Skip to main content

DOSSIER I · The Agentic Organization (Entry 03 of 05)

Agentic Engineering: From Solo Copilots to Governed Fleets

Trace the four-stage shift to agentic engineering — from IDE chat to durable worktree fleets, a five-plane foundry, and exact-candidate delivery authority.

9 min read

By Dakota Smith

Share article

XLinkedIn
On this page6 parts

Architectural scope

Four-stage maturity architecture culminating in a five-plane, nine-service TypeScript foundry with progressive ceremony tiers and commit-SHA Proof of Done.

Cadence
9 min read
Structure
6 sections · 1 code specimen

AgenticThe adjective for "acts like an agent" — multi-step and self-directed, not one question and one answer.Describes AI that plans and takes a sequence of actions with some autonomy, adapting as new information comes back.Full definition engineering did not begin the day a language model wrote a clean function on the first PromptThe brief. Closer to writing instructions for a new contractor than to programming.The text you give the model — question, instructions, context. Its quality shapes the quality of the output.Full definition. It began the day my primary engineering output shifted from application code to the specifications, compilers, isolation sandboxes, and authorization gates that decide what autonomous agents are allowed to ship.

Across the 58 AI dev tools I built in 2026 and an anonymized enterprise foundry architecture, agentic engineering matured through four distinct stages. Organizations that equate agentic engineering with faster IDE autocomplete stall at stage one because keystroke speed was never what slowed enterprise software delivery down.01 · Abstraction ShiftOnce code generation becomes abundant, senior engineering impact concentrates in domain boundaries, deterministic verification, and release authority.

Here is the four-stage climb from ad-hoc chat to supervised loops, durable worktree fleets, and a five-plane engineering foundry. Along the way, we will cover exact-candidate delivery authority, what breaks in transition, and when coding by hand stays faster.

The Four Stages of Agentic Engineering

Teams routinely try to leap straight from IDE chat tabs to background AgentA worker you delegate to: brief it, and it takes steps on its own. A chatbot answers; an agent acts.An LLM that runs tools in a loop toward a goal — it acts, checks the result, decides the next step, and repeats until done.Full definition swarms and spend the next sprint untangling broken branches. Each stage constructs the deterministic guardrails that stop the next level of autonomy from multiplying architectural drift.

StageEngineer's Primary RoleWhere Operational State LivesWhat Breaks Without the Next Stage?
1 · Chat and AutocompletePrompt line-by-line and edit diffs inside one editor tab.Ephemeral IDE buffers and local chat history.Local speedups create cross-PR pattern drift.
2 · Supervised Personal LoopsInterrogate specs, gate confidence, and enforce shell checks.Repo-local plan state and deterministic loop exit codes.Every developer runs incompatible local prompts and rules.
3 · Compiled Canons & WorktreesCompile multi-HarnessThe cockpit around the engine. The model is the engine; the harness is everything that makes it useful and safe to fly.The runtime around the model — the loop, tool access, memory, prompts, and guardrails. The model reasons; the harness does everything else.Full definition rules and supervise isolated Git worktrees.Versioned catalogs, linked worktrees, and JSONL event ledgers.Laptop sessions still tie execution and credentials to one host.
4 · Five-Plane Foundry & FleetsDefine contracts, ceremony tiers, sandboxes, and release verdicts.Client-tenant stamps, candidate SHAs, and signed proof bundles.Review queues flood without maker/checker separation and leases.

Stage 1 feels productive in week one. Inline completions shave twenty percent off isolated functions, then sprint four delivers the hidden invoice: three competing error conventions, duplicated data helpers, and tests generated to mirror implementation bugs. Stage 2 begins when you wrap generation in an explicit runtime harness, evolving from phased review in APL to pre-execution supervision in STUDIO. Execution blocks until a questioning gate clears a confidence threshold and every step passes typecheck, lint, and tests.

Personal supervision solved single-player drift and immediately exposed a multi-player ceiling. One architect maintaining a disciplined local .claude/ folder does nothing for ten engineers on the same client engagement whose harnesses share none of those constraints.

Stage 3: Compiled Canons and Durable Worktree Fleets

