Product

Try Intent-System

Keep the reasons behind AI-written code, and send every change to a reviewer that didn't write it. intent-cli works with the coding agent you already use — Claude Code, Codex, Cursor, Copilot, or OpenCode.

It is open source (Apache-2.0) and needs no server: intent, assignments, and progress live as files in git and on GitHub. v0.32.0 is the current stable release. Start with a single question about one feature, and go further only when it pays off.

Start with one feature→Choose how far to goView on GitHub
StatusOpen source · intent-cli v0.32.0 released · start with 1 thread + subagents
live
We use it ourselves

intent-cli is built with intent-cli

Today its own development runs as a single seat: one conductor, a fresh subagent for each independent review, and a second review by another vendor's model. Every PR keeps those review records, so you can check the workflow 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 its recorded reviews →

Install

With Node.js — no .NET SDK needed:

npm i -g intent-system

Or as a .NET global tool:

dotnet tool install -g JTechJapan.IntentSystem.Cli --version 0.32.0

Check with intent-cli --version (it should report 0.32.0). You don't need to learn its commands: your agent asks intent-cli what to do next and runs the steps.

Install details: self-contained binaries, preview channel →
First try · no setup

Let it question one feature you're about to build

Open your coding agent in a repository you care about and paste this, with a real feature in place of <topic>:

Grill <topic> with intent-cli.
Keep asking me one question at a time until the intent is packet-ready.

What happens: your agent reads intent-cli's grill guide, studies your existing code and docs first, lists the open questions in dependency order, and asks you the most blocking one — one decision at a time, without making you repeat what the repository already says.

grill itself is read-only: it writes nothing and publishes nothing. To keep your answers as decision records, the host needs to be initialized (intent init) with a domain; an issue comes later, from a packet drafted from those records. Both are part of the next step.

Next: choose how far to go

Which of these is you?

Recommended · start here1 thread + subagents
One conversation takes each unit from intent to a merged PR and starts a fresh subagent to review every change. Run it in the Claude desktop app, Claude Code, or an Orca Run.
Go →
Several units at onceA multi-seat team
Design, orchestrator, implementation, and review each get a seat, side by side in herdr. Orca Runs can be recorded too.
Go →
No code from youShape intent, hand off the build
Publish well-formed issues for another team, a vendor, or a person to implement.
Go →
Already using itUpgrade to v0.32.0
What changed, and what to check after you reinstall.
Go →

One seat or several: how the two setups differ

1 thread + subagents (solo-conductor)Multi-seat team (four-thread)
Who does the workOne conductor seat plays architect, orchestrator, and builder.Design, orchestrator, implementation, and review each hold their own seat.
Who reviewsA fresh, independent subagent for every review and re-review. The conductor starts it.The review seat.
What you set upInitialize the host and record the mode. No seat roster and no supervision cycle.Also record a session transport and the topology of every role.
Parallel workOne unit at a time.Seats work side by side.
Good fitWhere we recommend everyone starts — and how intent-cli itself is built. Needs a runtime that can start isolated subagents.Several streams of work at once, where separate seats keep design, delivery, and review apart.
StatusReleased as a preview-through-1.x capability.Released.

intent-cli supports both, plus a five-thread team (four seats and an optional Steward relay). Both start from the same install and host initialization, and the team mode can be changed later, so start with one thread and add seats only when you need several units in flight.

Recommended · 1 thread + subagents · solo-conductor

Take one unit all the way to a merged PR

solo-conductor is the single-seat team mode. Your one thread — the conductor — plays architect, orchestrator, and builder. Reviews stay independent: for every review and re-review, the conductor starts a fresh subagent that did not write the change, and its verdict is recorded as an independent review.

Run the thread wherever you already work — the Claude desktop app, Claude Code in a terminal, or an Orca Run — and let it start its own reviewer subagents inside the same session. There is no transport, pane layout, or seat roster to set up. How 1 thread + subagents works →

What you have after the first unit

A packet written from your intent, a GitHub issue published from it, a pull request, an independent review recorded on that PR, a merge after CI passes on the reviewed commit, and a closeout that feeds the next unit. Every step is visible in git and GitHub.

Hand this to your agent

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.

