Essay 6.3 — The Markov Phasic Brain, Part 3 of 10.

Essay 6.2 drew the full transition graph and named the tool-restriction discipline that makes each phase distinct. Every job the seed agent runs threads through that graph in cycles — OBSERVE → PLAN → EXECUTE → VERIFY → CONDENSE → back to idle, repeating until the work is done. This sub-essay opens the first phase in that loop: OBSERVE.

OBSERVE is the read-and-orient phase. Before the cycle plans, builds, or verifies anything, OBSERVE gathers the context the rest of the cycle will work from. The cognitive failure it prevents is the assumption-driven plan — an agent that builds a model of the situation from the user’s prompt and its own training, never reads what is actually in front of it, and ships work calibrated to a world that doesn’t exist. OBSERVE is the prototype’s structural answer: a phase whose only job is reading the source materials of the work, so PLAN has something real to plan against.

The sources are wide, and they shift by domain. The prototype seed agent happens to work on a codebase, so its OBSERVE reads source files; a legal-research seed would read case documents and statutes; a finance-analysis seed would read filings and time series; a real-estate seed would read inspection reports and zoning records. Across all of them, OBSERVE also walks the seed’s own .claude/knowledge/ directory to recall what previous cycles established, re-reads the working CLAUDE.md files to inherit decisions from earlier phases, asks the user through registered question prefixes when a routing decision needs the architect, and fetches external references when the project itself does not carry the answer. Most of the reading happens through subagents — the main session orchestrates two to four research subagents in parallel rather than walking the corpus by hand.

The write side is broader than a strict between-section lockout, and the breadth is deliberate. OBSERVE writes only into CLAUDE.md files — project files stay read-only to the phase — and within those files the section enforcement is anchored to the OBSERVE marker ---Ob---: edits must land strictly below it. Because the four phase markers are ordered ---Ob--- → ---Pl--- → ---Ex--- → ---Ve--- in every CLAUDE.md, this rule cascades downward. OBSERVE can write into its own section, into the PLAN section, into the EXECUTE section, and into the VERIFY section. Voice and point coaching prioritize the OBSERVE section as the primary landing strip, but the wider authority is intentional — OBSERVE is encouraged to forward-stage downstream work, writing the verify checklist beneath ---Ve--- while observations are fresh, writing the plan context beneath ---Pl--- so PLAN inherits the agent’s thinking. The compartmentalization is structural where it needs to be (above ---Ob--- is protected); above the structural floor, it is soft. ⓘ

The phase’s pacing comes from a structured control surface, and the first piece exists to prevent a specific failure: silently skipping the depth-commitment choice. The multiplier sentinel locks every tool at phase entry until the agent picks a number between 0.5 and 3.0 — a forecast of how much work this phase will do. Before the sentinel existed, the multiplier silently defaulted to 1, and the agent routinely never made the depth choice at all. The lock is the structural answer to that drift.

The math runs backward to intuition. A small multiplier means each action awards fewer points, so the agent needs more actions to fill the same 100-point phase budget. A smaller number declares a deeper phase — more reads, more grep sweeps, more synthesis paragraphs before the gate opens. A larger number declares a rapid surface pass — fewer actions, faster cadence. The full Tier-3 framing of why this direction is the honest one returns in Essay 6.8.

Around the sentinel sit a pair of point gates that shape the read/write rhythm. A minimum-synthesis gate demands some reading before any CLAUDE.md write lands. A maximum-accumulation gate blocks further reading once the agent has read for a while without synthesizing. The arithmetic is invisible during work — the agent never sees its point count, only the block message when a gate fires. This is anti-gamification by design: a visible score gets optimized; an invisible one keeps focus on the investigation itself.

Around the gates runs a small direct-action budget. Every observe-subagent dispatch grants +3 read-budget; every direct project-file read by the main session consumes 1. The arithmetic is small but the bias is structural — the 80/20 split (twenty percent main-session orchestration, eighty percent delegated investigation) is mechanized in the gate itself, not just coached.

