How we accidentally built a self-improving software factory

We built a software factory to build our product

We put our coding infrastructure together so that it builds software automatically, the way a software factory does. Internally we call it Architech. We use Architech to build our product for agent building and optimization, Helix.

Architech is our software factory. It is a multi-agent system with parallel workers, built on Pi, and it takes a feature through six phases:

• Plan. The architect turns requirements into a design and tasks, then publishes the tasks as GitHub issues.
• Build. The orchestrator dispatches issues to agents in parallel, or plans and acts in a single pass for small changes.
• Test. Tests run on every change before it goes to review.
• Review. A dedicated review agent reviews the change. The developer only reviews the pull request.
• Ship. The orchestrator runs review, CI and merge, then watches the rollout.
• Monitor. The orchestrator watches CI/CD, deploy health and the product.

Helix is our agent factory, an agentic coding harness optimized for building agents. It is also built on Pi. It takes an agent through six stages: Spec, Build, Evaluate, Diagnose, Optimize, Ship.

Architech built Helix for months. That was the whole relationship: one factory produced the other.

Helix moved to the cloud and learned to watch agents

Helix started out running on our laptops. We moved it into a cloud sandbox on Mutagent Cloud, so it can continuously monitor agent traces and agent actions.

Then we pointed it at Architech. As Architech is a multi-agent system with parallel workers, Helix performs its job of optimising and watching its agents.

We put the optimization loop on our own software factory

Once Helix was watching Architech, we diagnosed it and put the optimization loop on it. When we program with Architech now, Helix optimizes the agents doing the work: the architect writing the design, the orchestrator splitting issues, the review agent checking each change.

Architech moved to the cloud too

Moving Architech to the cloud was the easy part, because Architech had already built the infrastructure for Helix. Now the same infrastructure runs Architech, the factory that built it. The setup is the same as on our laptops, only the coding harness is different. Both factories now run in Mutagent Cloud’s agent sandboxes.

The loop closes

This is the part we did not plan.

Each turn of the loop compounds. A better Architech builds a better Mutagent Cloud and a better Helix. A better Helix makes Architech better again.

What we ended up with is a self-improving software factory that is also very good at building agents. Agent building became a subset of the software factory, because the agent factory now lives inside it. The combined loop behaves like an engineer and an AI engineer working side by side.

Your coding setup is a multi-agent system too

If you run a coding agent with a spec step, parallel workers and a review step, that setup is a multi-agent system. It can be evaluated, diagnosed and optimized like any other agent.

The open problem is amplification

A system that improves the thing that builds it can also amplify its own mistakes. A bad mutation to the review agent makes every later iteration worse, including the review of the next mutation.

What we still have to solve is how to contain that amplification: the guardrails that keep the system in check.