A developer who writes a ticket in Linear, tags it with a few labels and walks away can now come back to a finished pull request on GitHub, with tests, lint, typecheck and build already green. That is the premise of an open-source orchestration system built around Claude Code and T3 Code: a "software factory" in which AI agents handle triage, investigation, implementation and verification on their own, and a human is pulled in only when a ticket is ambiguous or a change cannot be fully verified. The interesting part is less the automation itself than the decision about exactly where the human lets go and where the human keeps a hand on the wheel.

The chef and the line cooks

A software factory, in this framing, is an automated development environment where agents use standardized tools, workflows and project knowledge to build, test and maintain software. The common misreading is that such a system is "build once, fire and forget." The argument here is that fully hands-off coding fails in practice: like a house whose load-bearing walls have been removed, a pipeline without human direction and guardrails sees its output quality collapse.

The division of labor borrows an analogy from the creator of P-Stack, an engineer who previously worked on Cursor and reports shipping 2,500 pull requests to production in a single month at SpaceX and xAI. Picture a commercial kitchen with one executive chef and ten line cooks. The chef does not boil every pot of noodles or taste every ingredient. The chef orchestrates, delegates, checks quality and steps in to adjust seasoning when a dish needs it. Mapped onto software, the engineer is the chef and the coding agents are the cooks doing the repetitive execution.

Executive chef tasting a dish at the pass while ten line cooks work at their stations

▲ The chef-and-line-cooks model of agent delegation

Two failure modes sit at the extremes. Micromanaging every generated line defeats the speed advantage of using agents at all. Letting agents run blind, with no continuous context and no final sign-off, produces the collapsing house. The old manual workflow sat closer to the first extreme: open an agent such as Cursor, Claude Code, T3 Code or Codex, prompt it to investigate, watch it write code, test by hand, open a pull request and merge. The developer was effectively a human "continue" button.

The pipeline from ticket to merge

Instead of arbitrary prompts, the factory forces every request through a fixed sequence of stages, which also appear as columns on its jobs board.

Stage What happens
Ticket A Linear issue is created and labeled; a webhook fires
Triage An agent judges whether the task is actionable and well defined
Investigate The agent reproduces the issue or explores the codebase
Implement Test-first implementation of the change
Verify Lint, test, typecheck and build run; failures loop back to Implement
Pull request and CI A PR opens on GitHub with a confidence rating and work summary
Merge Auto-merge when confident, or hand-off to human review

The two human checkpoints are deliberate. At triage, a vague ticket is not guessed at; the agent pauses, comments on the ticket with concrete options and moves the job to a "Waiting on you" column and a central inbox. At merge, two paths exist. If continuous integration is green, no review bot has flagged problems and the agent reports high confidence, the pull request merges automatically. If the agent reports lower confidence, hits unclear edge cases or cannot produce complete evidence, the PR is assigned to the human for review and any architectural correction. Repository defaults in the demo included cloud execution, Claude Code as the harness, merge-when-confident, mandatory Bugbot security reviews and a maximum diff size of 300 for automatic merges.

The pipeline from ticket to merge No Yes Yes No Linear issue createdand labeled Triage: pause and askif the ticket is vague Investigate: reproduceor explore the codebase Implement: test-firstchange Verify: lint, test,typecheck and build Checks pass? Open PR with confidencerating, wait for CI CI green andconfident? Auto-merge Human review
▲ The pipeline from ticket to merge

Verification is the precondition for autonomy

Automatic merging only makes sense if agents can test their own work in a repeatable, deterministic way. Two tools cover that here.

P-Stack is a framework of playbooks, skills and helper roles that gives agents structured operating guidance. An entry-point router reads a ticket's constraints and routes it to a playbook for feature work, bug fixing or investigation. The instance used in this system contains 23 playbooks, 58 skills and 12 agent role definitions. Each playbook forces a scoping phase, focused execution and verification against objective evidence before the agent is allowed to claim completion. Its verification skills can launch the application, drive interactions, read console and CLI output and clean up afterward.

TestSprite handles end-to-end browser testing for web applications. The problem it addresses is context: when a coding agent drives a browser itself, repeated screenshots and DOM dumps can consume the entire context window. TestSprite instead explores the running app, builds a test plan, runs it across parallel testing agents (up to 96 at once) and returns a compact structured JSON report with failed steps, visual evidence, root-cause notes and suggested fixes. In one example, it caught a Stripe fee calculation that omitted a $0.30 fixed fee, producing $97.10 instead of $96.80 on a $100 price, and handed the exact component fix back to the coding agent. In one real-world test, offloading browser tests cut token usage by roughly 50%, which worked out to more than $20 saved per coding day. Those are figures from one workflow; savings will vary with tooling. An open-source CLI lets a terminal-based agent trigger the suite directly.

