Governed delivery for AI coding agents.
Agents write the code. Intentline makes sure someone decided what to build, approved how, and can prove it works, with the record kept in your repository.
Desktop app for macOS, Windows and Linux. Runs on your own Claude subscription.
Recorded in the app: the requirements, the Issues mapped to them, and the code and tests that prove each one.
Same feature, two very different records.
An agent in a terminal is quick, and for a prototype that's fine. For software your business depends on, what matters is what you can show afterwards.
payments-core % claude "add a daily limit to SEPA instant transfers" ⏺ Update(src/payments/transfer.ts) ⎿ Updated with 12 additions … +40 more tool calls ⏺ Done. Edited 14 files. payments-core % git push origin limit payments-core % gh pr create --fill https://github.com/acme/payments-core/pull/57 payments-core %
mainOpen a Stage to see its recorddocs/sdlc/412-sepa-daily-limit/spec.md
REQ-1A transfer that takes the day’s total over the limit is rejected.REQ-2The app says why, and how much is left today.REQ-3The daily total resets at 00:00 CET.NFR-1The check adds under 40 ms at p95.
Screenshots of the running app, two variations
architecture.md · docs/adr/0031-read-daily-totals-from-the-ledger.md
NFR-1.In its own git worktree. Intentline did the push.
- Attempt 1src/payments/transfer-policy.ts and 13 more files, 5 tests citing REQ-nSent back: no test covers REQ-3
- Attempt 2Added test/daily-total.test.ts, citing REQ-3CI green
docs/sdlc/412-sepa-daily-limit/review.md
| REQ-1 | met | transfer-policy.test.ts:48 |
| REQ-2 | met | limit-notice.test.ts:12 |
| REQ-3 | met | daily-total.test.ts:7 |
| NFR-1 | 31 ms | limit.bench.ts:9, under 40 ms |
Agents do the work. You make the decisions.
Follow one Intent from a sentence to a merged Pull Request. The example is a payments change, but every kind of change runs the same way. Each Stage is a Claude Code session in its own git worktree that commits its document to the branch. Intentline does the pushes and the Pull Request. You only come in where there's a decision.
Animation of one Intent going through Intentline. You type the Intent "Enforce daily limits on SEPA instant transfers". Analysis writes four requirements to spec.md and waits for your approval. Design screenshots the app in two variations and variation A is chosen. Architecture draws a component diagram and records ADR-0031, then waits for your approval. With the spec, design and architecture in place, the PM Agent breaks the Intent into three Issues and drafts a Flow Proposal for Issue 412, which you approve. Implementation writes TypeScript code and tests that cite each requirement. Review finds that REQ-3 has no test and sends the Flow back; Implementation adds the test and Review passes with all four requirements met. CI goes green and you merge Pull Request 415. Every document is committed to the repository. The work spent 7.42 dollars of a 20 dollar Budget. At the end, the six Agents and you gather, each with what they delivered.
Every phase of delivery, each with its own Agent.
From the sentence you write to the merged Pull Request, a Flow runs through eight phases. In each one an Agent does the work in its own git worktree and commits what it made to the branch. The red marks are where it stops for you.

01IntentYou say what you want built
You write the goal in your own words, for one Issue or a whole feature. The
pmAgent fills in a title and a type if you leave them out.Intent #410
You write it
02AnalysisWhat exactly it must do
business-analystwrites each requirement with an ID and a fit criterion a test can check, and asks you what only you can decide.spec.mdCONTEXT.md- Rigorous +5 steps
Checkpoint: you approve the spec
03DesignHow it looks, in your real app
designerchanges your running app with throwaway code and screenshots it, in variations you choose between.design.mdscreenshots- Rigorous +4 steps
You choose a variation
04ArchitectureHow it will be built
architectdecides how the change fits your system, draws the components, and records each key decision with its reasons.architecture.mddocs/adr/
Checkpoint: you approve the design
05PlanIt becomes Issues, and a plan for each
pmreads the spec, design and architecture, splits the Intent into Issues in the order they have to land, and drafts each one’s Flow: Stages, Agents and a Budget.BreakdownFlow Proposal
You approve the Breakdown
06ImplementationThe code, and tests that prove it
software-developerwrites the code in its own git worktree, with tests that name the requirement each proves. It never holds your credentials.src/…test/…
Intentline pushes, CI runs
07ReviewProof it does what was agreed
reviewerchecks every requirement against the test that cites it, and sends the work back when one isn’t met, at most twice.review.mdrecordings
Sent back on its own when a check fails

08MergeDelivered, with the record behind it
Intentline opens the Pull Request. You merge it, or Auto-merge does once Review is clean and CI is green.
PR #415Delivery Report
You merge
The PM Agent leaves out the phases an Issue doesn’t need: a typo fix runs only Implementation and Review. The Product Agent drafts an answer to every Question an Agent asks.
When an Agent isn’t sure, it asks you.
An Agent doesn’t guess at what only you can decide. It stops the Stage and asks, with options and its recommendation. The Product Agent drafts an answer from your code and docs, and you can talk any question through with the Agent that asked before you send.
As much governance as the work needs.
The PM Agent proposes the Stages and stops from each Issue's complexity. You change them before you approve.
You decide at the plan and the merge.
You decide at the plan, Analysis, Architecture and the merge.
You decide at every step, each signed off by its named Owner.
The plan is approved before anything runs.
The Flow Proposal sets the Stages, the Agent for each, the Checkpoints and the Budget. Approving it also claims the Issue, so no teammate picks it up twice.