Every threshold in this surface — the synthesis floor, the accumulation ceiling, the transition gate, the budget total, the subagent grant — lives in the phase plugin’s config.conf file with a per-number purpose comment and a tunable range. The control surface is intentionally exposed. A domain that needs deeper observation per cycle would raise the accumulation ceiling and the phase-transition gate; a domain that runs many short cycles would lower both. The architect tunes the numbers; the discipline holds. ⓘ

The rest of this essay opens those mechanisms one at a time — the three internal gates that shape the phase from inside, a worked example end-to-end, the backward edges OBSERVE re-enters on, and the customization surfaces an architect tunes when adapting OBSERVE to a different kind of work.

Entry, classification, and write authority

OBSERVE is the entry phase. Every job starts here — the FORWARD_MAP permits only one transition out of idle, and it goes to OBSERVE. There are no exceptions and no skip paths; the seed agent’s design is consistent on this point. OBSERVE is also the phase that gets re-entered after a verification failure, when the agent has discovered the plan was wrong and needs to re-gather context. ⓘ

OBSERVE’s stated objective is to populate the working memory — the relevant CLAUDE.md files — with enough context that PLAN can produce a real plan. Each CLAUDE.md the agent updates declares that directory as editable later in EXECUTE; the choice of which CLAUDE.md to update is the choice of where the work will land. ⓘ

OBSERVE cycle 1 carries one decision that shapes everything downstream: which form the job takes. The agent classifies into one of three — a single-cycle deep job that runs freestyle and dissolves with its cycle, a multi-cycle job with an .md plan that refines across cycles, or a multi-cycle job that has already earned a parseable .yaml plan injected at every phase entry. The third form evolves out of the second through an approval gate; it is not chosen up front. PLAN inherits the classification and names the plan_file accordingly — false for single-cycle, a path for multi-cycle — but the framing happens here, in OBSERVE, before the first acceptance criterion is written. ⓘ

The footer-only write rule is enforced at the staging gate. The phase’s commit script stages only CLAUDE.md files; anything else surfaces as an anomaly. The restriction is what forces observation to actually happen — there is no escape into action. ⓘ

And the multiplier sentinel — the per-phase tool-lock that opens only when the agent forecasts the cycle’s scope — sits at the very front of every phase entry. The same sentinel pattern repeats in PLAN, EXECUTE, VERIFY, and CONDENSE. ⓘ

Image pending — OBSERVE’s three internal locks that shape the phase from the inside
Prompt: ASSET: images/observe-three-gates-b6-3.png Style: Match `opevc-cycle-blackboard.png` exactly. Dark slate chalkboard; hand-drawn chalk lines; pastel chalk (cyan, green, orange, pink, magenta — same palette as the cycle image) for the gate boxes; white chalk for labels and arrows; chalk sticks at the bottom edge; faint chalk dust at the edges. IMPORTANT: Use only the literal names listed below. Do not invent or substitute any other names, labels, or gate descriptors. Layout: A horizontal flow across the board, left to right, showing the OBSERVE phase as a chalk-drawn corridor with three sequential gates. Gate 1 (cyan box, leftmost, at the phase entry): labeled "multiplier sentinel" with a small "0" inside a chalk circle above it, and a white chalk note "all tools locked" beneath. Gate 2 (green box, middle-left): labeled "min synthesis" with a white chalk note "read before write" beneath. Gate 3 (orange box, middle-right): labeled "max accumulation" with a white chalk note "synthesize before reading more" beneath. Between Gate 1 and Gate 2, a chalk arrow with a small pink label "set 0.5 to 3" above it. Between Gate 2 and Gate 3, a curved chalk loop arrow looping back on itself, labeled "read / write rhythm" in white chalk. To the right of Gate 3, a final white chalk arrow exits the corridor, labeled "commit" pointing to a small magenta circle labeled "plan". Keep every line hand-drawn and slightly imperfect, never ruler-straight. STRICT NAME WHITELIST — the image must contain only these literal text strings as labels: "multiplier sentinel", "0", "all tools locked", "min synthesis", "read before write", "max accumulation", "synthesize before reading more", "set 0.5 to 3", "read / write rhythm", "commit", "plan", plus the caption below. No other words, file names, folders, or gate descriptors may appear.
Image 6.3. OBSERVE’s three gates — the sentinel locks entry, the paired gates shape the rhythm.

