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.

Works with the tools you already use
Claude Code GitHub GitLab Jira More to come
Why it matters

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.

Ad hoc agent sessionone prompt in a terminal
You get code.It may well work. Nobody can show what it was meant to do, who agreed to it, or how anyone knows it works.
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 % 
Left in the repositoryTS14 changed filesPRa description
✕What was agreed before any code?Whatever the prompt said, and nobody wrote it down
✕Who signed off the design?Nobody. The agent decided as it went
✕Can you prove it does what was agreed?Tests pass, but none says which requirement it proves
✕What could the agent touch?Your shell, your Git credentials, your remote
✕What did it cost?Unknown until the invoice
✕Can an auditor follow it next year?Only if someone remembers
Intentline Flowthe same change as Issue #412
You get code, and the proof behind it.Agreed requirements, an approved design, tests tied to each requirement, a reviewed result and its cost. All committed with the code.
acme/payments-core · part of Intent #410Merged
#412 Limit check in TransferPolicy
Pull Request #415 into mainOpen a Stage to see its record
Analysisbusiness-analystApproved by you, 09:31$1.12

docs/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.
DesigndesignerVariant A of 2$1.05

Screenshots of the running app, two variations

A · inline noticeOver your daily limit. €1,200.00 left today.Chosen
B · bottom sheetDaily limit reached. You can send €1,200.00 today.
ArchitecturearchitectApproved by you, 10:10$0.86

architecture.md · docs/adr/0031-read-daily-totals-from-the-ledger.md

ADR-0031: read daily totals from the ledgerNever from a cache, so two transfers sent at once can’t both pass. One ledger read per transfer, inside NFR-1.
Implementationsoftware-developerAttempt 2, CI green$3.51

In its own git worktree. Intentline did the push.

  1. Attempt 1src/payments/transfer-policy.ts and 13 more files, 5 tests citing REQ-nSent back: no test covers REQ-3
  2. Attempt 2Added test/daily-total.test.ts, citing REQ-3CI green
Reviewreviewer4 of 4 met$0.88

docs/sdlc/412-sepa-daily-limit/review.md

REQ-1mettransfer-policy.test.ts:48
REQ-2metlimit-notice.test.ts:12
REQ-3metdaily-total.test.ts:7
NFR-131 mslimit.bench.ts:9, under 40 ms
Budget $7.42 of $20Merged by you, 11:20
Left in the repositoryMDspec.mdPNGmock-upMDarchitecture.mdADRADR-0031TS6 tests citing REQ-nMDreview.mdTSthe code
✓What was agreed before any code?3 requirements and 1 NFR, each with a fit criterion, approved by you at 09:31
✓Who signed off the design?You, at 10:10. The decision and the reasons are in ADR-0031
✓Can you prove it does what was agreed?Every requirement has a test that cites it. Review caught REQ-3 untested and sent it back
✓What could the agent touch?Only its own worktree. It never held your credentials; Intentline did the push
✓What did it cost?$7.42, inside a $20 Budget you set before it started, broken down per Stage
✓Can an auditor follow it next year?Yes. Every decision is committed in the repository next to the code
How it works

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.

Phases

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.

  1. 01Intent

    You say what you want built

    You write the goal in your own words, for one Issue or a whole feature. The pm Agent fills in a title and a type if you leave them out.

    • Intent #410

    You write it

  2. 02Analysis

    What exactly it must do

    business-analyst writes each requirement with an ID and a fit criterion a test can check, and asks you what only you can decide.

    • spec.md
    • CONTEXT.md
    • Rigorous +5 steps

    Checkpoint: you approve the spec

  3. 03Design

    How it looks, in your real app

    designer changes your running app with throwaway code and screenshots it, in variations you choose between.

    • design.md
    • screenshots
    • Rigorous +4 steps

    You choose a variation

  4. 04Architecture

    How it will be built

    architect decides how the change fits your system, draws the components, and records each key decision with its reasons.

    • architecture.md
    • docs/adr/

    Checkpoint: you approve the design

  5. 05Plan

    It becomes Issues, and a plan for each

    pm reads 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.

    • Breakdown
    • Flow Proposal

    You approve the Breakdown

  6. 06Implementation

    The code, and tests that prove it

    software-developer writes 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

  7. 07Review

    Proof it does what was agreed

    reviewer checks every requirement against the test that cites it, and sends the work back when one isn’t met, at most twice.

    • review.md
    • recordings

    Sent back on its own when a check fails

  8. 08Merge

    Delivered, 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 #415
    • Delivery 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.

