Product

Software Factory

Our proprietary factory scales delivery speed to levels unachievable with a large distributed development team.

What is it?

The system behind our own delivery speed, made available as a product: three agents (Dispatch, Review, Resumption) that pick up ready work, build it against a machine-readable contract, review it against acceptance criteria with cited evidence, and fix what fails review without starting over.

What does it do?

  • -No idle work: ready tasks start immediately, day or night
  • -A held-out test suite runs before a model ever looks at the diff
  • -Every FAIL has to cite file, line and rule — no vague rejections
  • -Capped retries: failed review triggers a diagnosed fix, not an infinite naive retry loop

Why does it matter?

We know the limitations of AI development and supplement our agentic capabilities with domain and technology experts to keep quality at enterprise levels. Software Factory is the delivery engine that makes that possible at scale.

Who is it for?

Engineering Leaders

How it works

Claude Sonnet running through an agentic coding CLI, wired into the GitHub workflow end to end: Dispatch picks up and builds ready tasks, Review audits the diff against acceptance criteria and either opens the PR or routes to Resumption, which diagnoses and fixes without repeating a rejected approach.

Components

Agent Dispatch

Removes the wait between deciding what to build and having it built. A task shouldn't sit in a queue for a free engineer, it should start the moment it's ready.

An agent that watches our own task board and picks up ready work the instant it's marked ready. No standup, no assignment, no "who's got capacity." It checks the task is genuinely ready, builds it, and hands its own work to a second agent for review, automatically.

  • No idle work: ready tasks start immediately, day or night, instead of waiting for the next available engineer.
  • Engineers spend time reviewing, not typing: the routine implementation work moves to the agent, people stay on judgment calls, architecture, and the review that catches what the agent can't.
  • Consistent baseline quality: every run is pre-validated (type-checked, dependency-checked) before it's allowed to touch a line of code, the same bar every time.
  • A full audit trail for free: every dispatch leaves a transcript, a branch, and a project-board update behind it, nothing built in the dark.
  • It scales with the backlog, not the team: busiest day in our data saw 23 tasks dispatched in a single day. No hiring required to hit that.

How it works: Claude Sonnet, running through an agentic coding CLI on dedicated infrastructure, wired directly into our GitHub workflow. It validates the task against a machine-readable contract before touching any code, builds and tests the change, pushes a working branch, and triggers review, unattended, in one continuous run.

Real run — GitHub Actions #34247380566, issue #3093

▸ Pre-validation

Agent Review

Catches what's wrong with a change before a human has to, without slowing delivery down to a crawl.

A second agent that audits every implementation branch against the original task's acceptance criteria and the codebase's own rules, cites the exact file and line for anything it flags, and is explicitly barred from speculating about runtime behaviour it can't see in the diff.

  • A visibility boundary that's actually enforced: it judges the diff, the pre-validation output, and rule compliance, and nothing else, no guessing about what might break in production.
  • A held-out test suite the implementation never saw runs automatically before the model even looks at the diff, and it can tell a pre-existing failure from one this change actually caused.
  • Every FAIL has to cite file, line, and rule, or it gets downgraded, no vague rejections.
  • A clean pass opens the pull request itself: review isn't a gate someone has to remember to run, it's the thing that makes the PR appear.

How it works: Claude Sonnet, given the PR diff, the changed file contents, the original task, and the PR description, run with external tool access disabled for determinism. Outputs a structured PASS, HITL, or FAIL verdict as a comment; PASS triggers PR creation directly, anything else triggers the Resumption agent.

Real run — GitHub Actions #34247739491, issue #3093

▸ Execute Kiro review

Agent Resumption

Fixes a pull request that failed review without starting the work over, and without repeating the same rejected fix twice.

An agent that reads the branch as it currently exists, not as a continuation of a previous attempt, audits whether the blocker was missing evidence or an actual code defect since those need completely different fixes, and reconciles format before touching content so the review agent doesn't fail it again for the same superficial reason.

  • Diagnoses before it fixes: an evidence gap and a code defect are treated as different problems requiring different responses, not the same "try again" loop.
  • Format-matching before content: if a PR description's evidence section doesn't match what the task now requires, it gets rewritten to match first, closing the most common repeat-failure loop.
  • Re-enters review automatically: a fixed branch flows straight back into the Review agent, no manual re-trigger.
  • Capped, not infinite: each task gets a bounded number of attempts before it needs a human, so retries can't loop forever silently.

How it works: Claude Sonnet, reading the current branch state plus every existing PR comment, running the same evidence-audit-first protocol before writing a single line of code.

Real run — GitHub Actions #34231269669, issue #3073

▸ Get review feedback from issue comment

How can I get it?