Scaling agentic engineering across a delivery pod meant turning senior engineering judgment and session isolation into repository infrastructure. Three structural upgrades carried that transition.

  • Byte-locked cross-harness compilation. Delivery teams run Claude Code, Codex, and Copilot side by side. Compiling one plain-file canon via base kept CLAUDE.md, AGENTS.md, and Copilot rules identical to the byte, backed by dual-surface catalog distribution and pull-request governance gates.
  • Durable worktree isolation without transcript scraping. Running parallel agents against one checkout scrambles Git index state. Mapping each work item to its own branch, linked Git worktree, and persistent shell session let runs survive terminal restarts. Bounded lifecycle events wrote to an append-only JSONL ledger without scraping raw prompts, and final diffs checked against an immutable start commit so one lead supervised five to ten parallel worktrees safely.
  • Sub-ten-second verification seams. Agents flail when testing a three-line patch requires booting four cloud emulators. Standardizing control planes on erasable-syntax TypeScript (Node 24 native type-stripping plus Go-native parallel tsc --noEmit) while isolating polyglot .NET, Python, and SQL workloads behind crisp command seams gave every agent turn a fast, unambiguous pass/fail signal.

Stage 4: The Five-Plane Foundry and Progressive Ceremony

Once rules, ontologies, and worktree supervision proved reliable, a new architectural hazard appeared: nano-repository sprawl. Spinning up a bespoke agent repo for every CMS vendor, cloud stack, or client engagement creates polyglot maintenance paralysis.

By November 2026, our architecture consolidated into a Five-Plane, Nine-Service Engineering Foundry. Nine coarse horizontal services own platform mechanics, while vertical practices (Sitecore, Optimizely, Umbraco, data platforms, healthcare, governance) ship strictly as pluggable Domain Packs.02 · Three-Question GateA tenth core repository is blocked unless it ships an independent release artifact, requires a separate client IP boundary, or exceeds 35% of platform compute.

PLATE 04FIVE-PLANE ENGINEERING FOUNDRY
REV 2026.11 // PROGRESSIVE CEREMONY

Horizontal Platform Planes Paired With Progressive Engagement Ceremony

Five horizontal foundry planes—Plane 0 Law and CLI, Plane 1 Shield and Two-Speed Routing, Plane 2 Sandboxes and Synthesized MCP Mesh, Plane 3 Estate Intelligence and Domain Pack Catalog, and Plane 4 Runtime Stamp and Exact-Candidate Acceptance—paired with three progressive ceremony tiers from sub-60-second WASI drop-in to enterprise tenant stamp.
  1. P0

    Plane 0 · Law, Schemas & Drop-In CLI

    Typed receipts, OTel GenAI spans, cross-harness compiler (CLAUDE.md / AGENTS.md)

    Contracts + <60s Attach CLI
  2. P1

    Plane 1 · Shield, Cedar WASM & Two-Speed Routing

    150–250ms zero-output-token pre-flight guardrails before stateful reasoning

    Cedar Policy + FinOps Broker
  3. P2

    Plane 2 · Isolation Sandboxes & Synthesized MCP Mesh

    V8 WASI + OverlayFs, Dagger OCI, Hyper-V sessions, OpenAPI/SQL-to-MCP

    Sandbox Runner + AST/WCAG Mesh
  4. P3

    Plane 3 · Estate X-Ray & Governed Domain Packs

    Zero-execution brownfield graphs, OKF memory, pluggable vertical packs

    X-Ray Scanner + Pack Registry
  5. P4

    Plane 4 · Client Stamp & Exact-Candidate Acceptance

    Maker/checker worktrees, commit-SHA Proof of Done, human release disposition

    Tenant IaC + Delivery Authority

TIER 1 · TACTICAL DROP-IN

< 60s setup · 1h–3d work

Local V8 WASI + OverlayFs; zero cloud provisioning

TIER 2 · PROJECT MESH

1–4h setup · 2w–6m build

Synthesized API/SQL MCPs + isolated maker/checker worktrees

TIER 3 · ENTERPRISE STAMP

Day-1 IaC · 6m+ & 24x7 SLA

Client-tenant Shield gateway + Hyper-V sessions + signed receipts

PLATE 04: Nine coarse horizontal services across five planes prevent nano-repo sprawl while scaling ceremony from a 60-second local WASI drop-in to a dedicated enterprise cloud stamp.