Every requirement can be traced to a test.
Each requirement’s ID follows it from the spec, through the design and the code, to the test that checks it and the Review that confirms it. Pick one and follow its route.
- 01Analysisspec.mdREQ-1 A transfer that takes the day’s total over the limit is rejected.
- 02Architecturearchitecture.mdThe check runs in
TransferPolicy, before the scheme call. - 03Implementationsrc/payments/transfer-policy.ts
checkDailyLimit()rejects with status RJCT, reason AM02. - 04Teststest/transfer-policy.test.ts:48
it("rejects a transfer over the limit")cites REQ-1. - 05Reviewreview.mdMet. Checked by the test at line 48.
One feature, three repositories, one plan.
Most products span several repositories, so one feature can need a backend service, a client app and an admin tool at once. You describe the feature once. Intentline gives each repository its own Issue and its own Pull Request, and keeps them in the order they have to merge. The example below touches three.
Intent #410, Enforce daily limits on SEPA instant transfers, is broken down by the PM Agent into one Issue per repository: #412 in payments-core, #87 in mobile-app and #30 in backoffice. #412's Flow runs first and its Pull Request merges. #87 and #30 wait for it, then their Flows run, each ending in its own Pull Request.
How an Agent sees the other repositories
For each Flow, Intentline packs the Agent’s environment: its own repository to change, and copies of the other repositories in the group, as they were when the Flow started, to read. It can’t change those copies, and pushing and the Pull Request stay outside it, with Intentline.
- Read + write
- its own repository, on its branch
- Read-only
- the others, at a pinned commit
A whole team on one Board, with no server to run.
Each developer runs Intentline on their own laptop. The copies stay in step through your Issue Tracker, here GitHub: taking an Issue assigns it to you there, and its label says where it stands. Everyone sees who is on what, and nobody works the same Issue twice.
One feature shared by three people. You plan it and the PM Agent splits it into three Issues in GitHub. You take #412, Ana takes #413 and Marco takes #414, each from their own Board, which assigns them in GitHub. Agents build each Issue on its owner's laptop at the same time, and GitHub shows everyone where each stands. Each Issue ends in its own Pull Request.
Your Board, halfway through
Hatched cards are teammates’ work. Your Board shows who took each Issue and where it stands, read from GitHub. Their Agents’ sessions and questions stay on their laptops.
Everything Intentline does.
Plan
- Flow Proposals drafted per Issue
- Budgets of $5, $20 or $60
- Model and effort per Agent or Issue
- Claims through the tracker's assignee
Large work
- Intents for goals, not tickets
- Breakdowns into Issues with blockers
- Project Groups across repositories
- Target branches like develop or release
Specify
- Requirement IDs with testable criteria
- Cited sources for every fact
- Mock-ups of your real running app
- Rigorous Analysis and Design
- ADRs committed beside the code
Verify
- Requirement results with file and line
- Review loops, at most two
- Risk decisions on record
- Sign-off Owners per Stage
- Auto-merge only when clean and green
Stay in charge
- Checkpoints to approve, redo or Rewind
- Questions with Suggested Answers
- Stage chat to ask an Agent why
- Stop a Stage and keep its work
- Feedback on a ready PR, triaged
Agents
- Project Agents as files, changed by PR
- Agent Library with versioned starters
- Skills and MCP servers per Agent
- Track Records for every definition
- Evals and Hillclimbs to improve them
Day to day
- Board from Backlog to Done
- Pull Requests with CI and conflicts
- Live Transcripts of every session
- Delivery Reports of cost and time
- Run your app from any branch
- Chat sessions outside a Flow
- Screenshots in any message
- Queue that waits out usage limits
Platform
- GitHub, GitLab, Jira
- Your own Claude subscription
- Desktop app for three systems
- Local only, nothing hosted
Meet the Agents that do the work.
Each Stage has its own Agent: a Claude Code session with one role, defined in a file in your repository. These six are the starters. Change them or add your own through a Pull Request, and the whole team runs the same ones.
pmBreaks an Intent into Issues and drafts each one’s Flow Proposal: the Stages, the Agents and the Budget.
Commits the Breakdown and the Flow Proposalbusiness-analystWrites the requirements, each with an ID and a fit criterion that a test can check.
Commits spec.mddesignerChanges your running app and screenshots it, in variations you choose between.
Commits mock-upsarchitectDecides how the change is built, draws it, and records the key decisions.
Commits architecture.md and ADRssoftware-developerWrites the code, and tests that cite the requirement each one proves.
Commits the code and its testsreviewerChecks every requirement against its tests, and sends the work back when one isn’t met.
Commits review.mdRigorous Analysis and Design add nine step Agents of their own, from business-intent-analyst to design-validator.
Bring AI agents into delivery without losing control of it.
A six-week pilot: Adastra sets Intentline up with your repositories, Agents and sign-off rules, and your team delivers real Issues through it.
Ask your Adastra account team to arrange a pilot.
pm
business-analyst
designer
architect
software-developer
reviewer