ProductRecommended start · one thread + subagents · solo-conductor

One thread runs the whole loop. A fresh subagent reviews every change.

This is how we run intent-cli ourselves, and where we recommend you start. One conversation with your coding agent — the conductor — takes each unit from intent to a merged pull request. Whenever there is something to review, the thread starts a new subagent that did not write the change. No panes to arrange, no transport to run, no seat roster.

Set it upSee the loopWhere to run it

Released in intent-cli v0.32.0 as a preview-through-1.x capability. intent-cli supports three team shapes — this one, the four-thread team, and the five-thread team (four seats plus an optional Steward relay) — and you can move between them later.

One thread + subagents · solo-conductorv0.32.0 · RELEASED
You

Answer scope, version, policy, and default decisions. Everything else proceeds on the thread's recommendation and is recorded.

The thread · conductor
ArchitectOrchestratorBuilder
  1. Claim the unit, start from a ruling or bug chain
  2. Write and check the packet
  3. Publish the GitHub issue
  4. Implement in an isolated clone, open the PR
  5. Hand the PR to a fresh reviewer
  6. Fix, then a new reviewer checks the delta
  7. CI on the exact head, then merge
  8. Close out and write intent back

Runs where you work: the Claude desktop app, Claude Code in a terminal, or an Orca Run.

Reviewer · fresh subagent

Started by the thread for every review and every re-review. Never reused.

  • Gets: packet, review context, PR body, read-only clone
  • Never gets: the implementation conversation
Optional · second runtime

A reviewer from another vendor, e.g. Codex reviewing what Claude wrote.

Host gitintent, packet, claims, rulings, closeout writeback
GitHubissue, pull request, review verdicts, merge
Where to run it

Run the thread anywhere. Let it start its own subagents.

Run the conductor wherever you already work with your agent — the Claude desktop app, Claude Code in a terminal, or inside an Orca Run. The reviewer subagents are started by that thread itself, inside the same session. That is what makes it efficient: there is nothing else to launch, keep alive, or wire together, and the reviewer still sees only what it should.

  • Using Orca? Record the Run you already use for the solo team with intent-cli session-layer topology record-orca-run. intent-cli never runs orca or creates a Run.
  • The runtime must be able to start an isolated subagent. If yours cannot, use a multi-seat team, where review has its own seat.
  • intent-cli never starts or manages an agent. It renders the contract, checks the gates, and records what the thread did.
Why one thread is enough

Less to run, and nothing lost

Nothing extra to run

One conversation is the whole team. There is no session transport, no seat roster, and no supervision cycle: once the mode is recorded, intent-cli's bootstrap check reports the team complete.

Reviews stay independent

Every review and re-review goes to a new subagent that is never reused. It receives only the packet, the review context, the PR body, and read-only clone paths — never the conversation in which the code was written.

It asks you only when it matters

The contract tells the thread to ask you only at scope, version, policy, or default decisions. Otherwise it proceeds with its stated recommendation and records the ruling in the host.

It picks up where it left off

Scope rulings and each unit's closeout writeback are kept in the host, so a compacted conversation or a brand-new session resumes from recorded state instead of from memory.

It merges only what was reviewed

Merge waits for CI on the exact head commit and a reviewer verdict on that same head. Any fix pushed after a verdict is re-reviewed as a delta by a new subagent first.

Every delivery gate still applies

Claims, publishing, review transitions, closeout, and evidence records work exactly as in a multi-seat team. One thread changes who does the work, not the rules.

The loop

Ten steps per unit, one unit at a time

intent-cli guide solo-conductor gives the thread this loop with the exact intent-cli, gh, and git commands for each step. You don't run them; the thread does.

#StepWhat happensWho
01Claim the unitThe thread takes the execution-unit claim as the design actor before writing anything.thread
02Start from a ruling or a bug chainA packet is written only from your recorded ruling or from a triaged bug — never from nothing.thread · you decide
03Write and check the packetDraft the packet, validate the issue body, run the facet check, and dry-run publication, reading every warning.thread
04Publish the issueSeed the queue from the packet, publish the GitHub issue, and record the publication.thread
05Switch to implementationRelease the design claim, take the implementation claim, and claim the published issue as the worker.thread
06Implement and open the PRWork in an isolated clone, run the full test suite, open the pull request, and record the worker completion.thread
07Independent reviewStart a fresh reviewer subagent with only the review inputs, and record its verdict on the PR as an independent subagent review.fresh subagent
08Fix and re-review the deltaFix blocking findings, push, and have another new subagent review the delta against the new head.thread · fresh subagent
09CI on the exact head, then mergeWait for CI on that head SHA, record the approved transition with it, and merge only that head.thread
10Close outClose out the PR, write the result back to the intent tree, record the evidence, and release the claim.thread