Each plane owns one non-overlapping boundary across the delivery lifecycle.

  1. Plane 0 · Law, Schemas & Sub-60s CLI. Defines shared Zod 4 contracts, MCPUSB-C for AI — one standard plug so any agent can connect to any data source or tool.The Model Context Protocol: an open standard (Anthropic, 2024) for connecting AI systems to external tools and data without building a custom integration for each one.Full definition v2 envelopes, OpenTelemetry GenAI FinOps spans, and AI-disclosure schemas. A companion tactical CLI mounts cross-harness instructions in under sixty seconds.
  2. Plane 1 · Shield, Cedar WASM & Two-Speed Routing. Runs a 150–250ms zero-output-TokenA chunk of text — roughly three-quarters of a word. The unit the model reads and bills in.The fragments a model breaks text into. Around 100 tokens ≈ 75 English words. Limits and pricing are counted in tokens, not words or characters.Full definition pre-flight pass for prompt injection, PII, blast radius, and model-tier routing. Sub-millisecond Cedar policies then authorize calls, broker Entra secrets, and sign Ed25519 receipts.
  3. Plane 2 · Sandboxes & Synthesized MCP Mesh. Negotiates isolation across local V8 WASI (jco + QuickJS + OverlayFs), Dagger OCI pipelines, and Azure Container Apps Hyper-V Dynamic Sessions. Companion synthesis compiles OpenAPI 3.1, GraphQL, and SQL INFORMATION_SCHEMA endpoints into stateless MCP v2 servers on demand.
  4. Plane 3 · Zero-Execution Estate X-Ray & Domain Packs. Scans brownfield repositories, M&A codebases, and serialized CMS trees into static dependency graphs without executing untrusted client code. Pluggable role and platform Domain Packs attach from a compiled registry.
  5. Plane 4 · Client Tenant Stamp & Managed SLA Ops. Deploys containerized orchestration inside the client's Azure (Bicep) or AWS (Terraform) tenant on Day 1 with store: false zero external retention. It pairs sub-250ms APM alert triage (>= 0.92 calibrated confidence for reversible runbooks) with under-three-minute automated 8-section handoff bundles.

Pairing horizontal planes with progressive ceremony tiers let one platform serve every engagement horizon. A two-hour hotfix on a locked-down banking VDI uses Tier 1 local WASI drop-in (<60s, zero cloud setup). Three-month modernizations run Tier 2 project meshes with synthesized API/SQL MCPs, while multi-year managed engagements deploy Tier 3 Day-1 client cloud IaC.

Exact-Candidate Authority and the Four-Gate Discipline

Autonomous throughput means nothing if an agent can grade its own homework or collide with another agent on a shared staging server. Stage 4 enforces exact-candidate delivery authority, evolving our agent delivery harness around four operational invariants.03 · Inconclusive BlocksIn exact-candidate verification, a timed-out check, skipped suite, or single byte of post-run diff mutation blocks promotion identically to a failed test.

  • Four-gate separation of concerns. Workflow state machines separate requirements consent (approved scope and non-goals), bounded execution allowances (permitted paths, sandboxes, and spend), independent build verification, and human release disposition.
  • Structural maker/checker separation. Implementing sessions hold repo.write inside allowed paths and can never modify protected test suites or verify their own candidates. An independent checker session runs clean-room verification and adversarial diff review against the candidate.
  • Commit-SHA Proof of Done (inconclusive blocks like fail). Every gate binds to the exact candidate commit SHA. Verification emits a content-addressed evidence bundle mapping acceptance criteria to build logs, WCAG checks, semantic CMS tree diffs, and provenance receipts.
  • Shared environment leases and reversible changesets. Parallel worktrees must acquire time-bounded leases before touching shared CMS Content Management or staging instances, recording journaled inverse operations so failed validations roll back cleanly.
contracts/exact-candidate-work-order.yaml
# Stage 4 work order: progressive ceremony + maker/checker Proof of Done
workOrder: modernize-checkout-inventory-adapter
ceremonyTier: tier-2-project-mesh
routing:
  preflightModel: closed-world-decision-pass   # 150-250ms, 0 output tokens
  maxBlastRadiusScore: 2
