Autonomous Engineering Platform
A multi-agent platform that automates the software delivery lifecycle — requirement analysis, story generation, implementation, review, QA and release — with agents handing structured work to one another and a review loop that sends failing work back rather than passing it on.
Six specialised agents carrying a business requirement through to release-ready code, with a retry loop and humans at every gate.
Rather than one general-purpose assistant, six bounded agents each hold a narrow role with their own instructions and only the tools that role requires. Narrow scope is what makes agent behaviour debuggable — when output is wrong, you can tell which agent produced it.
Agents pass structured output along the lifecycle, so requirement analysis genuinely constrains the story, and the story constrains the code — instead of each stage restarting from a blank page.
The review agent is deliberately separate from the agent that wrote the code, and can send work back through a retry loop rather than forwarding it downstream.
Provider failover chains across three LLM vendors, so a single provider outage does not halt the pipeline.
Software delivery loses enormous time to work that is necessary but repetitive: restating requirements, drafting stories, writing boilerplate, catching predictable defects, assembling release notes.
Engineers had started using AI assistants individually, but the benefit stayed personal and inconsistent. Quality depended on who was prompting, nothing was captured at team level, and none of it was governed.
The goal was to move from scattered individual usage to a repeatable pipeline where AI handles the predictable work and engineers spend their judgement where it counts.
A multi-agent platform that automates the software delivery lifecycle — requirement analysis, story generation, implementation, review, QA and release — with agents handing structured work to one another and a review loop that sends failing work back rather than passing it on.
If you want agents doing real work inside an existing process rather than a demo, this is the shape: narrow roles, typed handoffs, an independent reviewer that can reject, and provider failover.
Agents
6 specialised roles
Orchestration
LangGraph state machine
LLM failover
3-provider chain
Infrastructure
PostgreSQL + Redis, containerised
The constraint that shaped it
The reviewer must be able to reject
A pipeline where every stage passes work forward is theatre. Making review independent — a separate agent, with authority to send work back through a retry loop — is what turns a chain of generators into something with a quality gate. Autonomy was capped deliberately: the platform proposes and explains, engineers approve.
Bounded agents over one large prompt
A single mega-prompt cannot be debugged — when output is wrong, there is no way to tell which instruction failed. Role-scoped agents can each be evaluated and improved independently.
Structured handoffs, not prose
Agents exchange typed output so later stages cannot silently reinterpret earlier ones, and the whole chain stays inspectable when something goes wrong.
Failover across providers
A three-vendor chain means a provider outage or rate limit degrades throughput instead of stopping delivery.
- Framed the problem with engineering stakeholders and set the platform's boundaries
- Designed the agent topology — roles, handoffs, retry loop and human gates
- Built the implementation hands-on, including orchestration and LLM integration
- Designed the operator interface so engineers could supervise and correct the pipeline
- Drove adoption and folded engineering feedback back into agent instructions
How We Solved the Problem
Requirement agent
Reads the incoming business requirement, identifies ambiguity and missing acceptance criteria, and emits a structured specification plus open questions for a human owner.
Story agent
Converts the agreed specification into implementable stories with acceptance criteria, sized and sequenced rather than dumped as a list.
Developer agent
Implements against those stories in the project's own conventions and patterns, rather than producing unanchored generic code.
Review agent — with retry
Independently reviews the implementation for defects, missing coverage and convention violations, returning work to the developer agent when it fails rather than passing it along.
QA agent
Exercises the implementation against the original acceptance criteria, closing the loop back to what was actually asked for.
Back
View All Case Studies
Next Case Study
Contract Lineage & Consolidation Engine
An engine that reconstructs the current state of a heavily amended commercial agreement — producing a consolidated document with complete change lineage, where AI proposes typed operations and deterministic code applies them.