Build your backend in one spec, not one week.

You've started a new project. You already know what's coming: the auth module, the migrations, the Dockerfile, the controllers, the DTOs, the validators. You've written it ten times. You'll write it again.

Or you describe it once — and Archon writes all of it for you. And the code is yours to keep.

You've already written this backend. Maybe ten times.

Every serious backend project starts with the same ~47 files: a module per domain, an entity per table, CRUD controllers, DTOs with validation, JWT setup, migrations, the Dockerfile, Swagger, error handlers, rate limiting. None of it is novel. None of it is what makes your product different. All of it is required.

So developers reach for one of four shortcuts. Each has a problem:

Archon was built for the fifth option: describe the system once, generate the code from deterministic templates, own the output forever.

An MCP-native architecture platform. Your AI agent runs the design loop with you.

Archon is not a CLI you learn. It's a set of Model Context Protocol (MCP) servers that your existing AI agent — Claude Desktop, Cursor, Windsurf, any MCP-capable client — plugs into. The agent you already use gains a new capability: "design and build me a backend, properly."

Behind that single capability lives a team of five specialist agents running on a shared memory plane: a vector store for semantic recall, a relational store for historical truth, and local inference for embeddings. They coordinate to take you from a sentence to a production codebase — with the UML class diagram as the contract you approve at every step.

The actual code is produced by the Archon Template Engine — a deterministic compiler we built. Same spec, same output, every time. No LLM is in the code-writing path. That's what makes the engine safe to re-run, predictable to scale, and possible to verify.

From a sentence to shipped code — the five-phase governed lifecycle.

You don't write a spec. You describe what you want, in plain language, to your AI agent. The agent then puts on five different hats — one per phase of the governed lifecycle. You approve at the two critical gates. The server refuses to skip a phase.

1. 00

   You describe what you want. In any words.

   "I need a booking platform with rooms, reservations, and customer profiles." That's it. No syntax to learn. You talk to your AI agent the way you already do.

2. 01

   Discovery — the Analyst extracts the requirements.

   Asks focused questions to pin down business rules, actors, domain events, and constraints. Scans available platform modules (Redis, BullMQ, Jenkins, Terraform, NewRelic, …). Locks everything into a Requirement Contract. archon_workflow_status shifts to DISCOVERY_DONE.

3. 02

   System Design — the Architect maps it to bounded contexts.

   Translates the requirements into domain shards, draws the UML class diagram (the contract you will approve), wires module dependencies, picks the Handlebars helpers needed for the templates, and emits the Architecture Contract. Hard rule: a minimum of 12 distinct entities for production workspaces.

4. ⟳

   You iterate on the diagram until it matches your intent.

   "Add a status field to Reservation." "Make Customer the parent of Booking." Each change redraws the class diagram. The loop ends only when you say the diagram is right. This is the most important step in the whole lifecycle.

5. 03

   Compilation & Planning — the Tech Lead validates and plans.

   Compiles all shards into a single DesignSpec.json, runs schema validation, and fingerprints the spec for immutability. Then produces an execution plan: the exact diff of files to create, update, or replace. You see it before anything ships.

6. ✓

   You approve the execution plan.

   The state machine refuses to materialize until you transition to USER_APPROVED with an explicit token. There is no auto-approve. There is no "trust mode." Archon writes nothing without your green light.

7. 04

   Materialization — the Orchestrator ships the code.

   Streams the approved execution plan through the governance gateway, writing every file deterministically: NestJS modules, TypeORM entities, controllers, DTOs, JWT auth, PostgreSQL migrations, Dockerfile, Jenkinsfile, Terraform, husky hooks. Your @ArchonManual()-marked code from prior runs is preserved by semantic hashing.

8. 05

   Verification — the Developer guards against drift.

   Verifies lineage, runs archon_reconcile to detect any file that diverged from the spec, and asks you to decide: align the file with the spec, or protect it (and update the spec instead). Decisions are logged. Your codebase never silently diverges from its source of truth.

Engineered part by part. Every layer materializes before your eyes.

This is the actual Archon lifecycle — not a diagram, not a flowchart. Each step shows you exactly what one specialist agent produces before handing off to the next. Step through it yourself or watch it auto-advance.

Use ← → arrow keys or click the dots to jump to any phase. Auto-advances every 3 seconds when idle.

One AI agent. Five hats. Strict separation of duties.

Archon's contract with your AI agent is precise: each phase has exactly one persona, and the personas don't bleed into each other. The Analyst doesn't write code. The Builder doesn't renegotiate requirements. This is what makes the lifecycle auditable — at any moment, the workflow state tells you which persona is active and what's allowed next.