While CI and the full test suite run in the background, the thread investigates the next unit. A CI wait is bound to the head SHA and the run attempt, never to whatever ran last on the branch.

Roles

Who plays which role

  • Architect — the thread, under a design claim: writes packets and records rulings.
  • Orchestrator — the thread: publishing, queue and label transitions, closeout.
  • Builder — the thread, under an implementation claim, in an isolated clone.
  • Reviewer — a fresh independent subagent for every review, started by the thread.

Optional: hand the build to another CLI

The guide also renders builder command lines for Codex, Claude, Cursor, Copilot, and OpenCode, so the thread can run the build in the isolated clone with a different tool. That builder may edit and commit inside the clone but never pushes, opens a PR, or runs gh; the thread reviews the clone's diff before pushing. How tightly each builder is bounded differs by runtime, and the guide states what was measured.

Optional · a second vendor's review

Have another model family check the work

Declare the team under [[cross_runtime_review.teams]] in .intent-cli/config.toml. On the repositories that declaration lists, the thread records a verdict from the conductor's runtime and one from a different runtime (Codex, Claude, Cursor, Copilot, or OpenCode) against the PR's current head, and approval is refused until that gate is satisfied on that head. Publishing an issue through publish-flow likewise needs a design verdict on the packet. Both reviews run as the command lines intent-cli renders, in read-only clones; the thread launches them and records the verdicts.

The guide advises a reviewer model from a different vendor and model family than the conductor's; the gate does not check this. These gates keep an honest workflow honest and are not a security boundary — gh pr merge itself is not gated.

How we run it

intent-cli is built this way

intent-cli's own development runs as one thread with Claude Code as the conductor, and it declares cross-runtime review. Each PR carries two recorded verdicts on the same head commit — one from a Claude Code reviewer and one from a Codex reviewer — with their notes, in public.

As of 2026-09-22, 643 of the 891 merged pull requests in the intent-system repository are units cut and tracked by intent-cli.

See a PR with both verdicts →
Set it up

Install, then hand this to your agent

npm i -g intent-system

Open your coding agent in the repository and paste:

Set up intent-cli in this repository as a single-seat solo-conductor team.
Follow intent-cli's host initialization guidance (dry-run first) and ask me the decisions that are mine.
Before recording team_mode, confirm every intent-cli that reads this host is v0.32.0 or later.
Record team_mode=solo-conductor, confirm guide bootstrap reports solo-conductor-complete,
then run the first unit with intent-cli guide solo-conductor.
Start a fresh subagent for every review, and check with me before publishing an issue or merging.

On a host that is already set up, the short trigger phrase is: “Run this work as a solo conductor.”

What the agent runs

  1. intent init — dry-run first, then --write.
  2. intent-cli team-mode set --domain <domain> --team <team> --mode solo-conductor --write
  3. intent-cli guide bootstrap — it reports solo-conductor-team-bootstrap in state solo-conductor-complete, then asks you to accept the model and checks repository access, claims, and that the runtime can start an isolated reviewer.
  4. intent-cli guide solo-conductor — then the loop above, one unit at a time.

Sharing the host with other machines or seats? Upgrade every intent-cli that reads it to v0.32.0 first. An older intent-cli rejects a team-mode.json that contains solo-conductor, and the whole file then fails to load for every team on that host.

Single-seat setup on GitHubsolo-conductor specificationTry grill first, no setup
Limits and growing

When to add seats

  • One unit at a time. When you need several units in flight at once, move to the four-thread or five-thread team.
  • Moving is a recorded change: intent-cli team-mode set --mode delivery --write records the transition, and you then record a session transport and the topology of every seat. The change is refused while an Orca Run binding exists.
  • If an acceptance criterion has to change, the thread records that as an architect decision before merge.
The multi-seat teamAsk on DiscordHands-on adoption support
Try Intent-System