A software factory thatworks your backlog.
Point it at your ticket system and your repository. An orchestrator breaks the work down, specialist agents implement, test and review it, and what comes out the other end is a pull request you can read — then a rollout you approved.
Your tickets. Your repositories. Your keys.
Works with the ticket system you already use · Bring your own keys or your own subscriptions
From a ticket somebody wrote to a rollout somebody approved.
Every step in between is done by agents, recorded on a board you can watch, and stopped wherever you want a person to decide.
Requirements in one end. Reviewed software out the other.
The factory connects to the ticket system and repository you already use. Nothing moves without leaving a trace, and you choose where a human still signs off.
Requirements arrive
Issues come in from GitHub, GitLab, Forgejo, Jira or Trello — whatever your teams already write tickets in. Nobody moves to a new tool, and nobody writes requirements twice.
Orchestrator and architect break it down
An orchestrator agent works with an architect agent to cut a requirement into work items small enough to build and verify independently. They land on an internal Kanban board, so you can see what the factory thinks the work is before any of it starts.
If the breakdown is wrong, you correct it there — not after the code is written.
Implement, test, review
Implementer agents work the items. Tester agents exercise the result end to end rather than trusting it. Reviewer agents read the diff with fresh eyes and send work back when it is not good enough.
Keeping those roles apart is the point: the agent that wrote the code is not the agent that decides it is finished.
Pull request, merge, roll out
The factory opens a pull request against your repository, with the tests and the review attached. On merge it hands off to GitOps — Argo CD or whatever you run — to roll the change through your stages.
Where you want a person to approve a promotion, it waits for one. Where you do not, it does not.
Want to try it against a real backlog?
The factory is in development and we are taking a small number of early customers with real repositories and real tickets.
Six roles, deliberately kept apart.
One agent doing everything makes the same mistake twice and marks its own homework. These roles check each other by design.
Orchestrator
Owns the board. Decides what is ready to start, what is blocked, and what needs a person. Nothing runs without it knowing.
Architect
Turns a requirement into work items that can be built and verified independently, with the technical approach written down before anyone codes.
Implementer
Works a single item against your existing codebase and conventions. Small, reviewable changes rather than sweeping rewrites.
Tester
Exercises the change end to end, in a browser where that is what it takes. Failures go back to the implementer, not to you.
Reviewer
Reads the diff without having written it. Approves, or sends it back with specifics. The pull request you see has already survived this.
Release
Merges what passed and hands off to your GitOps pipeline, stopping at whichever stage you decided needs a human.
Your board
Every item, every state change, every decision an agent made — visible while it happens, not summarised afterwards.
Your repository
The work lands as commits and pull requests in your own repository. Turn the factory off and everything it built is still yours.
It fits round what you already run.
The factory is deliberately not a place your teams have to move to. It connects to the trackers, repositories, pipelines and chat tools already in use.
Tickets and repositories
- GitHub Issues and pull requests
- GitLab and Forgejo
- Jira and Trello
- Any Git repository you can grant access to
Delivery and rollout
- Argo CD and GitOps workflows
- Automated end-to-end testing
- Pull request creation and review
- Staged rollouts with approval gates
Where your teams talk
- Slack
- Microsoft Teams
- Matrix
- Approvals and escalations in the channel
Your infrastructure, your models, your keys.
The factory works with external frontier models and agents rather than locking you to ours. Where the work runs, and whose account pays for the inference, are both your decision.
SaaS
Hosted and operated by us. The fastest way to point the factory at a repository and watch it work.
Self-hosted enterprise
Runs inside your own infrastructure, under your network boundary and your own governance, with the same board and the same agents.
Bring your own keys
Use your own API keys with the frontier models you have already approved. Inference runs on your account, under your existing terms.
Bring your own subscriptions
Already paying for coding agents your teams like? The factory can drive those rather than duplicating what you buy.
The factory is being built. Come and break it.
We are taking a small number of early customers with real repositories and real backlogs — the kind of work that shows where this holds up and where it does not.
A sustainical platform.