WorkAutonomous Agents · Multi-Agent Orchestration2026
Five autonomous agents take a plain-language brief to shipped code — with a human approval gate at every stage and an audit trail of every action.
Independent product, architected and built by our founding team
5
Agents in the chain
5
Human gates per run
109s / 248s
CI absorbed into review
Hash-chained
Audit trail
The challenge
Autonomous coding agents produce plausible output, and plausibility is indistinguishable from correctness until something ships. How do you build a pipeline a human can actually trust — and prove afterwards what happened?
What we built
A control plane that drives a brief through five stages with one specialised agent per stage, each starting in a fresh context and receiving only the previous stage's approved artifact — so a mistake cannot propagate silently through shared conversation state. Every stage ends at a human approve/decline gate; a decline routes back to the same agent with the reviewer's feedback rather than cancelling the run. Three of the five agents are read-only and none is granted a shell: installs, builds, tests and deploys run through platform-owned ports behind the gates. A deterministic hook blocks destructive commands before any tool call runs, and a hash-chained append-only log records every agent action, block and human decision.
Key engineering
The decisions that made it work
Fresh context per stage
Agents hand forward finished artifacts, never conversation state.
Exit codes, not agent claims
The QA gate trusts the real test runner's exit code — never the agent's own assessment of its work.
Least privilege by design
No agent holds a shell; capability, not trust, decides what each stage can touch.
CI inside the gate wait
CI starts the moment coding stops, running while the human reads the diff — 109 seconds absorbed into a 248-second gate wait on a measured run.
The results
What actually changed
- 1
Five agents in a production pipeline with a mandatory human gate at every stage
- 2
Every agent action, tool call and human decision on a hash-chained, append-only audit log
- 3
109s of CI absorbed into a 248s human review window on a measured run — verification without added wait
What it doesn't do
It generates greenfield applications well and brownfield changes cautiously; large existing codebases are the harder, less-proven case. One operator can still approve their own gates — the audit trail makes decisions attributable, not independent.
Stack
- TypeScript
- Node.js
- LangGraph
- Claude Agent SDK
- Fastify
- Next.js
- MCP
- OpenTelemetry
- Docker
Tell us the pain point. We'll tell you honestly what AI can do about it.
A founder replies within 24 hours. If the answer is 'AI is wrong for this', you'll hear that too — free either way.