A pair of intermediate gates shape the rhythm of the phase from inside. A minimum-synthesis gate makes the agent read enough before any write into CLAUDE.md is allowed. A maximum-accumulation gate blocks further reading once the agent has read for a while without synthesizing. The arithmetic underneath is hidden from the agent; only the block messages surface, and only when a gate fires. ⓘ

OBSERVE also dispatches its share of subagents. A typical phase fans out two to four research subagents in parallel — the main session orchestrates, the subagents investigate. The 80/20 split is the subject of Essay 7. ⓘ

When OBSERVE believes it has enough, it commits. The commit is the phase’s exit ritual. After the commit, the orchestrator advances the job to PLAN. There is no skipping back through OBSERVE without rolling the job backward — and rolling backward is allowed, but it is explicit, not silent. ⓘ

The friction it enforces

The tool restrictions in OBSERVE are not a polite suggestion. A guard hook intercepts every tool call and rejects the ones outside the phase’s allowlist. ⓘ

Read passes for project files, but only when the direct-action budget allows it. Every project-file read outside .claude/ consumes a point from a small pool; the pool is empty by default and refills only when the main session dispatches an observe subagent. The architecture builds the 80/20 split into the gate itself — the main session that tries to read everything by hand hits the budget floor and is forced to delegate. ⓘ

The same direct-action budget machinery is wired into every other phase too. PLAN, EXECUTE, VERIFY, and CONDENSE each carry their own +3-grant / -1-consume arithmetic, calibrated to that phase’s own subagent roster (PLAN dispatches plan- analyzers, EXECUTE dispatches execute- workers, VERIFY dispatches verify- auditors, CONDENSE dispatches condense- extractors). The 80/20 enforcement is universal across the cycle; OBSERVE is shown here because it is where the main session usually first hits the gate, but the same shape repeats four more times. ⓘ

Write is more interesting than a strict between-section lockout. The only file the agent edits in OBSERVE is a CLAUDE.md — project files stay read-only to the phase — and within that file the section enforcement is anchored to the OBSERVE marker ---Ob---: edits must land strictly below it. Because the four markers are ordered Ob → Pl → Ex → Ve in every CLAUDE.md, this rule cascades downward. OBSERVE can write into its own section, into PLAN’s, into EXECUTE’s, and into VERIFY’s. Above ---Ob--- is the structural floor — the brain-section content protected from observe-time edits.

Below the floor, the discipline is soft. Voice and point coaching prioritize OBSERVE’s own section as the primary landing strip; the wider authority lets the agent forward-stage downstream work — writing the verify checklist beneath ---Ve--- while observations are still fresh, writing the plan context beneath ---Pl--- so PLAN inherits the agent’s thinking, not just its raw observations.

The other phases' write authority narrows as the cycle progresses. PLAN writes below ---Pl--- (Pl + Ex + Ve sections). EXECUTE below ---Ex--- (Ex + Ve). VERIFY only into ---Ve---. To argue with observations or plan decisions from a later phase, the agent backward-transitions to the upstream phase per the BACKWARD_MAP — verify-commit.sh --backward, execute-commit.sh --backward — and then operates under that phase’s wider authority. Cross-phase argument is a backward-transition, not a direct cross-section write. ⓘ

Questions are the third surface. When OBSERVE genuinely needs the architect, the agent uses a registered prefix — [WAITING] for generic clarification, [POINT-BOOST] when the budget gate has tightened past useful work. A bare clarifying question with no prefix is rejected by the question-discipline gate before the architect ever sees it. ⓘ

A worked example

Picture a multi-cycle plan-job on its third cycle. The .md plan has been approved; a .yaml was authored on cycle 2; the orchestrator injects the .yaml’s current objective into OBSERVE at phase entry. The agent enters OBSERVE — the multiplier sentinel is unset, every tool is locked. The agent reads the injected objective, forecasts the scope of this cycle’s observation work, picks 1.5 on the multiplier. The lock lifts. ⓘ

