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.
By Dakota Smith

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
- Dossier track
- DOSSIER I · The Agentic Organization
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]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.
| Stage | Engineer's Primary Role | Where Operational State Lives | What Breaks Without the Next Stage? |
|---|---|---|---|
| 1 · Chat and Autocomplete | Prompt 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 Loops | Interrogate 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 & Worktrees | Compile 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 & Fleets | Define 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 24native type-stripping plus Go-native paralleltsc --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]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.
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.- P0Contracts + <60s Attach CLI
Plane 0 · Law, Schemas & Drop-In CLI
Typed receipts, OTel GenAI spans, cross-harness compiler (CLAUDE.md / AGENTS.md)
- P1Cedar Policy + FinOps Broker
Plane 1 · Shield, Cedar WASM & Two-Speed Routing
150–250ms zero-output-token pre-flight guardrails before stateful reasoning
- P2Sandbox Runner + AST/WCAG Mesh
Plane 2 · Isolation Sandboxes & Synthesized MCP Mesh
V8 WASI + OverlayFs, Dagger OCI, Hyper-V sessions, OpenAPI/SQL-to-MCP
- P3X-Ray Scanner + Pack Registry
Plane 3 · Estate X-Ray & Governed Domain Packs
Zero-execution brownfield graphs, OKF memory, pluggable vertical packs
- P4Tenant IaC + Delivery Authority
Plane 4 · Client Stamp & Exact-Candidate Acceptance
Maker/checker worktrees, commit-SHA Proof of Done, human release disposition
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
Each plane owns one non-overlapping boundary across the delivery lifecycle.
- 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.
- 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.
- 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 SQLINFORMATION_SCHEMAendpoints into stateless MCP v2 servers on demand. - 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.
- 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: falsezero external retention. It pairs sub-250ms APM alert triage (>= 0.92calibrated 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]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.writeinside 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 (
inconclusiveblocks likefail). 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.
# 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-recordNotice 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.
- 01An AI Adoption Strategy That Works Without a Terminal9 min read
- 02An AI Governance Framework in Code, Not Slide Decks10 min read
- 03Agentic Engineering: From Solo Copilots to Governed FleetsReading now
- 04AI Isn't Just for Coders: How Claude Skills Bridge the Gap7 min read
- 05Claude Skills for Power Users: Scripts, Teams, and Architecture9 min read
Further analysis
Continue reading
Selected by shared architectural signals and recent publication history.
- 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.

- 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.

- 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...