01 · Two Registers
Most agent frameworks have one place for rules. Substrate has two.
Open a production agent stack today and find the rules. They live in the prompt. System prompts at the top of the context window. In-context examples wedged in to demonstrate desired behavior. Tool descriptions with inline behavioral hints. RAG-retrieved boilerplate carrying organizational policy. Persona definitions. Safety preambles.
All text. All read by the model. All subject to whether the model decides to honor them.
Substrate works differently. The rules live in two places, and the places aren't redundant. They serve different jobs, and the substrate treats them as different artifacts.
Register One
Compiled Doctrine
Rules the runtime enforces structurally. Deterministic. Testable. Checked at the boundary before the action is admitted. The model never sees the path to violate them because the runtime doesn't expose it.
Register Two
Interpretive Doctrine
Rules the agent reads. Judgment-shaped prose. Applied contextually at decision time. The rule's surface is the reading agent's judgment; the substrate trusts the agent to interpret it.
Two registers. Different machinery. Different artifacts. Both versioned alongside code. Both subject to evolution from observed friction. The split is not an implementation detail. It is the structural property that makes the rest of the substrate work.
02 · Compiled Doctrine, In The Wild
Rules the model literally cannot violate.
Compiled doctrine in substrate is concrete. The runtime enforces specific properties at dispatch time, and the model never sees the option to break them.
Enforced by the runtime today
permissionsA coordinator-tier agent cannot write code. The runtime does not expose the file-write tool to it.
pre-runA coordinator agent must run in a mode that cannot directly touch the filesystem. The runtime rejects it before the model is invoked otherwise.
lifecycleThe runtime advances a chain through build, review, and release in a fixed order. The model does not decide what comes next.
lineageEvery action carries its parent's ID. Orphaned actions are structurally impossible.
cancellationA cancellation cascades through the whole work tree, not just the root. The model cannot escape its own cancellation.
None of these are asked. None are documented in a system prompt for the model to honor. They are properties of the runtime. The runtime checks them at the boundary, and the boundary fails closed.
The compilation step happens implicitly. A role's rule-set is read when the agent starts, and its constraints become enforced gates. A coordinator-tier agent is not told "do not write code." Writing code is not in its tool surface. The model could try to spell out a write operation, but the runtime would not route it; the model has no way to execute outside of what the runtime exposed. The rule is not known by the model. It is structural.
A coordinator-tier agent isn't asked not to write code. Writing code isn't a path the runtime exposes.
The visual editor surfacing this compiler (cos's V6 Doctrine Editor: PREDICATE, ROUTER, ACTION, OUTPUT nodes wired into testable DAGs) does not introduce the concept. The compiler is already in the substrate. The editor makes it operator-editable. The image of a rule being authored with a TEST gate passing is the image of an existing compiler being addressed by a visual surface.
03 · Interpretive Doctrine, In The Wild
Rules that need an agent's judgment to apply.
Not every rule can be compiled. Some rules require context, weighing, judgment about what's currently true, and a read on what should happen next given a specific situation.
Judgment-shaped, read at decision time
recoveryRescue work, don't discard it. When an agent produces real work-product but the final integration step fails, the recovery procedure pulls the result out of the agent's isolated workspace rather than throwing it away.
altitudeCoordinators don't grind leaves. A top-level coordinator does not drop down to do mechanical work itself, even when it could.
supervisionRunning is not productive. An agent burning tokens without producing useful actions is not progressing. Read the trace.
judgmentForward momentum is itself a value. Better to make a defensible call and let a supervisor override than halt waiting for permission.
These rules cannot be compiled without losing their fidelity. "Fails" in the recovery rule has too many shapes; the runtime can detect specific failure modes but cannot anticipate every case. "Mechanical work" is contextual; what counts as mechanical for one task is genuinely uncertain for another. "Forward momentum" requires weighing whether the next move is defensible, which is a judgment call no compiler can make in advance.
Interpretive doctrine relies on the agent reading carefully and applying contextually. The agent is the enforcer, but only of rules that genuinely require an enforcer with judgment. The runtime does not abdicate; it delegates only the rules whose nature is judgment-shaped.
04 · The Partition Rule
Which register does a rule belong to?
Substrate has a single rule for sorting any new piece of doctrine into one register or the other:
A rule belongs to whichever register can express it without losing fidelity.
If a rule compiles to a deterministic gate without losing the intent, it is compiled. The runtime should enforce it. The model should never see the option.
If a rule requires judgment, weighing, or context, it is interpretive. The agent should read it. The runtime should not pretend it can be checked structurally.
Mistaking the registers is itself a doctrine bug. Two failure modes appear:
Compiling a judgment-shaped rule produces brittle false-positives. The rule cannot capture every legitimate case, so the runtime starts blocking real work as if it were a violation. Operators learn to work around the false-block, which trains the team to bypass enforcement, which makes the next enforcement weaker.
Interpreting a structurally-enforceable rule produces drift. The rule is read by some agents and not others. Compliance becomes probabilistic. The team takes the drift personally and tries to fix it with more prompt-text, which compounds the problem. Eventually the rule stops being a rule and starts being a hope.
The partition rule prevents both failures. The visual editor is not where prose-judgment lives. The written doctrine document is not where deterministic gates live. The artifacts exist as two things because doctrine is two things.
05 · Why The Bifurcation Is The Differentiator
Most platforms flatten both registers into one surface.
LangChain, CrewAI, AutoGen, and every system-prompt-heavy agent framework I have looked at carefully has one register for rules. System prompts and tool docstrings and retrieved instructions all flatten into one read surface, all interpreted by the model at inference time.
The result is exactly what you would expect. Every rule competes for the model's attention with every other rule. Compliance is probabilistic at best. Auditing requires inspecting model behavior across many runs and inferring whether rules were honored. The runtime is not the enforcement layer; it is the dispatch layer, and enforcement is something the prompt is hoped to provide.
Substrate inverts this. Rules that can be compiled are compiled. The runtime is the enforcement layer for those rules, and structural impossibility replaces probabilistic compliance. Rules that need judgment stay where judgment lives, and the agent applies them with the context-awareness they require. The two registers do not overlap because they cannot; what each enforces is structurally different.
The downstream properties follow:
Audit-by-construction becomes enforceable. Every action passes through the dispatch surface, which is also the audit surface. Compiled rules are checked at the boundary; the boundary records what happened. There is no place for an action to exist that the audit log does not see.
Consistency-across-agents becomes a runtime property. Agent 99 reaches the same conclusion as agent 1 given the same inputs, because the rules constraining them are compiled and structurally identical. The model is the executor; the substrate is the enforcer.
Doctrine evolution becomes safe. When the friction-aggregator surfaces a candidate amendment, the substrate can route it to the appropriate register. Compiled doctrine evolutions are testable in isolation before they ship. Interpretive doctrine evolutions are reviewed for judgment-clarity. Both can mutate the contract that subsequent dispatches read, in their respective registers, without crossing the streams.
None of these are aspirational. They follow from the bifurcation, mechanically.
The compiler exists today. The editor is what's coming.
The runtime has been enforcing compiled doctrine for as long as it has existed. Role-scoped permissions, pre-run checks, fixed-order chain advancement, parent-link lineage, cancellation cascades. The compilation has been implicit, encoded in role rule-sets the runtime reads when an agent starts. What's coming next is the operator-facing surface for that compiler. The image of a rule being authored visually with tests passing and traces firing is the runtime's own machinery, surfaced.
The bifurcation is not theoretical. It is what doctrine is, in a runtime that takes the difference between enforcement and judgment seriously. Two registers, two artifacts, two enforcement layers. A rule belongs to whichever register can express it without losing fidelity. Mistaking the registers is itself a doctrine bug. The visual editor and the written doctrine document are two artifacts because doctrine is two things.