Your delivery pipeline, run by agents
Software Factory
Software services firms and in-house engineering teams
Coding agents make an individual developer faster at an individual task. They do not scope a project, hold the architecture, sequence dependent work, prove that a change does what was asked, or keep the trail a client expects. We built a software factory that runs that whole path as one pipeline: scope, plan, document, ticket, implement, test and QA, with a person approving every verified change. It orchestrates Claude Code, Codex and Pi sessions in parallel sandboxes, runs each change in an in-app preview with a recorded walkthrough, and keeps only tests that are proven to catch the change. It is built to fit the business rather than the other way round: it connects to GitHub or GitLab, Jira or Linear, MCP servers and the models and subscriptions a company already pays for, and we customise templates, definition of done, review gates and stack conventions for each team. It runs hosted, self-hosted on the customer's own infrastructure, or set up and operated for them.
At a glance
- Built for
- Software services firms delivering for clients, and product teams that want more delivery capacity without growing headcount at the same rate
- Problem
- AI makes writing code cheap, but delivery is still bottlenecked on scoping, coordination, verification and review, and generic tools ask teams to change how they work
- Solution
- A seven-stage pipeline from request to verified pull request, customised to each team's process and connected to the systems it already runs
- Deployment
- Hosted, self-hosted on the customer's cloud or data centre, or set up and run for them; open-source core under MIT
- Engineering
- 878 commits since March 2026, 154 test files, 25 database migrations
- Stack
- TypeScriptBunHonoPostgreSQL / SQLiteDocker sandboxesFirecracker microVMsClaude CodeCodexMCP
The challenge
Every company delivers software differently, and the ones with the most to gain from AI (services firms and busy product teams) are the least able to stop and rebuild their process around a new tool.
Coding is not delivery
Scoping, architecture, sequencing, regression checks and sign-off still sit with people, so faster code alone does not ship faster.
It has to fit what exists
Repositories, trackers, branch protection, review rules and client vendor policies are already in place and can't be swapped out.
Proof, not confidence
A model that wrote the code will happily write tests that pass. Teams need evidence that a change does what was asked.
Data and model control
Some clients require code to stay on their infrastructure, or rule out particular model vendors.
Accountability
Clients want to know why something was built and who approved it, long after the work is merged.
Our approach
We built the factory as our own delivery engine first: the other products in this portfolio were taken from requirement to production through it. That kept it honest. Every stage leaves something a person can check, the human gates stay where judgment matters, and anything that slowed real client work became a change to the pipeline. For each customer we then shape it to their process instead of asking them to adopt ours.
What we built
A seven-stage pipeline from request to verified change
- Scope reads the request alongside the codebase, docs and connected tools, and asks the questions a good engineer would ask before building.
- Plan writes a technical analysis and sequence diagrams, failure paths included, so architecture is decided before code exists.
- Document produces a versioned PRD with acceptance criteria, which the verification stages later check against.
- Ticket breaks the plan into a dependency graph, each ticket linked back to the requirement that caused it.
- A person approves the finished, running, tested change, and the pull request lands under the team's own branch protection.
Parallel agents in isolated sandboxes
- Claude Code, Codex or Pi sessions run each ticket in its own sandbox, on its own branch, never against a main line.
- Independent tickets run in parallel; dependent ones wait, and context from finished tickets travels forward.
- Live logs and diffs for every session, with the option to steer, continue or restart at any point.
- Sandboxes run as Docker containers on the customer's own servers, or on hosted Firecracker microVMs with one setting.
Verification that proves itself
- A separate QA agent writes tests from the acceptance criteria, not from the diff.
- Each test runs before and after the change. Only tests that fail first and pass after are kept and committed.
- Every change is started in an in-app preview with its databases, migrations and seed data, and exercised in a real browser with a recorded walkthrough.
Integrates with your existing services
- GitHub and GitLab: reads repositories, works on branches and opens pull requests under existing protection rules.
- Jira and Linear: tickets and status stay in sync with the tracker the team already uses.
- MCP servers and app connectors give agents the same internal tools, docs and business systems engineers use.
- Any major model on the Claude and ChatGPT plans a company already pays for, or on API keys, with a model policy per project or client.
Customised to how each team delivers
- Document templates, definition of done, review gates and stack conventions configured per team or per client.
- Approval rules decide which stages need a person and who that person is.
- Can be delivered under the customer's own brand and domain as their own capability.
- We install it, connect it, train engineers to hold the gates, or keep running it and own the outcome.
Security and operations
- Runs entirely inside the customer's environment when required: their cloud or data centre, their compute, their database and storage.
- Secrets and subscription credentials are encrypted at rest and stay on the customer's infrastructure. Nothing phones home.
- Agents work on branches in isolated sandboxes; nothing merges without a named person approving it.
- Requirements, decisions, tickets, sessions, tests, recordings and approvals stay queryable after release.
- Admins decide which models and subscriptions each team or client project may use.
Results
Our own products ship through it
KiteReach, Mags and Easylogs were built and are iterated on through the factory.
Seniors supervise, not hand-write
Experienced engineers hold the architecture and review gates across several streams of work instead of writing each one.
Fits without a migration
It attaches to the repositories, trackers and models a team already has, so adoption doesn't start with a rebuild.
A trail on every change
Every merged change traces back to the requirement, ticket, tests and approval that produced it.
Key takeaways
-
1
Build the whole path, not a faster step. Delivery speeds up when scoping, sequencing and verification are part of the pipeline, not just code generation.
-
2
Fit the business, not the tool. Configurable templates, gates and integrations are what let a team adopt the factory without changing how it works.
-
3
Keep the human gate. Agents do the volume; a person approves a verified change. That is where judgment pays.
Have a process like this?
Tell us what is costing your team the most time. We will show you how we would scope it, build it and get it into production.