The DOCOD Runtime is the open-source reference implementation of the DOCOD Method.
It derives engineering state directly from project files, verifies relationships, hashes, approvals and evidence, and prevents a gate from staying green when what supported it has changed.
The files are the state.
Open source · zero-install (Node ≥18, vendored YAML) · model-neutral
Define · Orchestrate · Confirm · Observe · [re]Define
The method organises how intent becomes decisions, how work is coordinated, how results are confirmed, how the system is observed, and how learning feeds the next cycle.
Its role is to make verifiable what should not depend on an agent’s memory, interpretation or word.
This is the SDLC, the Software Development Life Cycle.
The discipline software engineering has used for decades to turn intent into systems that can be built, tested, operated and evolved.
DOCOD does not replace that lifecycle.
It reorganises it for an environment in which agents take part in more and more of the execution.
| Classic SDLC | DOCOD movement | Artifacts you already recognise |
|---|---|---|
| Planning and feasibility | Define | business case |
| Requirements and analysis | Define | PRD, FRD, user stories |
| Design and architecture | Orchestrate | system design, data design, security design, API contract, ADR |
| Implementation | Orchestrate | tasks, code, evidence |
| Testing and verification | Confirm | test plan, QA, design review, code review |
| Deployment and operations | Observe | SLOs, runbooks, playbooks, release notes |
| Maintenance and evolution | [re]Define | postmortem, impact analysis, the next cycle |
The table shows where each artifact is most often born.
ADRs, RFCs, trade-offs and impact analysis are cross-cutting. They appear when a decision requires them, not because there is a fixed phase reserved for them.
A human developer fills a gap with experience, informal context, a hallway conversation or accumulated judgment.
An agent receives none of that by default. It receives context.
When that context is incomplete it does not necessarily stop. It infers. And a plausible inference can still produce the wrong software.
The more execution you delegate, the more explicit the engineering that directs it has to become.
Agents also help interview, structure requirements, compare documents, find inconsistencies, maintain artifacts and propagate change.
What once looked like documentation about the system starts taking part in the execution of it.
The specification stops being paperwork about the work. It starts programming the context in which the work happens.
It does not merely record that something was approved.
It checks whether the approval still matches the current content.
It does not merely record that one artifact depends on another.
It detects when the live input has changed.
It does not merely ask an agent to cite evidence.
It mechanically verifies what it can verify.
And when the required capability does not exist:
it does not manufacture a pass.
DOCOD does not replace the SDLC. It makes the SDLC operational for agentic software engineering.
Whenever the runtime runs, it reads the project again.
It is derived from the files that exist now.
Nothing needs to remember that the event happened. Current state emerges from what is on disk.
A legacy system does not have to be fully converted before the runtime can help. Diagnostic mode points at the repository and returns the map with provenance: what was observed, what was inferred, what came from someone outside the code. No pins, no gates, no frozen baseline.
Pre-read, not pre-approved.
The neutral discipline. The cycle and the principles that do not depend on model, language or tool.
Agents, rules, skills and contracts that define responsibilities, inputs, outputs and conditions.
The layer that materialises the method inside a harness. Slash commands, subagents and integrations belong here.
The actual project. Its configuration, its artifacts, its decisions and its state.
Files → Derive → Gate → Human decision
And then it reads the files again.
What changes between harnesses is the adapter. The method, the contracts and the state derived from files do not. A harness becomes supported by gaining an adapter, not by rewriting the discipline.
The list of roles is not hardcoded in the runtime: agents, skills and artifacts are DECLARED in registries. A project can add its own by writing the contract and registering it, exactly like the ones that ship in the box. What the method fixes is the shape of the contract, not who is in it.
These pieces are what give governance a body. Without them what remains is ethos.
It puts contracts, derived state, evidence and gates around execution.
Because the important question is not only:
Can the agent do this?
It is also:
How do we know what it was supposed to do, what it actually did, and whether we can still trust that result after the project changed?
When a person approves an artifact, the runtime records who approved it, when, and the hash of the approved content.
If the file changes later, the hash no longer matches. The old approval does not stay green for convenience: it becomes invalid, and whatever depends on it is reconsidered.
Artifacts record the inputs they depend on. When a live input changes, the runtime mechanically detects that the relationship is stale.
Understanding how that change should propagate still requires analysis. Detecting that the old premise is no longer the same does not: the input resurfaces as stale and downstream work is blocked again.
The runtime mechanically checks what it can prove: whether the frontmatter actually parses, whether the status is allowed by the method, whether the approval hash still matches the content, and whether the input hashes still match their live sources. The full list of checks and warnings lives in the manual.
Some conditions fail the gate. Others surface as warnings. And a pass also states its limits: a silent pass teaches nothing.
When the environment lacks a capability needed to verify something, the runtime does not turn missing evidence into success.
Missing capability is not permission to improvise.
It automates work.
Not accountability.
The project still needs to know:
That is what the runtime is for.
Open source · zero-install (Node ≥18, vendored YAML) · model-neutral