Two founders, and a workforce of agents.

How the software gets built #

The platform reaches from accelerator scheduling and object storage to durable workflows and live queries in a browser, and it is maintained by a company of this size because the software factory builds it. Work is not handed to a queue of people. It is planned as a dependency graph, claimed by agents that can only take what is genuinely ready, implemented in isolated environments, and driven through a series of gates that fail closed.

The design assumption is that any individual agent will sometimes be wrong, confidently. So correctness is never anyone's carefulness — it is a property of the pipeline. An implementer cannot review its own work, cannot merge it, and cannot mark it done; those routes do not exist in the tooling rather than being discouraged by convention. Verification happens against services actually deployed on a real cluster, because passing on a laptop has never been evidence of anything.

The same machinery builds the platform it runs on. Every weakness in the factory shows up on our own delivery first, which is a considerably better way to find one than hearing about it from a customer.

The life of one change #

1. Work is planned as a dependency graph rather than a backlog. Every task carries its acceptance criteria and knows what must land before it can start.

2. An agent claims the next task that is genuinely ready, atomically, so two agents can never take the same piece of work or start something whose dependencies are unmet.

3. It works on its own branch in an isolated environment, with the specification, the architecture model and the operating rules for that subsystem loaded as context.

4. It implements the change, writes the tests, updates the documentation and the feature catalogue, and opens a merge request. It cannot merge that request itself.

5. A mechanical pre-review runs first and rejects anything with a certain, checkable violation, so expensive review attention is spent on questions of judgement instead.

6. An independent reviewer — never the implementer — evaluates the change against its specification, and either lands it or returns it with specific, actionable feedback.

7. Layered gates run and every one of them fails closed: static validation, tests, adversarial code and security review, then live tests against actually-deployed services on a real cluster.

8. The change promotes as an immutable artefact, and the deployment is only finished when the cluster is observed healthy. Regressions and production signals return as new work without anyone filing a ticket.