makerSession:
  sandbox: dagger-oci-isolated
  capabilities: [repo.read, repo.write, mcp.synthesized-openapi-readonly]
  protectedPaths: [tests/conformance/*, .github/workflows/*, iac/*]
  environmentLease: staging-cm-slot-02
checkerSession:
  independentSessionRequired: true
  gates: [tsc-parallel-noemit, vitest-unit, playwright-wcag22, cms-tree-drift]
  inconclusivePolicy: block                    # inconclusive blocks like fail
disposition:
  byteTamperInvalidatesApproval: true
  humanApproverRole: principal-engineer-of-record

Notice where authority terminates. Agents synthesize context, propose patches inside leased sandboxes, and assemble verification evidence; deterministic runners certify the exact commit digest; and a named human engineer of record authorizes promotion.

What Breaks in the Transition (and When to Write It Yourself)

Climbing all four stages of agentic engineering exposes organizational bottlenecks that tool demos routinely hide.

Review queues replace coding bottlenecks. Ten parallel worktrees opening draft pull requests before noon will bury a tech lead by Wednesday. Stage 4 only holds when PRs stay narrow, inconclusivePolicy: block filters every broken or unverified candidate before human notification, and review ceremony scales by blast radius.

Specification debt compounds at machine speed. Give an ambiguous story to a senior developer and they clarify the edge case in five minutes. Give an ambiguous story to a background swarm without a Stage 2 questioning gate and you receive 1,400 lines of well-typed code solving the wrong business rule. Crisp domain invariants and explicit non-goals become the highest-return engineering skill on the floor.

Incident readiness erodes under rubber-stamp review. If engineers approve Proof of Done bundles without understanding failure paths and state transitions, 2 a.m. incident response degrades within two quarters. Engineers of record must still defend architectural tradeoffs and rollback behavior in review.

When NOT to use autonomous fleets. Keep your hands on the keyboard for initial domain discovery where writing the first prototype reveals where the real abstractions sit. Write code by hand for cryptographic or auth boundary modules, and for twenty-line fixes where authoring a work contract takes longer than writing the patch.

Conclusion

Agentic engineering does not replace software engineering; it promotes software engineering from hand-crafting every line to designing the deterministic planes under which code is produced, verified, and accepted. Moving from solo chat to supervised loops, durable worktree fleets, a five-plane platform foundry, and commit-SHA Proof of Done lets teams scale autonomous throughput without surrendering engineering rigor.

Key Takeaways:

  • Earn each stage in sequence: Supervise single loops and compile shared repo canons before launching parallel background fleets.
  • Isolate parallel runs by construction: Pair linked Git worktrees with non-scraping JSONL ledgers and environment leases so concurrent agents never trample shared state.
  • Prevent nano-repo sprawl with horizontal planes: Keep core platform mechanics in coarse horizontal services and ship vertical CMS or industry skills as pluggable Domain Packs.
  • Match ceremony to engagement horizon: Scale smoothly from a sub-60-second local V8 WASI drop-in to synthesized project MCP meshes and Day-1 client cloud stamps.
  • Bind acceptance to exact candidates: Enforce maker/checker session separation, treat inconclusive gates as failures, invalidate approval on a single byte of drift, and keep a named human on release authority.

To dive deeper into the implementation patterns behind Stages 2 through 4, explore the Harness Engineering, Agentic Patterns, and AI Security pillars on daksmith.dev.

DOSSIER I · ENTRY 03 OF 05

The Agentic Organization

How an engineering practice moves from idle seat licenses to dual-surface distribution, CI-enforced governance, and accountable agent fleets.

Security & Governance Pillar
  1. 01An AI Adoption Strategy That Works Without a Terminal9 min read
  2. 02An AI Governance Framework in Code, Not Slide Decks10 min read
  3. 03Agentic Engineering: From Solo Copilots to Governed FleetsReading now
  4. 04AI Isn't Just for Coders: How Claude Skills Bridge the Gap7 min read
  5. 05Claude Skills for Power Users: Scripts, Teams, and Architecture9 min read

Further analysis

Selected by shared architectural signals and recent publication history.

  1. 01AI14 min read

    The AI Dev Tools I Built in 2026: 58 Builds, Five Shifts

    Trace 58 AI dev tools I built across 70 workspaces in 2026 — from early agent loops to DXP ontologies, fleet worktrees, FinOps gateways, and signed proof.

  2. 02AI10 min read

    An AI Governance Framework in Code, Not Slide Decks

    Build an AI governance framework in code: a 15-module NIST PR spine, Cedar policy narrowing, sub-250ms pre-flight guards, and a 7-stage board assurance DAG.

  3. 03AI14 min read

    The Agent Delivery Harness: An Opinionated Multi-Model Layer

    An agent delivery harness turns human intent, experience, and judgment into accountable, evidence-bound decisions across one or more model runtimes.

Discussion

Loading comments...