Foreman turns your dev loop into an AI assembly line: Vercel’s software factory ships reviewed draft PRs from a GitHub issue

What this project actually does

Foreman is, in plain terms, an "eve software factory" — a template from Vercel Labs that puts AI agents on every stage of your development loop while keeping a human firmly in the seat for the judgment calls. You drop a task into GitHub or Linear, and Foreman moves that task through four stations and hands back a reviewed draft pull request on your own repository. Your job is simply to glance at it, mark it ready, and merge. It takes over the repetitive, time-consuming implementation work without ever deciding the architecture for you.

Why it is blowing up right now

The "AI software factory" idea is having a real moment. Everyone is asking how to hand an entire development loop to agents, and Foreman lands exactly on that wave. It is a Vercel Labs project with a one-click "Deploy with Vercel" button, so you can be running in minutes. It ships under the MIT license, which keeps the barrier to entry essentially zero. And its "human-in-the-loop" framing is the part people trust: rather than letting an agent rewrite your codebase unsupervised, Foreman keeps the final approval gate in human hands, which is precisely the restraint that makes teams willing to try it.

Technical highlights

The genuinely interesting design is that Foreman splits the work into four independent stations, each its own agent with its own instructions, sandbox, and tools:

• Classifier triages the task first — type, priority, complexity, and whether it is even actionable. If the request is unclear, it goes back to the requester instead of building the wrong thing.
• Analyst turns the task into a plan with acceptance criteria, working from a live checkout of your repository.
• Implementer runs the plan inside its own sandbox, verifies against your repo's own checks (tests, build, lint), and pushes a branch.
• Reviewer judges everything only against the real diff, and crucially it never sees the Implementer's reasoning — an internal blind review that prevents the "I wrote it so I think it's fine" trap.

Even better, between runs Foreman keeps a "factory brain" — notes about your repository that every run starts from, so it learns your project the more you use it. Entry points are flexible too: label an issue factory, @-mention it on an issue or PR, delegate from Linear, hand it a task in the local TUI, or let it diagnose a red CI and push a fix to its own branch. It even posts an orienting comment on any new PR so human reviewers get a summary, not a wall of noise.

Who it is for

If your team already lives in GitHub and Linear, Foreman plugs in with almost no friction. Engineering leads can offload "triage the backlog and draft the first implementation" while keeping their hands on review. Solo developers get the same pipeline through the local TUI. It fits teams drowning in issues but unwilling to let an agent run completely loose.

Quick start

The easiest path is the "Deploy with Vercel" button, which wires up the GitHub and Linear connectors, a Vercel Blob store, and prompts you for FACTORY_REPO (the owner/repo it works on) and FACTORY_LABEL (default factory). To run locally: vercel link && vercel env pull && pnpm dev, then hand the TUI a task and watch the four stations fire in order.

A concrete walkthrough

Imagine you tag an issue "factory" that says "users report the password-reset email arrives twice." Foreman's Classifier decides it is actionable and medium complexity. The Analyst checks out your repo, finds the reset endpoint, and writes a plan with an acceptance test: "email sent exactly once per request." The Implementer spins a sandbox, adds a de-duplication guard, runs your test suite, and pushes a branch. The Reviewer only sees the diff and the test result, then posts a draft PR back on the issue. You read it, approve, and merge — the whole thing never touched your main branch until you said yes.

Where to be careful

Foreman is not magic. It works best when your repo already has real checks (tests, lint, CI) it can trust; without them the Implementer has no guardrail. It also assumes you are comfortable reviewing diffs, because the human gate is the whole point. If your task is vague or lacks acceptance criteria, the Classifier will bounce it back rather than guess — which is good, but means you still have to write clear issues.

How it compares to rivals

Against Devin, Cursor's background agents, and GitHub Copilot's coding agent, Foreman's difference is clear: it is not "one superhero agent going solo" but a "four-station pipeline plus independent blind review plus factory memory." It is natively wired into GitHub and Linear rather than living only inside an editor, and it leaves every merge decision to a human. If this had shipped six months earlier, I suspect several closed-source "AI programmer" products would have felt the pressure.