Your AI agent already knows how to use Archon.

Archon is built on the Model Context Protocol — the open standard for how AI agents talk to external tools. That means:

From spec to working backend in six stages.

Every generation goes through the same six stages. Each stage is inspectable. Each stage is reversible. Each stage produces an artifact you can read.

Each box is a separate, testable Archon component. Click any stage to see exactly what it does. Every artifact between stages is written to disk so you can open it, diff it, and reason about it. There is no magic step — there is no LLM at any of these stages.

Watch a spec become a diagram, then a codebase — live.

In a real project, your AI agent describes your intent to the Archon MCP servers; the Architect persona drafts a UML class diagram inside an Architecture Contract; you iterate until the diagram matches what you meant; then the Tech Lead compiles it and the Orchestrator ships the code. This is that loop, compressed into one interactive panel:

1. Edit the spec on the top — entities, fields, relations.
2. Watch the class diagram redraw in real time — same algorithm the Architect uses to produce the contract you'll approve.
3. Browse the generated files below — 60+ production files from 22 lines of spec.

// loading…

How this differs from a real run: in production, your AI agent calls Archon's MCP servers, which run schema validation, retrieve past architectural decisions via semantic search, apply your platform feature flags, manage workflow state, and stream changes back to your workspace with governance gates. This panel shows the shape and scope of that output, locally — so you can feel what Archon produces without installing anything.

What "describe a booking system" actually means.

Let's say you're building a booking platform — rooms, reservations, customers. You write this:

Customer {
  id: uuid primary
  email: string
  name: string
}

Room {
  id: uuid primary
  name: string
  capacity: int
  pricePerNight: decimal
}

Reservation {
  id: uuid primary
  customerId: Customer
  roomId: Room
  checkIn: date
  checkOut: date
  status: string
}

And Archon writes all of this, ready to run:

• 3 NestJS modules wired into the root AppModule
• 3 TypeORM entity classes with foreign-key columns and indexes
• 3 service classes with full CRUD methods and repository injection
• 3 REST controllers exposing GET / POST / PATCH / DELETE with typed routes
• 6 DTO classes (Create + Update for each entity) with class-validator decorators
• 3 PostgreSQL migration files with proper foreign keys and rollback
• Swagger / OpenAPI decorators on every endpoint
• JWT auth guard wired and ready to attach
• Dockerfile, docker-compose.yml, package.json, tsconfig.json
• Jenkinsfile with build, lint, test, and deploy stages
• NGINX reverse-proxy config, environment variable validation
• Rate limiting, CORS, security headers, error handler, logger

That's roughly 47 files. From 22 lines of spec. The next time you change one field, only the affected files re-generate — your manual code in between is preserved.

Because we're not paying an LLM to write your boilerplate.

Other AI code-gen tools call a large language model for every file they produce. If your project has 47 files, that's 47 prompts, 47 round-trips, and 47 chances for the model to hallucinate. You pay for the tokens. You pay again when it gets one wrong and you re-prompt. You pay forever, every time you regenerate.

Archon doesn't call an LLM at generation time. The actual code is produced by the Archon Template Engine — a deterministic compiler we built specifically to translate a validated spec into production-grade TypeScript. It runs locally, on your machine, in milliseconds. The only AI step is optional and lives in front of the spec (helping you draft it), not behind it.

Because there's no model to wait for.

These numbers are pulled from the live benchmarks page, last measured on 2026-05-15. They are not marketing claims — they're reproducible by anyone who clones the repo.

Because templates can be tested. Hallucinations can't.

An LLM produces a different file every time you ask. You can't write a unit test against "what the model felt like writing this morning." A template, on the other hand, is just code. We run a real ESLint pass and a real TypeScript compile against the actual output of every Archon release.

What happens if Archon disappears tomorrow?

Nothing breaks. Here's exactly why — no marketing language, just facts:

How Archon compares to the alternatives.

An honest table. Where the alternative is better at something, we say so.

Connect Archon to your AI agent. World-class standard install.

Three steps, once. After that, Archon lives inside the AI agent you already use — no new editor, no new chat window, no context-switching.

npm install -g archonspecs

{
  "mcpServers": {
    "archonspecs-mcp": {
      "command": "archonspecs",
      "args": [
        "https://archonspecs.dev/mcp/sse?apiKey=<YOUR_TOKEN>"
      ]
    }
  }
}

The full MCP reference and tool catalog are in the documentation. The reproducible benchmark numbers are on the benchmarks page. The source is on GitHub.

The questions people actually ask.

Still on the fence? Open the benchmarks page — every number on this guide is reproducible.