Developers New to Kontour? Start with Flow Agents.
the agent said it was done — this is the part it skipped
Your agent reports the task complete. It ran the tests — but did it ever open the page? Did the review happen, or did it get summarized away when the session ran out of room?
Flow puts the answer in plain files next to your code. Every step has a gate — a checkpoint that names what the step has to hand over before the work moves on. Flow records what each gate asked for, what actually arrived, and anything a person waived on purpose. Nothing becomes "done" because an agent said so.
$ npx flow status demo --format summary flow run: agent-dev-flow / demo-checkout-banner current step: implement PASS plan gate: Acceptance criteria are ready for implementation. satisfied BLOCK implementation gate: The implementation diff is scoped to the planned change. missing expected: The implementation diff is scoped to the planned change. transition diagnostics: transition.gate.block WAIT verify gate: verify gate waiting status: blocked next action: attach scoped files before continuing continuation: resume from implement, not chat memory report: .kontourai/flow/runs/demo/report.md ready steps: implement
Real output from the demo inside @kontourai/flow 3.10.0, captured after npx flow init --demo and then npx flow evaluate demo --exit-code, which exits 1 and leaves the run exactly here. Nothing is added or reworded; the one over-long line is wrapped onto the indented line beneath it, and nothing else is changed. The gate that stopped the run is the demo's own implement gate — we did not pick it, and the run id, the step names and the gate descriptions are all the demo's.
Quickstart
$ npm install -D @kontourai/flow $ npx @kontourai/flow init --demo initialized .flow demo run ready: demo try: flow status demo flow resume demo flow console --run demo
Real output from @kontourai/flow 3.10.0 in an empty directory. npm's own install output is trimmed; the six lines printed by init --demo are unedited, and the three commands it suggests are the ones the rest of this page runs.
See it
flow evaluate --exit-code exits non-zero and names the piece of proof that never showed up — the run does not become "done" because the agent said so. The fourth command picks the work back up from exactly that point. Full walkthrough in the docs →What Flow answers
Example use case
A team asks an agent to ship a pricing-page change. The flow they declare names the required path — plan, implementation, code review, rendered-page verification, release readiness — and what each step has to hand over. The work can only advance when each gate has the evidence it asked for.
The demo that ships with the package is that idea in four steps, and the capture beside this is what it actually does. The run has cleared plan and implementation and reached verify, where the gate asked for test results that were never attached. The run does not become "done." It routes back to the step that can fix it, carrying the reason and the attempt count with it.
$ npx flow evaluate demo --exit-code route-back verify-gate: Test results are ready for verification. missing current step: verify next action: return to verify and replace failing evidence attempt 1/3
Real output from the same demo run as the hero, after attaching the demo's own scoped-diff evidence to clear the implement gate. Unedited; the command exits 1. This is the demo's verify gate, not the release path described on the left — that path is an illustration, and we do not have a capture of it.
Works the way the work actually happens
Real sessions do not run in order. The agent grabs the screenshots first, the test run lands three messages later, and the review comes back the next morning from someone else. Tools that audit by insisting on a fixed sequence spend all their time fighting that.
Flow does not care what order the proof arrived in. At each gate it asks one question: is everything this step needs here, recent enough, and from a source you trust? Same answer whether it all landed in one go or in pieces across three sessions. And when something does not hold up, the work routes back — it returns to the step that caused the problem, with the reason attached. The run is not broken. It just is not finished.
The difference
Observability is necessary, but a trace alone does not know whether the right verification happened, whether approval had enough context, or whether the agent skipped a required handoff.
Flow turns required paths into evidence-gated transitions. If the evidence is missing, the run blocks or routes back. If the user accepts the gap, the exception becomes part of the record.
Authority over a run
$ npx flow pause demo --request pause-request.json pause: demo status: paused request: kontourai.io#231 $ npx flow resume-run demo --request resume-request.json resume: demo status: blocked request: kontourai.io#231 $ npx flow kit validate ./release-kit valid Flow Kit container: ./release-kit
Real output from the same demo run, unedited except for the blank line inserted between commands. Two lines are worth reading literally. The echoed request: value is the file's own authority.request_ref — here an issue on this site's repo — not the file name. And resume-run reports status: blocked because pause captured the status it interrupted and then put it back. The kit is a two-file container we built for this capture.
Fits your stack
Keep Camunda, Temporal, Dapr, Inngest, or Trigger.dev running the work while Flow makes required gates and their evidence inspectable.
Run LangGraph, CrewAI, OpenAI Agents, Microsoft Agent Framework, or your SDK of choice and give every loop the same visible completion criteria.
Turn Phoenix, LangSmith, AgentOps, and OpenTelemetry traces into evidence evaluated against a declared gate.
Carry OPA, security scanners, and Veritas decisions into the run history so reviewers can see what passed and what was waived.
Flow Console
flow console --run <id> opens a page on your own machine that reads the run straight out of .kontourai/flow/runs/<id>/ — the path the work took, every gate it cleared or stopped at, and the evidence behind each one. It updates while the run does. It picks a free port unless you name one with --port, and it only ever listens on your own machine: no account, no upload, nothing hosted.
$ npx flow console --run demo --port 4317 Flow Console: http://127.0.0.1:4317/ run: demo Press Ctrl+C to stop.
Real output from the same demo run, unedited. Three lines is all that flow console prints; it then holds the terminal until you stop it. Everything else the console has to show is in the page it serves.
Where Flow fits
Flow on its own is a CLI and a library — you point it at whatever is already running your work. If you would rather not wire anything up, Flow Agents ships these checkpoints into your coding agent already set up: blocking in Claude Code and Codex, advisory everywhere else.