What your agent will run

  1. 01
    Initialize the host

    intent init, dry-run first and then --write — the same flow as every other setup.

  2. 02
    Record the mode
    intent-cli team-mode set --domain <domain> --team <team> --mode solo-conductor --write
  3. 03
    Confirm it

    intent-cli guide bootstrap --domain <domain> --team <team> reports solo-conductor-team-bootstrap in state solo-conductor-complete.

  4. 04
    Run the ten-step loop for each unit

    intent-cli guide solo-conductor lays out the loop — design claim, packet, issue, implementation, PR, independent review, fixes, merge, closeout — and the rules that keep the reviewer independent.

Optional: a second opinion from another vendor

Declare the team under [[cross_runtime_review.teams]] in .intent-cli/config.toml. On the repositories that declaration lists, approving a PR then needs a verdict from a different runtime — Codex, Claude, Cursor, Copilot, or OpenCode — recorded against the PR's current head commit, and publishing an issue through publish-flow needs a design verdict on the packet. intent-cli renders the reviewer prompt and records the verdict; your seat runs the reviewer. This is how intent-cli itself is reviewed today.

These gates keep an honest workflow honest; they are not a security boundary. Other routes, such as gh pr merge, are not gated.

Limits: one unit at a time, and only on an agent runtime that can start isolated subagents — if yours cannot, use the multi-seat setup. Already running the conductor in an Orca Run? It can be recorded for the solo team as well (session-layer topology record-orca-run).

Sharing the host with other machines or seats? Upgrade every intent-cli that reads it to v0.32.0 before you record the mode. 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 GitHub→The full explanationsolo-conductor specification
Several units at once · multi-seat team · herdr

Give each role its own seat

The four-thread model is the multi-seat model: design shapes intent, the orchestrator coordinates, implementation delivers the pull request, and review checks it. Design can stay in your current conversation; the other roles get their own panes and folders, so you can watch them work in herdr.

1. Pick your onboarding pattern

Two questions decide it: does the host metadata live in a separate repository or on a branch of the same one, and is the project brand-new or existing? That gives four patterns, each on its own self-contained page with paste-ready prompts.

2. Record a session transport

If every agent runs on one machine, record herdr-only — it has fewer dependencies:

intent-cli session-layer set --domain <d> --team <t> --mode herdr-only --write

agmsg + herdr is deprecated. It still works, and removal is planned only after current users have been checked. It is also the default when nothing is recorded, so record your choice explicitly. Neither transport is the primary one.

3. Ask your agent to build the team

Start this work in a herdr-only four-thread team for <owner>/<repo>.
Use intent-cli's bootstrap guide, ask me for the CLI/model for each seat and the application kind, and emit commands only.
After I approve, I will run herdr, provider, and scheduler commands; record and validate the topology, then report the first verified handoff.

Also in v0.32.0

  • Orca Run records. intent-cli session-layer topology record-orca-run links an Orca Run you already use to its seat; session-layer topology orca-runs reads it back. intent-cli never runs orca or creates a Run.
  • Cross-runtime review works for multi-seat teams too — see the single-seat section for how the gates apply.
  • Supervision is opt-in. A standing supervisor is set up only for teams listed in [supervision] opt_in_teams.

The three-thread timer loop remains a simpler supported alternative. See the alternative →

Choose your pattern on GitHub→Orchestration contractHow the team is wired
Rolling this out across a team?

intent-cli is free to use. If you'd rather not work out the first rollout alone, J-Tech Japan offers paid, hands-on support on your own codebase: Intent Storming facilitation to seed your intent tree, pair programming, and help setting up the team.

Support & consultation →
No code from you · authoring-only

Shape intent and publish an issue without writing code

With team_mode=authoring-only, you can shape intent and publish an issue without writing code. The agent interviews intent and authors packets; implementation may be handled by another team, a human, or a vendor. This mode has no delivery topology or delivery seats, and delivery supervision does not apply.

Use team_mode=authoring-only for <domain>.
Interview me about intent, author the packet, and ask for approval before publishing the issue.
Do not create delivery topology or seats; report the authoring audit and external handoff.
Already using it

Upgrading to v0.32.0

