Research prototype · results are early, see below

Many agents, one codebase, one seam.

SEAM — Software Engineering Agent Merge

SEAM runs several coding agents on one goal in parallel and integrates their work into one real git repository. Its focus is the part most multi-agent coders skip: autonomous integration. No two agents touch the same files, every change passes an independent review and the full test suite before it merges, and a true semantic conflict is escalated to a human rather than silently merged.

View on GitHub Read the design

What SEAM guarantees

Each rule is enforced by the engine, not by asking the agents nicely.

Disjoint file scopes

Every task declares the files it may touch. The atomic claim never lets two in-flight tasks overlap, so most merges stay trivial.

No silent scope escape

A worker that needs files outside its scope stops and asks the lead, which re-checks disjointness before granting.

Two gates before merge

An independent review of the diff against the spec, then the full test suite on the merged tree. Two distinct runs.

One merge at a time

A single global merge slot. Each merge moves main; the next one is tested against the new main.

Escalate, never auto-resolve

If the merged tree fails with no textual conflict, the task goes to a human. Main never receives the break.

Crash-safe, bounded

The merge commit is recorded before main moves; review retries are capped; there is no infinite fix loop.

How it works

LEADA goal becomes typed, file-scoped, dependency-ordered tasks — from a hand-written plan, or drafted by an LLM planner that reads the repo in the sandbox.

TASK STOREAtomic claim: matching type, dependencies merged, scope disjoint from every in-flight task.

WORKERSClaude Code headless, one git worktree and branch per task, each in its own Docker container. Many run in parallel.

REVIEW GATEDeterministic checks first (reviewer ≠ author, in scope, the task's own tests green), then a tool-less LLM reviewer judges the diff and the original files against the spec.

MERGE ENGINEOne task at a time: trial merge, then the FULL suite on the merged tree. Green → main moves. Red or conflict → needs_human.

Safety model

Everything in a container

Worker runs, every test run, the merge-time suite and the planner execute in Docker, never on the host. Test runs have no network.

Agents never hold your key

Agents sit on an internal network whose only host is SEAM's credential proxy. They get a placeholder; the proxy forwards only model calls to the Anthropic API.

Agents never run git

SEAM stages and commits their edits with git hooks disabled; a worktree's .git is mounted read-only.

A reviewer with no tools

The reviewer reads the spec, the diff and the original files and returns a verdict. It cannot execute or edit anything.

The proxy also meters every response's token usage and refuses generation once the run's token cap is spent, so a compromised agent can spend quota only up to that cap.

Results so far

Real agents (Claude Code workers, an Opus reviewer), October 2026. Full detail in the design doc, §8, §11 and §12.

Run	Outcome	Cost
Toy repo, two disjoint tasks	merged 2/2 zero human touch; two workers in parallel	≈ $0.05
Toy repo, semantic conflict	escalated caught by the merge-time suite; main never broke	$0.21
boltons: 8 independent features	merged 8/8 807 tests green on master	$0.67
boltons: 5 tasks with dependencies and a shared file	merged 5/5 right order; reviewer rejected 2 real bugs, both fixed on retry	$1.35
LLM planner on the boltons goal	valid plan right dependency; found the cross-module coupling on its own	$0.07
That plan, run unedited	merged 2/2 but 2 test-passing defects shipped (one inherited from a boltons bug)	$0.47
LLM planner on the 8-feature goal, run unedited	merged 8/8 same plan as the hand-written one; probes found 1 defect, inherited from a boltons bug	$1.44

What these do not show

An escalation rate on real code. No real-code task has escalated yet; the plans so far were written by the AI that built SEAM. The LLM planner exists to measure this honestly.
A reliable reviewer. A single LLM review let a significant, test-passing bug through about half the time. Adversarial probe tests caught every buggy version but also rejected 3 of 4 correct ones, so they are opt-in.
Anything statistical. Each result is one to three runs, on repos and tasks chosen by the project's author.

Get started

Needs macOS or Linux, Python ≥ 3.11, Docker (on macOS e.g. Colima; keep repos under $HOME), Claude Code on the host, and exactly one credential: CLAUDE_CODE_OAUTH_TOKEN (from claude setup-token) or ANTHROPIC_API_KEY.

pipx install seam-merge        # or: uv tool install seam-merge
seam image build
read -s "CLAUDE_CODE_OAUTH_TOKEN?token: " && export CLAUDE_CODE_OAUTH_TOKEN

# the happy-path case on a throwaway repo (the examples live in the source repo)
git clone https://github.com/sc0Vu/SEAM && cd SEAM
examples/greeter/make_repo.sh ~/seam-demo/case1
seam run --repo ~/seam-demo/case1 \
    --plan examples/greeter/case1.json --state-dir ~/seam-demo/case1-state

# or let the planner draft a plan for your goal, review it, then run it
seam plan --repo ~/my-clone --goal "…" --out plan.json

SEAM moves the target branch itself: always run it on a dedicated clone. See the README for every command and option.