Process · How we ship

An autonomous fleet, with humans in command.

From a signed brief to live software — our four-stage process moves at machine speed without giving up human oversight, accountability, or care at any step.

Start a project Our AI for Good initiative

The stages

Four stages, no ambiguity.

Each stage has a defined set of inputs, outputs, and a human checkpoint before the next stage begins. Nothing proceeds on autopilot.

Brief

We start from the outcome that helps people, then agree on scope, guardrails, and what “good” looks like.

Every engagement starts with a single question: who does this help, and how do we know when we've helped them? We meet with you to understand the underlying need, not just the feature list. Scope, guardrails, success criteria, and responsible-AI constraints are all agreed in writing before a single line of planning begins — so the fleet builds the right thing, not just a thing.

Inputs

Problem statement
Target user description
Success criteria
Constraints and guardrails

Outputs

Signed brief document
Agreed definition of done
Responsible-AI checklist

Cadence — One to two working days; a synchronous call plus async review.

Plan

The work is decomposed into small, verifiable tasks — a plan a fleet of agents can execute and a human can review.

The brief is broken into a prioritised list of scoped, independently verifiable tasks — each with explicit acceptance criteria and a clear human checkpoint. The plan is the contract: it tells the fleet exactly what to build and how to prove it's built correctly. It is reviewed and approved by you before any code is written.

Inputs

Signed brief
Technical constraints
Integration dependencies

Outputs

Prioritised task list
Acceptance criteria per task
Dependency map
Estimated timeline

Cadence — One to three working days depending on complexity; delivered as a structured document.

Autonomous build

A fleet of AI agents implements, tests, and self-reviews in parallel, moving from plan to working software in days.

With an approved plan, a fleet of AI engineers picks up tasks in parallel — each in an isolated branch, each tested against its acceptance criteria before a pull request is opened. An independent judge reviews every PR against the original acceptance criteria. Speed is real: work that would take weeks sequentially happens in days. But nothing merges without human sign-off.

Inputs

Approved task queue
Acceptance criteria
Codebase access

Outputs

Reviewed pull requests
Passing test suites
Build artefacts ready for human review

Cadence — Continuous during build phase; PRs arrive as tasks complete, not in batches.

Human review & ship

Every change is validated and signed off by a person before it goes live. Nothing ships on autopilot alone.

A human — your team, ours, or both — reviews every pull request and makes the merge decision. Once merged, the deployment follows the agreed pipeline with monitoring in place. We do a structured handover: walkthrough, documentation, and a responsible-AI sign-off confirming the shipped software meets the guardrails agreed in the brief.

Inputs

Reviewed pull requests
Deployment pipeline
Staging environment

Outputs

Deployed, live software
Handover documentation
Responsible-AI sign-off

Cadence — Tied to your release cadence; we support continuous delivery or scheduled releases.

Deliverables

What you get at each stage.

Every stage ends with something concrete you can review, approve, or reject — before the next stage starts.

Brief

Brief document
Scope boundary statement
Agreed responsible-AI constraints

Plan

Implementation plan
Acceptance criteria document
Approved task queue

Autonomous build

Pull requests per task
Test results
Independent judge verdict per PR

Human review & ship

Live software
Handover documentation
Responsible-AI sign-off checklist

Timeline & rhythm

Machine speed, human rhythm.

The fleet builds continuously, but you review and approve at a pace that suits your team — daily standup, weekly sprint, or milestone-based. We match your release cadence, not the other way around.

Brief and plan: typically two to five working days, depending on scope.
Build phase: PRs arrive as tasks complete — not batched, not rationed.
Review gates: you set the merge cadence; we keep the queue moving.
Deployment: continuous delivery or scheduled releases — your pipeline, your call.
Handover: structured walkthrough plus documentation before sign-off.

Responsible AI

Human oversight at every gate.

Autonomy without accountability is just risk. Every stage has a human checkpoint built in — nothing proceeds until a person has reviewed and approved. Here's exactly where those gates sit.

Brief

Human-defined scope and guardrails gate every downstream task. No autonomous work begins without a signed brief.

Plan

A human reviews and approves the plan before any autonomous build begins. Tasks are scoped to be small enough for independent human review.

Autonomous build

Every PR is independently reviewed by a separate AI judge before it reaches a human. No PR merges automatically — the merge boundary is always yours.

Human review & ship

A person makes the final merge and deploy decision. The responsible-AI checklist from the brief is verified against the shipped product before sign-off.

See our AI for Good initiative

Let's build

Have something worth building?

Tell us who it helps. If it makes people better off, we'd love to build it with you.

Start a project