Agentic Development Framework (ADF)
The orchestration layer of the Agentic Work System — defining stage gates, agent roles, boundaries, governance rules, and the process discipline that keeps autonomous development coherent and auditable.
The Problem with “Agentic” Development
Most agentic coding tools are sophisticated prompts in a loop. They lack context persistence, defined roles, and any governance discipline. An agent that can do anything, in any order, with no checkpoints, is not a system — it’s chaos with an API key.
ADF is the orchestration layer of the Agentic Work System. It defines the process — the stage gates, agent roles, boundaries, and governance rules — that give autonomous development structure.
Two Layers
The Environment Layer — capabilities that persist across all projects:
- Orchestration rules and agent role definitions
- Capabilities registry (what tools, skills, MCP servers are available)
- Connections to the shared Knowledge Base and Memory systems
- Governance rules (codified in
.claude/rules/— agents cannot override them)
The Project Layer — ephemeral per-project structure with strict stage gates:
Discover (Intent) → Design (Specs) → Develop (Build) → Deliver (Ship)
Each gate requires specific artifacts and human approval before proceeding. No stage can be skipped. But the work doesn’t end at Deliver — there’s a continuous Operate → Improve feedback loop that surfaces what worked, what broke, and what the next iteration needs. ADF projects don’t close; they cycle.
Two Types of Context
ADF makes a hard distinction between two types of context that agents work with:
Ephemeral working context — the accumulated conversation history, intermediate tool calls, in-session reasoning. This is intentionally short-lived. ADF wipes it between phases. The agent re-reads authoritative artifacts — not conversation history — to continue. This prevents context drift: the gradual degradation of decision quality as a session accumulates noise, stale assumptions, and contradictory state.
Durable artifacts — intent docs, design specs, stage outputs, architecture decisions. These persist because they are the authoritative state of the work. The intent that drives the project must remain intact through every phase. The plan lives in these files, not in an agent’s memory.
The discipline: ephemeral working context is cheap and disposable. Artifacts are the record.
The Handoff Problem: Context Pollution
When ADF delegates work between agents — or between a human and an agent — there’s a second context problem: pollution.
Agent 2 doesn’t need everything Agent 1 accumulated. If you hand over a full context window containing an entire session’s reasoning, intermediate states, and tangential observations, you’ve given Agent 2 noise it must filter rather than signal it can use. The handoff should be precise: exactly what Agent 2 needs to do the next task, no more.
Context drift is a temporal problem — quality degrades within a long session. Context pollution is a handoff problem — too much of the wrong context crosses an agent boundary. ADF addresses both: stage gates for drift, structured handoff protocols for pollution.
Codified Governance
Rules are not suggestions. ADF enforces governance constraints through hard-coded rules in .claude/rules/ that agents read but cannot modify:
- Never commit secrets or credentials
- Never skip stage gates without human approval
- Confirm before destructive operations
- Re-read shared files before writing in multi-agent contexts
Connection to AGF
Every pattern that works in ADF practice becomes an AGF design pattern. Every failure surfaces a framework gap. ADF is the proving ground; AGF is where the lessons are formalized and made reusable.