Articles
Long-form thinking on semantic intent, AI-assisted development, and the patterns that preserve what code means.
Before the Agent Runs
AI-first delivery is fast. Dangerously fast. The instinct is to add governance after the artifacts exist — as review, as audit, as remediation. Governance-Driven Design proposes the opposite: formalize intent before the machine runs. A pre-execution discipline that completes what TDD, BDD, and DDD started — moving the definition of correctness upstream to the governance layer.
The Harness Was Already the Methodology
Google's new SDLC playbook names the discipline: an agent is a model plus a harness — roughly ten percent model, ninety percent harness, gated on evals rather than demos. But the ninety percent is not scaffolding around intelligence. It is methodology made executable — where intent, verification, and human judgment are encoded. The name arrived this spring. The harness has been running in production for twelve months.
The Query Carries the Architecture
We focus on keeping log files local. The question you ask about those logs carries the same information — endpoint names, failure modes, stack details, incident timelines. When you send a diagnostic query to a cloud API, you send a compressed map of your production system.
The Name Is the First Spec
Natural metaphors are not branding. They are cognitive infrastructure — pre-built conceptual structures that transfer an entire set of properties, relationships, and behavioral constraints from the natural world into a technical one, arriving warm in both human and AI reasoning simultaneously. Why the cormorant, the phoenix, the ember, the reef, the octopus, and the crocodile are not decoration.
The Habitat Inverts the Stack
Every automation tool shares a hidden assumption: you are the processor. REEF declares the opposite. The habitat tends to itself — declared once, running continuously, surfacing only what earns your attention. The personal machine stops being a workbench and becomes a headquarters.
The Synthesis Gate: What Makes a Workflow Agentic
Most definitions of agentic AI focus on the tooling — which framework, which model, how many agents. The question is architectural and precise. A workflow becomes agentic at the moment ambiguity enters and interpreted meaning comes out. One synthesis node is sufficient. Everything else can be pipes.
When Intent Becomes Infrastructure
Methodology-as-Infrastructure proved that analytical reasoning can be compiled into deterministic runtimes. Intent-as-Infrastructure is what happens when the compiler itself is intelligent: bounded vocabulary encodes the what, an AI model generates the how, sovereign artifacts record the result, and human judgment enters at the moment it belongs — not routed around, but designed in.
The Compiler Is Claude
REACH is a DSL for local workflow automation — declare the source, the timeframe, the analysis intent. OCTO is the orchestration layer built on REACH arms. In both cases, the vocabulary is bounded, the artifact is sovereign, and the compiler is Claude. This is what Intent-as-Infrastructure looks like in practice.
One Grammar, Two Readers
The same Semantic Intent block can be read two ways. A deterministic parser turns it into tool configuration — that is ChirpIQX. A language model executes it as a runtime directive without being told to — that is cal_verify_case. Same grammar, two consumers. The second is the "emitted directive" of Paper 3, and seeing them side by side answers whether any of this is more than prompt engineering.
Three Papers That Needed Each Other
Three papers published the same week — not planned as a trilogy. Each one starts where the previous one stops. The governance primitive defines what agents carry. Agentic Traffic Control defines how agents move. GESA defines how the system learns. None is complete without the other two.
The Pipeline That Was Already a Traffic System
An 11-model AI orchestration pipeline built five things: a signal layer, lane separation, junction protocol, priority routing, and an audit trail. None were designed as a traffic system. Each was built to solve an immediate problem. Looking at what had been built, the pattern was already there. The name was not.
The Page That Proves Itself
Every RECALL artifact embeds its own source. recall validate makes that embedding operational — extract the source, recompile it, compare the output. The philosophical conclusion of "source is the artifact": a page that can prove it was not changed after compilation.
The Bridge: When Rune's ? Becomes Wake's Memory
The ? rune was designed to carry intent that never gets stripped. Wake was designed to carry intent that survives between sessions. v3.5.0 connects them: ingest_rune_manifest turns every governance annotation in a Rune schema into a causal memory entry. The declaration and the memory are now the same artifact.
The Schema Is the Editorial Policy
When AI is generating the content side of a RECALL brief, PIC X field declarations stop being a formatting detail and become a quality contract. Four rendering problems, one root cause — and why every fix pointed back to the schema, never the renderer.
Two Gaps: What Rune and Wake Are Actually Solving
They feel like different projects — a reactive binding protocol and a temporal memory server. But Rune and Wake address the same underlying problem on two different axes. One bridges the synchrony gap: the space between human intent and what AI can structurally access right now. The other bridges the temporal gap: the space between a decision made and a decision remembered. Together they describe what semantic continuity means in practice.
Rune Protocol: Discovered, Not Designed
Mere had four sigils before they had a name. @ ~ ! ? — read, sync, act, intent — were working in a reactive document format before anyone asked what they were formally. The protocol wasn't invented. It was extracted. What it turned out to be: a bounded-complete reactive binding grammar, a governance layer, and the syntax substrate the whole ecosystem was already running on.
Wake Intelligence: The Fourth Question
The first three layers ask why, how, and what. Layer 4 turns the question inward: how well am I actually predicting? Per-project weight tuning, cross-project causality, and semantic search — what shipped in v3.3.0 and why the hardest part was keeping three numbers well-behaved.
Wake Intelligence: The Three Questions Most Context Stores Never Ask
Most MCP context servers answer one question: what did we save? Wake Intelligence answers three: why was it created, how relevant is it right now, and what will be needed next. A 3-layer temporal intelligence brain for AI agents, built on Cloudflare Workers.
When the Methodology Becomes the Infrastructure
Methodologies are traditionally documents — frameworks that describe how to think but leave execution to interpretation. Methodology-as-Infrastructure proposes something different: that a sufficiently rigorous methodology can be compiled into a deterministic runtime layer that other systems build upon.
Strata: The Database Layer Needs Its Own Pipeline
Phoenix extracts intent from application code and rebuilds from zero. The database layer — stored procedures, SQL Agent jobs, linked servers, a decade of accumulated logic — doesn't follow the same rules. Introducing Strata: the sibling methodology for database archaeology.
The Grammar Ships: .sil Syntax Highlighting for VS Code
Syntax highlighting for .sil files started as a GitHub issue. Someone from the VS Code extension community found it within 24 hours. What the grammar reveals is more than aesthetic — each colour layer maps to a distinct semantic layer of the EMBER format.
The Invoice Is an App
An invoice is three computations: Σ(price × quantity), a tax rate applied to the subtotal, and a sum. Mere builds one in under 90 lines of declarative HTML — reactive computed chain, two screens, no JavaScript. The document and the app were always the same thing.
Mere: The File Is the App
A workbook format where the file contains everything — screens, state, behavior, theme, data. Open it and it runs. Send it and it travels. No server, no account, no build step. And why that matters more than it sounds.
CAL: A DSL Where the Cascade Is the Program
SWOT gives you four boxes. Porter gives you five forces. CAL gives you syntax. An introduction to the Cascade Analysis Language — a DSL that traces how failure and success propagate across six organizational dimensions, scores the result, and produces a deterministic decision.
From Draft to Artifact: The First Thing You Build with RECALL
Most people who find RECALL want to publish one thing — a case study, a report, a structured brief. That instinct is correct, and it leads somewhere larger. Three use cases, one progression: publish one thing, make it a template, watch the audit trail appear.
Error Signal Fidelity: When the Compiler Speaks to the AI, Not the Human
Most compiler errors are written for human eyes — prose messages, implicit assumptions, single-shot reads. When AI is generating the source, the reader is a language model. RECALL's diagnostic output was designed for that reader: stable codes, structured JSON, per-code hints, and exact location — all the inputs a generation loop needs to close.
Machine Legibility Dimensions: A Framework for Notations Designed for AI Readers
The Cognitive Dimensions of Notations framework evaluates languages from a human reader's perspective. As AI systems become primary authors and readers of formal notation, a different set of questions applies. Nine dimensions — tokenisation alignment, ambiguity surface, schema availability, error signal fidelity — and why one honest Neutral matters more than nine Positives.
RECALL: The Source That Knows Who Wrote It
Git blame tells you which commit touched a line. RECALL v1.1 goes further — authorship is a compile-time constraint. CREATED-BY accepts exactly three values: Human, AI compositor, or AI agent. The source doesn't just remember what was written. It remembers who.
RECALL-JCL: The Contract at Every Boundary
Distributed systems are not hard because the transport is hard. They are hard because the contract between systems is invisible. RECALL-JCL makes the contract the program — declared before execution, validated at compile time, sealed permanently in every artifact the pipeline produces.
WITH INTENT: The Clause That Writes the Source
RECALL compiles WITH INTENT to a placeholder. The clause that compiled to nothing produces source that compiles to something real — structured, field-typed, verified by the same compiler that validates everything else.
RECALL: The Institutional Memory Problem
An AI model re-enters your pipeline fresh on every run. No persistent mental model. No accumulated context. The Pipeline Manifest is the architectural answer — one machine-readable read that encodes everything the pipeline needs.
RECALL: What COBOL's Failures Teach an AI-First Compiler
COBOL had four failure modes — all rooted in trusting programmers with what compilers should enforce. Applying those lessons to RECALL reveals why the discipline is the proof of AI-first design, not just the positioning.
RECALL: Live Schema, Strict Mode, and the Idea That Emerged
A live schema the compiler queries itself. Structured diagnostic codes. Intent as a field-level type. Three features that solved immediate problems — and quietly built the infrastructure for something larger.
RECALL: What COBOL Would Have Built for the Web
It started as an aesthetic impulse — what if someone opened View Source and saw COBOL? Three days later it's a working compiler, a self-hosted documentation site, and the beginning of a semantic layer for AI orchestration.
EMBER: A Language Designed for the Third Reader
XML was designed for machines. Markdown was designed for humans. EMBER was designed for AI agents — and that distinction changes everything about what a language needs to be.
Semantic Intent Drift: The AI Coding Bug Your Tests Can't Catch
Your AI-assisted codebase has a class of bugs that's invisible to traditional testing. The code compiles. The tests pass. The behavior is wrong.