A ticket in. A pull request out.

One press of Build end to end. Ensemble gives your own Claude Code or Codex the ticket, your docs and your code, in a sandbox on your machine. It refines the ticket, plans, builds, reviews its own work in rounds and opens the pull request.

  • The sandbox holds every repository in the workspace, the ticket in full, your Claude notes and your reference documents.
  • The agent has a shell in the sandbox, but no GitHub credentials, no Docker socket and no way to change your own files.
  • Its changes leave as a patch. Ensemble pushes them from your machine, when you say so.

One click, ticket to pull request.

How the build works

One press runs it to an open pull request. Or step through it by hand, and nothing happens until you press. The same agent and the same sandbox, either way, and no context to paste or prompt to write.

In one click

  1. Refine and plan

    Your agent reads the ticket against your docs and your code, updates the acceptance criteria where they fall short, and plans the change.

  2. Build

    Your Claude or Codex writes the change in a sandbox on your machine.

  3. Review in rounds

    Claude and Codex review the branch against the new criteria. The agent fixes what they find, and they review again.

  4. Open the pull request

    Its description says what the review found and what was fixed.

  5. Update the ticket

    The ticket gets the new criteria, and a plain-English comment that links the pull requests.

Steps 2 and 3 repeat, 4 rounds by default (1 to 6). They stop early when a round finds nothing open.

The review rounds are on by default

At Start, After the build: review and fix, then open the pull request is ticked, so you settle the plan and the rest runs by itself. Tick Approve the plan automatically too, and Start is the only press.

What the rounds do

The review uses your workspace’s AI review setting. With Claude and Codex, both review at once, without seeing each other’s findings. The agent may say a criterion does not apply; the next check judges that. GitHub gets only the commits, one status per round and the pull request; a teammate’s Ensemble shows that you are building the ticket.

When a round leaves something open

After the last round the pull request opens anyway, and its description lists what is still open. Over your spend budget, the rounds pause until you press Continue.

The ticket, updated

After Build end to end opens the pull requests, Ensemble writes the description and criteria the plan changed, and comments on the ticket as you, in plain English. It never changes the ticket’s status.

By hand

  1. You

    Press Implement

    On the ticket’s story view, from This Sprint. Then Start.

  2. Agent

    It plans first

    It reads the ticket, the code, the data and your reference docs, and writes a plan. It changes no files.

  3. You

    Settle the plan

    Each point: Agree, Keep the story or Reply. Then Approve and start.

  4. Agent

    It builds in the sandbox

    It writes the code, runs the repositories’ own tests and reports on each criterion.

  5. You

    Read the diffs

    One diff per pull request, in plan order. Ask for changes in the conversation.

  6. You

    Push

    A new branch and a new pull request, under your GitHub account. A draft by default.

Fill gaps

A ticket already under way can still miss criteria. When its story check found gaps, the story view offers Fill gaps in place of Implement. It is the same session, but the plan and the build cover only those gaps.

What you need

A container runtime on this computer: Docker, Podman, Colima, OrbStack or microsandbox. Claude Code or Codex, signed in. An issue tracker connected to the workspace, so the ticket can be read.

The story check

Not “is the code right?”“Does this work do what the ticket asked for?”

Criterion by criterion, against the code.

The story check reads the ticket from your tracker, and every open and merged pull request that names it, in any of your repositories. It is one check per ticket, so a ticket split across three pull requests gets one answer.

Met A pull request does it. The check names which one, and the evidence.

Met outside code changes A person’s comment on the ticket says it was done another way.

Partly met Some of it is there. The check says which part is not.

Not met It is in none of the pull requests. The check says where it belongs.

Can’t tell from the code The code cannot show it, or a pull request could not be read.

Two more lists: Asked for outside the criteria, what the title or description asks for that no criterion names; and Not asked for, work in the pull requests the ticket does not ask for.

How the code meets each criterionPAY-142 Partial refunds
  1. MetAC1Partial refund keeps the order open
  2. Partly metAC2Customer gets one email
  3. Not metAC3No refunds after 30 daysNo pull request claims this.
  4. MetAC4Refund reaches the daily ledger

How the code meets each criterion

The story view lists the pull requests that move each criterion forward, merged or open, with one line on how. Open a line for the whole of it and the files. No new model run: it uses the story check’s status and each pull request’s description.

A criterion no pull request claims says so. A pull request pushed since its description is listed apart until the next check.

Check against docs

In the story view, Check against docs reads the ticket’s story and criteria against your reference library: specifications, design notes, policies. It says Matches the docs, Partly matches the docs or Goes against the docs, and what to do. Every point must quote a section of your library, and Ensemble checks the quote is really there. A point without one is dropped, never shown.

One ticket, drawn.

For a ticket with two or more pull requests, the story view draws a Ticket design: who touches the data across the top, each step down the page in the order it happens. Each box and each step names the pull request that does it. The model works the flow out from the code. A ticket with one pull request shows that pull request’s own design.

Read them together

The story check says criterion 3, “No refunds after 30 days”, is not met. The design agrees: no step checks the 30 days.

Step 7 sends one email. The story check still says the retry path sends two. The design shows the main path, not every branch.

Click a step in the app to open its file in the pull request’s Changes tab.

Verify the results.

An agent wrote this code. Ensemble checks some of what it says, and labels the rest as the agent’s or the model’s. The rest is yours to check, as for any pull request.

The agent says

The build report: per pull request Done, Partly done or Not done, the checks it ran (Passed, Failed or Not run), and each criterion. It is the agent’s own account. It never holds back Push.

Ensemble checked

Every piece of evidence in the plan, on your machine; a point it cannot check is left out, and one line says how many. Every docs quote. Before a push, that the commit is the change you reviewed.

The model worked out

Each criterion verdict, and the design. “Can’t tell from the code” means the code cannot show it, or could not be read; it is never turned into “Not met”. A design marked Drawn for an earlier commit. is out of date.

Before you merge

  1. Read every diff. The report is not a review.
  2. Look under What Ensemble left out: edits in a repository the plan did not name.
  3. Check each “Met” against the code it names. Read every “Partly met” and “Can’t tell from the code”.
  4. Find the main path in the design, then check each step in its file.
  5. Run the tests yourself, and try the change the way a user would.
  6. After review rounds, read Still open in the description, and each point the agent pushed back on in the build tab.
  7. Then review it like any other pull request. Your auto review skips the commit the rounds already reviewed, so ask a teammate. Merging is yours.

Build your next ticket.

Run it on your machine, sign in to GitHub with gh and to Claude Code or Codex.

npx ensemble-review