From v0.31.0, v0.32.0 brings 42 units of work; from v0.32.0-preview.4, nine. Reinstall with either install command above, then check the items below that apply to you.

  • Supervision is opt-in. Existing records no longer opt a team in; add it to [supervision] opt_in_teams if you want a standing supervisor.
  • stalls.jsonl is now runtime-local. If your host tracks it in git, run intent-cli notify supervise repair-cycle-history --domain <d> --team <t> --write to untrack it while keeping the file.
  • agmsg + herdr is deprecated. It still works; record herdr-only when you are ready to move.
  • A PR sent back for changes can return to review. request-update now removes intent-pr-approved (G824).
  • Body checks before GitHub writes. The seven routes that send an issue or PR body through gh (three gh api --input, four gh --body-file) refuse malformed bodies and bodies over 65,536 bytes, and size is shown before a write with a warning from 58,000 bytes. Both numbers are intent-cli's own conservative limits, not verified GitHub boundaries.
  • Coming from v0.32.0-preview.2? The preview.2 deadlock where a team-owned unit could not be worker-claimed on a claims-enabled host is fixed (G815).
  • Planning to try solo-conductor? Upgrade every intent-cli that reads the host before you record the mode (see the single-seat section).
v0.32.0 release notes→GitHub release
Current v0.32.0 capabilities

The released contract, in one place

Released baseline

intent-cli v0.32.0 is the current stable release. A team records one of three team modes: solo-conductor (one thread plus a fresh review subagent per review, the recommended start), delivery (a multi-seat team for several units in flight), or authoring-only. The three-thread timer loop remains a supported alternative.

Install channels

npm i -g intent-system installs the intent-cli command with no .NET SDK required; the .NET global tool is JTechJapan.IntentSystem.Cli. intent-cli update derives its channel from the executable path.

Cross-runtime review

For a team declared under [[cross_runtime_review.teams]], on the repositories it lists, PR approval needs a verdict from a different runtime (Codex, Claude, Cursor, Copilot, OpenCode) recorded against the current head commit, and publish-flow needs a design verdict on the packet. intent-cli renders the prompt and records the verdict; it never launches the reviewer. The gates are not a security boundary.

Acceptance and supervision

Guide primacy is an acceptance rule: a capability whose guide route is missing or wrong is not shipped. Supervision is opt-in per team ([supervision] opt_in_teams) and corroborates findings within the cycle before escalation.

Session choices

For collocated multi-seat teams, herdr-only is recommended because it has fewer dependencies. agmsg + herdr is deprecated: it still works and remains the default when nothing is recorded. Neither transport is primary. An Orca Run you already use can be recorded against a seat or a solo team.

File-backed delivery

Declare delivery_method: file-backed to persist a durable, addressable task envelope and deliver a one-line pointer. Without that declaration, delivery remains inline.

Named branch lanes

A lane comes from the registry/default or an explicit packet draft --lane choice. This is a released preview-through-1.x capability, not a 1.0 compatibility guarantee. The packet records branch_lane and routing_snapshot; intent-cli proposes and records the lane but does not create or manage branches.

Git-backed multi-user claims

claim acquire and claim verify use immutable Git-backed records under .intent-cli/claims/. This is a released preview-through-1.x capability, not a 1.0 compatibility guarantee. Only the successful plain push owns the claim, so claim before scaffold and verify ownership before work proceeds.

Prompt class and scope

Prompt policy uses literal prompt classes and scoped approval, including answerable_by, a hard non-overridable risk floor, and live-dialog compare-and-swap. This is a released preview-through-1.x capability, not a 1.0 compatibility guarantee. Unknown or unmatched cases escalate instead of guessing.

Authoring-only team mode

With team_mode=authoring-only, you can shape intent and publish an issue without writing code. The agent interviews intent and authors packets; implementation may be handled by another team, a human, or a vendor. This mode provides no delivery topology or delivery seats; delivery mode remains the default, and delivery supervision is not applicable in authoring-only mode. This is a released preview-through-1.x capability, not a 1.0 compatibility guarantee.

Command-emitter boundary: intent-cli supplies deterministic guidance and records or verifies workflow state. The coding agent or operator runs herdr, providers, and any scheduler after the relevant decision; intent-cli does not launch them, operate herdr, or register a scheduler.

Community & support

Join the J-Tech Japan OSS Discord for community questions and discussion — answers there are free. File reproducible bugs and actionable feature requests as GitHub issues.

For hands-on adoption — pair programming, pair storming, Intent Storming facilitation against your own codebase — J-Tech Japan offers paid consultation.

Join the Discord→Support & consultation

Learn the methodology

The methodology stands on its own, with or without the tool. The three proposals — Compass, Git-AI-Flow, and Intent Storming — are independent of any product, and you can apply them to your existing toolchain today.