Isolated workspaces, locally or in the cloud

Running several agents against one repository at the same time only works if they cannot collide. Locally, each task gets its own T3 Code thread and a fresh git worktree, a separate working folder with its own checkout, so parallel sessions never produce dirty-tree conflicts. In the cloud, each job boots its own sandbox on Modal from a standardized worker image with pinned versions of T3 Code, Claude Code, Codex, P-Stack, the reporter and the project playbooks. Modal keeps warm images per repository with source pre-cloned and dependencies installed, so startup is fast, and this path offers effectively unlimited horizontal concurrency.

Six glass pods with robots coding, four active and two hibernating, linked to a control cabinet

▲ Isolated sandboxes with idle hibernation

One cost control stands out: a sandbox that sits idle for five minutes, typically while waiting for a human answer or a PR review, hibernates automatically and resumes with its exact state intact when the reply arrives. Modal is described as powerful with a generous free tier, though other sandbox providers may be faster or cheaper.

The plumbing underneath

The system has three custom primitives. The Runner is a background script on a local machine (a Mac Studio in this case) that watches for new ticket events, claims them within milliseconds, reads the labels to decide local versus cloud execution, starts threads or containers, monitors health and cleans up worktrees. It is a foreman; it never writes code itself. The Reporter listens to every thread and streams stage transitions, token counts and dollar costs. The Panel is a Vercel-hosted dashboard with board and list views, an events feed with timestamps and a machines page showing load, memory, disk and active subagents for each connected runner.

Neon ties it together as a serverless Postgres backend. Webhooks from Linear land in an ingest function, are logged into an immutable events table, and Neon's native real-time sync pushes every new row to the runner and the dashboard without polling or a custom WebSocket server. GitHub webhooks flow back the same way, so a merge on GitHub moves the job to the Merged column within seconds. Linear was chosen for its clean issue-state transitions, but any source that emits webhooks could feed the factory; Slack is already wired in, with GitHub Issues and others planned.

Labels do the routing. A ticket carries a trigger label, a repository label, a "Runs on: Cloud" or local label and, optionally, a harness override such as Codex, Antigravity or Claude Code. Global settings pick the default harness and model; Claude Opus 5.5 is treated as the most capable choice for autonomous engineering, with Claude Sonnet 5.5, Claude Haiku 5.5 and Claude Fable 5-1 also available. Onboarding a repository is itself automated: an agent clones it in a sandbox, infers the install and check commands, and opens a PR with a .factory/setup.json recipe (for the demo repo, "bun install --frozen-lockfile" plus lint, test, typecheck and build).

What three tickets looked like in practice

Three Linear issues went in at once against a small recipe-book app. A favorites feature (star buttons persisted in local storage) moved quickly through triage into implementation, producing a new component with tests. A total-cooking-time feature reached verification in a Modal sandbox and passed 4 of 4 checks, with the build step reporting 145 ms and a run cost of about $0.35 to $0.38. The third ticket, deliberately vague ("Make the recipe book nicer"), was caught at triage and parked in "Waiting on you" with three scoped options: visual polish only, search and filter discovery, or an ingredient-focused reader view. Typing "Let's go with A" in the inbox sent the job back to the queue and on through investigation and implementation, ending as PR #6.

Two details show the system's limits honestly. The cooking-time PR did not auto-merge despite the agent's confidence, because the runner image lacked the browser libraries needed to render the app and capture screenshots. Since verification could not be completed empirically, the safety rule fell back to human review, and the PR was squash-merged by hand on GitHub. The second is cost of construction: building and refining the factory consumed roughly $3,000 in LLM tokens, and the project is described as a work in progress with active bugs. When something needs a closer look, an "Open in T3" button generates a pairing link, valid for 15 minutes, into the live Modal container, where the developer can inspect subagent logs and steer the agent through chat.

What to take from this

The core idea is that autonomy comes from structure, not from a bigger prompt. Unstructured "vibe coding" is dismissed here as a slot machine; the factory replaces it with a state machine whose loops only advance on evidence. The human role moves from typist to orchestrator with two explicit interrupts: unclear tickets at the front and unverified changes at the back.

For anyone trying a similar setup:

  • Write tickets that are specific and testable; vague ones will stall at triage by design.
  • Define a machine-readable setup recipe with frozen-lockfile installs and the full check suite.
  • Enable automatic merging only alongside complete checks, protected branches and a review bot.
  • Give every agent its own worktree or container, and hibernate idle sandboxes.
  • Make sure sandbox images include browser dependencies if agents must verify UI visually.
  • Keep an inbox where a one-line, multiple-choice answer can unblock a paused job.

The whole stack is published as open source, so the blueprint is available to copy, adapt or contribute to.