architecture · 02

Two layers: judgment and enforcement

A Markdown skill makes the judgment calls; a Rust binary enforces the invariants. Neither reaches into the other.

maps to as-built §2§3

the split · one side you edit, one side you can't
A skill you can edit; compiled code you can't deadreckon is split into two halves that never mix. On the left is judgment, a skill: a plain-text Markdown file at skills/<name>/SKILL.md that you can edit, holding what to ask the model, which tools to prefer, and when to declare the work done. On the right is enforcement, the compiled Rust binary at crates/deadreckon*, which owns the locks, atomic state writes, the signed acceptance gate, and the sandbox. The skill can change how a run is attempted but can never change the rules. Below, the binary itself is layered: a thin CLI on top, a runtime that runs the loop in the middle, and a core of durable building blocks at the base. JUDGMENT · YOU EDIT THIS a Markdown skill skills/<name>/SKILL.md · plain text what to ask the model which tool to prefer when to declare done ENFORCEMENT · COMPILED, FIXED the Rust binary crates/deadreckon* · compiled code locks · atomic state writes the signed acceptance gate the platform-native sandbox neither side reaches into the other inside the binary: thin on top, durable at the base CLI: read your command, set up the run (thin) RUNTIME: run the turn loop, the sandbox, the gate CORE: durable state, locks, gate, promotion (the rules)
Each side does what it is good at. The editable skill makes the judgment calls; the compiled code makes the guarantees. Neither can quietly become the other.

deadreckon is split into two halves that are kept strictly apart. One half is judgment: the soft, changeable decisions about how to get good work out of a model. The other half is enforcement: the hard guarantees that must never bend, like "a run cannot be marked done without a valid signature."

Judgment lives in a skill. A skill is just a Markdown file (skills/<name>/SKILL.md) written in plain English. Think of it as the agent's playbook: it says what to ask the model for, which tools to prefer, and when to call the work finished. Because it is only text, you can open it in any editor, change how the agent behaves, and rerun, with nothing to recompile.

How a text file steers a run

The trick is simple. On every turn, deadreckon reads your skill straight off disk and pastes it into the prompt it sends the model, right beside your goal and a summary of the run so far. The skill is not configuration the binary interprets; it is text the model reads.

what the model receives each turn
introYou are deadreckon, running unattended coding work.
specyour goal, plus the acceptance checks
skillyour entire SKILL.md, pasted in verbatim
historywhat happened on previous turns
the model replies with one action: bash, write_file, or done

That makes the skill influence, not control. It can tell the model to prefer one tool, keep turns small, or document its decisions, and a capable model will follow it. What it cannot do is widen the sandbox, skip a lock, or sign its own gate, because none of that code reads the skill. The boundaries live in the binary and hold no matter what the skill says.

Enforcement lives in the Rust binary, the compiled program. It owns the locks, the atomic writes, the signed gate, and the sandbox: the things that have to be correct every single time. Inside, it is layered: a thin command-line layer on top, a runtime that drives the loop in the middle, and a core of durable building blocks at the base.

Why the wall matters. Editing the skill can change how a run is attempted, but it can never change what counts as "done." That rule lives on the other side of the wall, in compiled code the agent cannot edit.

source