0% read on this device
Browse the curriculum

Start Here

Vision

First Principles

Operating Model

Domain Model

Agent Factory

Runtime Architecture

AI Engineering

Autonomous Workflows

Verification & Delivery

Factory Platform

Quality Engineering

Security & Governance

Case Studies

Labs

Interview Practice

Research Journal

Reference

Curriculum/Runtime Architecture/A rapid review of the chapter’s existing Quick Read, principles, definitions, lessons, and review material.
Runtime Architecture10 min readchapterQuick Read

AI Software Factory Reference Architecture

Connect intent, authority, execution, verification, delivery, operations, and learning through one canonical architecture.

Status: Review readyRisk: highLifecycle: executeContent reviewed 2026-08-30Maturity guide →
Claim boundaryThis chapter references implementation evidence. Inspect its evidence boundary before treating a claim as proven.
study mode

A rapid review of the chapter’s existing Quick Read, principles, definitions, lessons, and review material.

Quick Read

The chapter in one pass.

~2 min
  • Purpose: Connect intent, authority, execution, verification, delivery, operations, and learning through one canonical architecture.
  • Four synchronized views: Lifecycle; logical components; deployment and trust boundaries; authority and evidence.
  • Core rule: Planes own decisions and records. They do not require one service per box.
  • Evidence boundary: This is review-ready architecture. The case-study section states the narrower implementation evidence separately.
Whiteboard exercise

Reconstruct and defend this chapter’s architecture.

Reconstruct the architecture, name each boundary, and defend the tradeoffs.

runtimeharnessenvironment10 min chapter
Open the source exercise

Draw all planes and the golden path in ten minutes. For every arrow state the command/event, identity, authoritative record, failure mode, idempotency strategy, and human decision. Then redraw it as a three-deployment V1 and defend what you combined.

3. Enduring Principle

Organize the factory into cooperating planes

Planes are responsibility boundaries, not necessarily deployable services. A small V1 may implement several in one codebase while preserving their contracts.

Control plane

Owns authoritative hierarchy, specification baselines, policy evaluation, approvals, dispatch eligibility, lifecycle transitions, exceptions, and reconciliation. It decides what may happen; it should not perform arbitrary repository mutation.

Execution plane

Accepts frozen, bounded execution manifests. It claims work through leases, invokes models and atomic tools, operates in isolated sandboxes, produces artifacts and structured completion reports, and tolerates retries. It cannot expand its own authority or accept its own WorkOrder.

Quality plane

Compiles quality contracts, runs independent deterministic and probabilistic validators, normalizes evidence, evaluates freshness and contradictions, and recommends or records eligibility under policy. Builder and validator execution contexts are logically separate.

Delivery and outcome planes

The factory governs delivery but may delegate mechanics to GitHub Actions, Argo CD, or another system. It binds approvals and evidence to exact artifacts, observes canaries and production outcomes, and reopens or quarantines work when reality contradicts pre-release claims.

Data plane

Maintain distinct stores or logical record classes for authoritative domain state, append-only audit history, immutable evidence, large artifacts, and sampled telemetry. Use one correlation spine, classification, retention, encryption, backup, and tenant isolation model. Never reconstruct authority from logs.

Security plane

Every human, service, agent configuration, worker, and tool endpoint has an identity. Authorization is capability- and scope-based. Dangerous actions require explicit grants, risk gates, and short-lived credentials. Sandboxing, network/file boundaries, secret brokering, provenance, and tamper resistance constrain compromise.

Human governance

Humans own Mission intent, material Plan approval, risk exceptions, authority promotion, consequential deployment, and policy/learning promotion. Operators should see evidence and surprises, not supervise every token.

Preserve agent parity without equal authority

Any supported operator outcome should be achievable through an authorized tool/API path so agents are not second-class automators. That does not mean agents receive every human permission. Parity concerns reachable outcomes and composable primitives; governance determines who may invoke which primitive, for which subject, under which conditions.

Use one orchestrator and event-driven contracts

A unified orchestration authority coordinates lifecycle state while workers remain replaceable. Commands request work; events report facts; domain mutations decide authoritative transitions. Idempotency keys, leases, compare-and-set transitions, outbox/inbox patterns, and reconciliation protect at-least-once delivery.

Prefer atomic tools and explicit completion

Expose narrow primitives—read file, run test, create branch, publish PR—not opaque mega-tools that plan, mutate, approve, and report success. The orchestrator composes them under a manifest. Completion requires a structured report containing exact outputs, lineage, evidence references, and unresolved findings.

8. Personal notes and lessons learned

  • The model is a replaceable execution dependency; authority and evidence are the architecture.
  • A plane is useful only if I can name the decision it owns and the records it may mutate.
  • Agent-native parity should improve composability without erasing human accountability.
  • V1 should be a vertical proof, not a catalog of horizontal platforms.

9. Interview questions

  1. Why separate control and execution planes?
  2. Is the quality plane a service, a team, or a responsibility boundary?
  3. How do you support agent parity while preserving separation of duties?
  4. When would you split the modular monolith?
  5. How does at-least-once messaging affect Attempt and evidence design?
Evidence boundary

Curriculum maturity is not implementation proof.

This chapter defines architecture or practice. It does not by itself prove a corresponding production implementation.

CurriculumReview readyImplementation evidenceNot asserted hereInspect evidence map →
External review

Review this chapter.

Challenge a claim, boundary, missing failure mode, unclear term, or unsupported evidence statement.

  • Claim
  • Boundary
  • Failure
  • Evidence