Writing code is easy. Shipping reliable software is not.

Production-grade software comes down to three things. A coding agent on its own gives you none of them.

Agents write the code.
The factory makes it shippable at scale.

Specs, tests, a fresh reviewer and merge policies around every change, from intent to production.

With a coding agent, the lifecycle is one slow loop, and you are inside it.

The agent writes the code. You still carry the plan between sessions, rerun the tests and read every diff. Each prompt to review cycle takes days, and nothing you correct carries over to the next session.

One file, factory.yaml, defines your factory.

Write it once with /onboard, run it locally, push it to the cloud when you are ready. Local and cloud runs share the same file.

metadata: { id: shop, repos: [acme/shop-web, acme/shop-api] }
boards:
  linear:  { team: SHOP, statusMap: { triage: Triage, done: Done } }
  github:  { labels: { ready: factory:ready, risk: risk:* } }
autonomy: calibration            # calibration · standard · auto
agents:
  architect:    { provider: anthropic, model: opus,   effort: high }
  developer:    { provider: mistral,   model: devstral, effort: medium }
  reviewer:     { provider: openai,    model: gpt,    effort: high }
stages:
  test:   { extend: [e2e-acceptance] }
  review: { external: [security-scanner] }
merge: { staging: yolo, e2e: as-ready, prod: on-approval }
orchestrator:
  escalate: [risk:high, new-table, spec-ambiguous]
  decide:   [naming, refactors, test-gaps]
limits: { sandboxes: 4, usd_per_task: 25 }
triggers:
  - { on: board.status=Triage, start: spec }
  - { on: github.ci-failed,     start: build }
routines:
  - { every: mon 07:00, run: "patch upgrades, one PR" }
notify:
  - { to: slack:#eng, on: [plan.ready, escalation] }
  - { to: github,     on: [pr.opened, run.done] }
sandbox: { preset: node-22, install: [pnpm, playwright] }

factory.yaml is the blueprint. Onboarding fits it to your stack.

Every factory starts from the same roles, rules, workflows and gates. /onboard reads your repos, asks about what it cannot see, and customises the blueprint, so the factory builds your kind of software your way.

Managed cloud factory infrastructure.

Push factory.yaml and enable it. From then on the factory runs always on: in sandboxes, on your models, against your boards, with every run traced.

SandboxesEvery stage in its own sandbox, your tooling preinstalled, capped in parallel.

Triggers and routinesBoard status, failed CI, Slack mention, webhook or schedule starts the work.

BoardsGitHub, Linear and Jira, with your statuses and labels mapped.

Your model providersYour keys; provider and model per role, nothing else called.

Every run tracedTokens, runtime and cost per task, stage and role, against your caps.

Gates and escalationsPlan and merge approvals wait for you; open questions park the run.

Watch the whole factory from one place.

Push factory.yaml, turn the factory on, then see what it reads, what it costs and where every item stands. Read-only for now: the cloud views are for observing.

You decide how much the factory decides.

Start with every gate on. Raise the autonomy tier as the factory earns it, and set a merge policy per environment.

Open by design. Your code, your models, your rules.

No black box and no lock-in. Your factory is plain files in your repo, running on the models you choose.

Your software factory, live in your repos. We build it with you.

We build Mutagent with it.

Architech is the factory behind our own product. It built Mutagent’s MVP, our agent factory, and the cloud infrastructure Architech itself now runs in.

Built by operators.

BeneCEO

PhD, 6 patents. Staff TPM at Cruise. CPO at Beam AI.

BurakCTO

Designed Beam AI's agent platform. Built Architech, the software factory that built Mutagent's MVP in 4 weeks.

See it run on one
of your own repos.

A 30-minute working session. Bring a real ticket from your backlog: we plan it with the factory, and you see the spec, the waves and the first PR come together live. No commitment.

How coding agents and planning evolved.

Shapes, agents and code live in separate layers.