Stay on the path
Loose requests turn into shaped work, plans, implementation waves, review, verification, and release decisions — without writing a perfect prompt every time.
Flow and Veritas discipline inside the agents you already use
Agents are useful out of the box. They get fragile when work is long, parallel, risky, or knowledge-heavy — they skip verification, call partial work done, and lose the thread after compaction. Flow Agents installs one structured path into the agent tool you already use, so a loose request becomes shaped work, plans, review, verification, and a release decision — with evidence the agent and the developer can both read back. It does not replace the runtime or framework; it gives the work a required path and inspectable evidence.
$ npx @kontourai/flow-agents init --dest ~/dev/my-project
# or, from a checkout: bash install.sh ~/dev/my-project
installing Flow Agents bundle…
✓ agents Claude Code, Codex, Kiro, CI
✓ skills idea-to-backlog … learning-review
✓ kits Builder Kit
✓ context contracts, settings, hooks
✓ evals static · integration · behavioral
workflow artifacts → .flow-agents/
───────────────────────────────
ready. ask your agent:
"Use deliver for this issue."
One structured path
Skills choose the right workflow, sidecars preserve state across compaction, gates catch stop-short behavior, and a finding or gap routes the work back instead of waving it through.
review → finding routes back to build · verify → gap routes back to build · evidence → not-verified routes back to plan
Loose requests turn into shaped work, plans, implementation waves, review, verification, and release decisions — without writing a perfect prompt every time.
Acceptance criteria, test results, browser checks, governance reports, and gaps live in durable workflow artifacts the agent reads back — not in chat memory.
Install one bundle across Claude Code, Codex, Kiro, and CI. The same workflow, without rewriting it for each tool.
Runs in the tools you already use
Agents, skills, and hooks wired into the Claude Code harness.
The same workflow path mapped to Codex agent definitions.
Runtime-specific hook wiring for Kiro sessions.
Carry the workflow and its evidence into CI agents.
Tool adapters translate one source configuration into each tool's native shape — so adding a tool doesn't fork the workflow. Framework adapters for API-based agents (LangGraph, CrewAI, and peers) are on the roadmap.
Flow Kits
A Flow Kit is a portable workflow bundle: a validated kit.json
manifest, one or more Flow Definitions, and optional skills, docs, adapters,
evals, and assets — installed as a unit into any workspace. Kits are the
extension model: you package a workflow once and the same validated path runs
across runtimes without per-tool rewrites.
Builder Kit — first Kontour-authored kit
Builder Kit owns the Build path end to end — shaping, probing,
planning, execution, verification, PR readiness, merge readiness, and
learning — as two Flow Definitions your agent invokes by name:
builder.shape and builder.build. It installs
automatically with Flow Agents.
You can author your own kit today: a directory with a
kit.json, at least one flow file, and a single
install-local command. Validation runs the same contract
as Builder Kit before anything is copied.
A kit's gates can be evaluated agentlessly — a deterministic check of the same path, no agent in the loop — so CI or a person can verify a kit, not only the agent that ran it. Each kit declares a conformance level, so you know what it guarantees before you install it.
$ npx @kontourai/flow-agents flow-kit install-local ./my-kit --dest .
$ npx @kontourai/flow-agents flow-kit activate --dest .
Direction — kits are designed to be shareable across teams. The intended growth path: install from git remotes and a curated catalog of Kontour-authored kits. Today install is local-path only.
idea-to-backlog Shape a raw idea into executable issues pull-work Select the next ready issue and hand it off plan-work Turn a goal into a structured execution plan execute-plan Run implementation in parallel waves review-work Critique before verification verify-work Prove the change actually works evidence-gate Decide if the work is trustworthy release-readiness Merge, release, or hold — with reasons deliver The full chain, end to end fix-bug Diagnose → fix → verify the regression Example use case
No new CLI to memorize. You describe a feature request in plain language; Flow Agents routes it from idea to backlog to plan, implementation, review, and verify evidence while keeping the state and next action durable — even across compaction, branch switches, and delegated subagents.
When evidence is missing, the workflow stops and says so, instead of summarizing unfinished work as done.
You
Use deliver for issue #214. Plan it, implement it,
verify it, and stop if evidence is missing.
Flow Agents
✓ plan-work execution plan → 3 waves
✓ execute-plan implementation complete
✓ review-work 1 finding → routed back → fixed
✗ verify-work browser check missing
stopped at evidence-gate
next: capture a browser check, then resume
state → .flow-agents/runs/deliver-214/
What keeps it honest
Workflow state, acceptance, evidence, critique, release, and learning records persist as inspectable sidecars under .flow-agents/ — so a session can be resumed, audited, or handed off.
Wire Veritas readiness reports in as a governance adapter to back merge decisions with repo-standard evidence. Optional, never mandatory — Flow Agents does not own the policy.
Choose local, worktree, container, cloud, or privileged execution boundaries on purpose. Evals — static, integration, behavioral — keep the bundle honest as it changes.
Where it is today
The core Build workflows are live. Install it into any workspace
with npx @kontourai/flow-agents init —
and expect a phased rollout from here toward richer just-in-time
guidance, more work modes, and deeper governance.
$ npx @kontourai/flow-agents init --dest ~/dev/my-project
then, in your agent:
"Use idea-to-backlog for this feature
and create executable GitHub issues."
"Use fix-bug. Reproduce it, find root cause,
fix it, and verify the regression path."
Flow Agents applies Kontour Flow inside existing agent tools. Flow owns the gates, transitions, and evidence; Flow Agents brings them — and optional Veritas governance — into the coding agents you already use.