The agent reads the injected .yaml back, reads the working CLAUDE.md for cycle 2's execution notes, walks .claude/knowledge/ for prior lessons. It dispatches two observe-* subagents in parallel — one to map the target repo’s current state, one to look for contradictions between the .yaml objective and what cycle 2 actually shipped. Each dispatch grants +3 to the direct-action budget, so the main session keeps headroom for its own targeted reads. ⓘ

A contradiction surfaces — the .yaml describes a marker schema that no longer matches cycle 2's code. The agent does not silently choose; it asks the architect via [WAITING] for a routing decision. The architect answers. The agent writes a synthesis paragraph into the working CLAUDE.md — below ---Ob---, never above it — and commits. PLAN inherits. ⓘ

Backward edges

OBSERVE is the phase agents re-enter when things go wrong. A failed VERIFY routes back here. So does an EXECUTE that runs into a path the plan didn’t list. Re-entry is allowed; what is not allowed is silent re-entry — every backward edge commits an explicit "backward to OBSERVE" record so the cycle history reads honestly. ⓘ

OBSERVE itself only routes forward — to PLAN. The agent cannot self-advance to EXECUTE; the orchestrator hardcodes the next phase. That single rule preserves the OPEVC discipline against an agent that "knows what it wants to build" and would otherwise skip the plan-authoring step. ⓘ

What you would customize

OBSERVE is the most customization-friendly phase in the architecture, because what counts as "enough context" is exactly where your seed differs from the next architect’s.

The architect would tune the subagent roster. The prototype’s observe subagents (currently a dozen — codebase explorers, contradiction finders, web researchers) are calibrated to the prototype’s own work. A legal-research seed would swap in case-law searchers; a finance-research seed would swap in filings parsers and time-series analysts. The roster is the surface; the entries are yours. ⓘ

The architect would tune the gate thresholds. The prototype sets a low synthesis floor and a higher accumulation ceiling, calibrated against the prototype’s tempo. Sharper jobs lower both; long structural sweeps raise both. ⓘ

The architect would tune the question registry. Your seed may need a [STAKEHOLDER-CHECK] prefix for a domain where decisions require named approval, or a [CITATION-NEEDED] prefix that routes through a different downstream handler. The registry is short by design — short enough that every prefix is meaningful — and extensible. ⓘ

What the architect would not customize is the read-before-write principle itself. The principle is the floor: an observation phase that lets the agent write before reading is not an observation phase.

The shape lifts cleanly off this prototype. A real-estate-agent seed working a buyer-side deal would swap the observe roster — in go a PDF parser for inspection reports, a scanner for comparable-sales filings, a zoning-records reader for the parcel — and would lower the synthesis floor and raise the accumulation ceiling, because each document arrives self-contained and the synthesis beats are shorter. The multiplier sentinel still locks every tool at phase entry until the agent forecasts the cycle’s scope. The paired gates still pace read against write. The direct-action budget still pushes investigation onto the agent’s own roster of subagents. The agent’s .claude/knowledge/ still carries the prior deals as the primary source the next observe begins from. ⓘ

The honest design-limit is the same one the cycle inherits everywhere: the multiplier sentinel and the paired gates are friction — voice injections, point counters, block messages — not mathematical enforcement of the right scope or the right depth. Gmode is the documented bypass when off-cycle reading is the right move; the discipline rests on the agent reading the injected voice and choosing to obey. ⓘ

The deepest payoff of OBSERVE is the cognitive failure mode it prevents: the assumption-driven plan. An agent that skips observation does not skip having a model of the world — it just relies on the model it already had, which was shaped by the prompt and the LLM’s prior, neither of which has read the actual project or the architect’s situation. The structural insistence on observation before action is the prototype’s answer to LLM-mediated assumption drift. The friction is the pedagogy. The phase is the compartment.

OBSERVE writes once, into the working memory, and hands the result forward. The next sub-essay opens PLAN — the phase that turns observations into a binding contract before any code is written.

Essay 6.3 — The Markov Phasic Brain, Part 3 of 10.

Previous: Essay 6.2 — The Discipline and the Map — the full transition graph and the tool-restriction pedagogy. Next: Essay 6.4 — PLAN — Decide, Then Lock — turning observation into a binding contract.