The premise of building enterprise software has changed.

How it actually works.

Orch is built around one working assumption, learned the expensive way: a model can write a correct 100–300 line unit of code in isolation, but multi-file builds fail at the seams between units. So the system manages seams, not just generation. What follows is the real machinery, described from the source code at v0.92 — not from marketing memory.

graph TB
    subgraph Studio["Orch Studio (v80)"]
        Conv["Conversation"] --> Domain["Domain Parser"]
        Domain --> Method["Method Agent"]
        Method --> Grill["Conversational Grill"]
        Grill --> Wire["Wireframe Generator"]
        Wire --> Council_S["Council Debate"]
        Council_S --> Stranger["Stranger Test"]
        Stranger --> Decompose["Mission Decomposer"]
    end

    subgraph Build["Orch Build"]
        TickGen["Ticket Generator"]
        Executor["Modular Executor<br/>5-phase pipeline"]
        Verify["19 Quality Gates"]
        Report["Build Report"]
    end

    subgraph Intelligence["Intelligence"]
        Retro["Retrospector<br/>174 crystals"]
        Gap["Gap Analyst"]
        Heatmap["Domain Heatmap<br/>49 rules, 7 songlines"]
        Schema["Schema Contract"]
        Runtime["Runtime Smoke Test"]
    end

    subgraph Data["Supabase"]
        DB[(PostgreSQL 17<br/>22 migrations)]
    end

    Decompose -->|missions| TickGen
    TickGen --> Executor
    Executor --> Verify
    Verify --> Report
    Report --> Retro
    Retro --> Gap
    Heatmap --> Executor
    Schema --> Executor
    Runtime --> Verify

    Studio --> Data
    Build --> Data
    Intelligence --> Data

    style Studio fill:#1a1e28,stroke:#3b82f6,color:#F1F3F5
    style Build fill:#1a1e28,stroke:#FBBF24,color:#F1F3F5
    style Intelligence fill:#1a1e28,stroke:#22c55e,color:#F1F3F5
    style Data fill:#1a1e28,stroke:#ef4444,color:#F1F3F5

1. From mission to tickets.

A natural-language mission is decomposed into dependency-ordered, self-contained tickets on the Auftragstaktik pattern — each carries its purpose (“i syfte att”), its downstream consequence (“därefter”), and a definition of done (“slutligen”) — so an isolated builder with no view of the rest of the build can still make a sound call.

graph LR
    E["Client describes<br/>what they need"] --> DP["Domain Parser<br/>(5s)"]
    DP --> MA["Method Agent<br/>(30-60s, web search)"]
    MA --> CG["Conversational Grill<br/>(10-30 min, adaptive)"]
    CG --> WF["Wireframe Generator<br/>(real-time HTML)"]
    WF --> CD["Council Debate<br/>(5 perspectives, visible)"]
    CD --> ST["Stranger Test<br/>(quality gate)"]
    ST --> MD["Mission Decomposer<br/>(2-4 specs)"]
    MD --> BQ["Build Queue"]

    style E fill:#D97706,color:#0A0C10
    style BQ fill:#22c55e,color:#0A0C10

2. Three build strategies.

A sequential CLI builder with cumulative context; a parallel “ant colony” of API workers that between waves re-scans the filesystem for what has actually been built rather than trusting the plan; and a five-phase architect-first pipeline (architect → contract → build → assemble → verify) for multi-subsystem work. Mode selection is a deterministic function of the mission’s shape, not a mood.

3. Nineteen gates, then judgment.

Output passes nineteen automated quality gates — compilation, tests, secret scan, completeness, design-token use, plus a layer of integration checks added after the first-generation pipeline kept passing components that failed to compose (API contracts, route wiring, auth headers, env-var safety, user-path, build). Deterministic checks run before any model is asked for judgment; then a separate model reviews the code, and an intent-fidelity pass asks whether the build serves the original mission, not just the acceptance criteria. The builder’s self-report is never accepted as evidence.

4. The part nobody sees: it learns.

Around the pipeline sits a retrospective system almost as large as the pipeline itself — 27 modules and 8 of the platform’s 14 database tables — that reviews every build’s outcome, tracks recurring failure modes, distills them into “crystals” injected into future prompts, and periodically scores its own autonomy level. Plus a tree-sitter codebase graph so downstream agents query for slices of a codebase instead of ingesting raw source.

graph TD
    MC["Metrics Collector<br/>11 dimensions"] -->|stores| BM["build_metrics"]
    BM --> GA["Gap Analyst"]
    GA --> RA["Research Agent<br/>(codebase-blind)"]
    RA --> SW["Spec Writer<br/>missions/orch-agent-missions/"]
    SW --> DC["Decision Classifier"]
    DC -->|reversible| IQ["Improvement Queue"]
    DC -->|irreversible| AR["Adversarial Reviewer"]
    DC -->|existential| AR
    AR --> IQ
    IQ -->|approve| BO["Build Orchestrator"]

    style MC fill:#22c55e,color:#0A0C10
    style IQ fill:#FBBF24,color:#0A0C10
    style AR fill:#ef4444,color:#0A0C10

Built by one person.

I spent twenty years in finance and industry — a decade as a director at Citi, co-founder and CCO/CFO of an industrial software company, Sergeant in the Swedish Amphibious Forces — and wrote my first line of code in February 2026. Orch exists because I couldn’t find a way to build what I knew I needed without hiring a team I didn’t want to run or learning to write software myself. Turns out I didn’t need to learn to write code; I needed to build a platform that let me stop needing to. By version 14 the platform was good enough to build itself. Every release since has shipped that way — the self-build isn’t a party trick, it’s the integrity test: if the platform can’t govern its own construction, it can’t govern anyone else’s. The longer story, and the person, live at interstice-advisory.com.

Built with Orch.

In one measured self-build run, Orch produced its own SaaS infrastructure module in 17 minutes — roughly 30,000 lines an hour. Rates like that are exactly why the nineteen gates exist. 15+ production systems built since February 2026; the platform itself is ~130,000 lines at v0.92, every one machine-written.

Full case studies (static HTML, no JavaScript required):

• Project Management
• Agricultural Intelligence
• Clinical Trial Intelligence
• Verk — The Daily Driver
• Quantum Circuit Simulator
• What is governed autonomous coding?