Questions

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.

Recorded in the app: a Question in Analysis, its Suggested Answers, a discussion with the Agent, and the spec it leads to.
Governance

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.

Fix a typo$5budget
Small Issue

You decide at the plan and the merge.

Add a screen$20budget
Medium Issue

You decide at the plan, Analysis, Architecture and the merge.

New business rule$60budget
Intent, Rigorous methods

You decide at every step, each signed off by its named Owner.

Approval

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.

A Flow Proposal for a Medium Issue: a $20 budget, an Agent picked for each of the five Stages, and Checkpoints after Analysis and Architecture.
Traceability

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.

FollowA transfer that takes the day’s total over the limit is rejected.
  1. 01Analysisspec.mdREQ-1 A transfer that takes the day’s total over the limit is rejected.
  2. 02Architecturearchitecture.mdThe check runs in TransferPolicy, before the scheme call.
  3. 03Implementationsrc/payments/transfer-policy.tscheckDailyLimit() rejects with status RJCT, reason AM02.
  4. 04Teststest/transfer-policy.test.ts:48it("rejects a transfer over the limit") cites REQ-1.
  5. 05Reviewreview.mdMet. Checked by the test at line 48.
Risk acceptedEach risk left open needs a decision (accept, mitigate or descope), kept with who made it and when.
Across repositories

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.

1 Intent2 The PM Agent’s Breakdown3 Delivered in orderINTENT #410Enforce daily limits onSEPA instant transfersacme/payments-core#412 Limit check in TransferPolicyFlow #412PR mergedacme/mobile-app#87 Show the remaining limitwaits for #412Flow #87acme/backoffice#30 Limit changes in back officewaits for #412Flow #30time#412 merges, then #87 and #30 start INTENT #410Enforce daily limits onSEPA instant transfersPM Agent: an Issue per repositoryacme/payments-core#412 Limit check in TransferPolicyFlow #412PR mergedacme/mobile-app#87 Show the remaining limitwaits for #412Flow #87acme/backoffice#30 Limit changes in back officewaits for #412Flow #30#412 merges, then #87 and #30 start

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

software-developerAGENT ON #412
One Agent, one packaged environment.

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
Across a team

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.

1 Split2 Take3 Build4 DeliverYOUYouyour laptopGitHubshared by allAK@ana-kAna’s laptopMR@marco-rMarco’s laptopPlans the featuresplit into 3 IssuesAgents build #412on your laptopPull Requestfor #4123 Issues creatednobody assigned yetAssignedone each: you, Ana, MarcoLive statusevery Board reads it3 Pull Requestsnothing done twiceTakes #413from Ana’s own BoardAgents build #413on Ana’s laptopPull Requestfor #413Takes #414from Marco’s own BoardAgents build #414on Marco’s laptopPull Requestfor #414Takes #412from your own Board

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.

The laptops never talk to each other. GitHub is the only thing they share: taking an Issue assigns it there, and every copy of Intentline reads that.

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.

Split a BreakdownEach person ticks the Issues they will take. Every Flow starts on its claimer's machine, as soon as its blockers are done.
Claims that holdApproving a plan claims the Issue. Taking one over reassigns it in the tracker and says so in a comment.
Sign-off OwnersName the people or teams who must approve the spec, design or architecture. They sign off by reviewing a Pull Request.
Same Agents for everyoneProject Agents and the group file live in the repository and change through Pull Requests, so the whole team runs the same ones.
Capabilities

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
Agents

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.

Planpm

Breaks an Intent into Issues and drafts each one’s Flow Proposal: the Stages, the Agents and the Budget.

Commits the Breakdown and the Flow Proposal
Analysisbusiness-analyst

Writes the requirements, each with an ID and a fit criterion that a test can check.

Commits spec.md
Designdesigner

Changes your running app and screenshots it, in variations you choose between.

Commits mock-ups
Architecturearchitect

Decides how the change is built, draws it, and records the key decisions.

Commits architecture.md and ADRs
Implementationsoftware-developer

Writes the code, and tests that cite the requirement each one proves.

Commits the code and its tests
Reviewreviewer

Checks every requirement against its tests, and sends the work back when one isn’t met.

Commits review.md

Rigorous 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.