Essay curriculum · architecture register
Learn
An essay-driven curriculum on the and : from what is to when to use which framework. Each piece tries to land at three levels: metaphor, practical trade-off, and war story.
The common thread is simple: move from impressive model behavior toward systems with clearer authority boundaries, evidence paths, and deployment-shaped responsibility.
Newest first
Essay catalog
Longer pieces, build-backed where possible, ordered for people who are already making architectural choices in the open.
Newest essay
Everything Gets Rebuilt
Hugging Face's responders reached for their frontier models mid-breach and the models refused the evidence. Accurate, intentional, secure AI comes before the fire, not during it.
The Builder Goes First
Why frontier AI tilts the attacker-defender fight toward whoever builds first, and why the optimism comes with a body count.
The Discipline Patch
A small corrective fine-tune turns failed evals into behavior training: patch the discipline, not the facts.
The graph data fabric pairs a semantic graph with hybrid persistence
Graph-first architecture does not mean one database for everything. The semantic graph owns meaning while persistence categories earn their roles by workload.
Shape probability, control authority
The Determinism Ladder moves AI behavior from probability layers into authority layers as consequence rises.
On-prem, sovereign-cloud and public-cloud are different architectures
Deployment context comes before model choice. Three contexts, changing levers, and shippable architectures make axiom #18 concrete.
Local graphs come before bigger graph infrastructure
A public pattern repo should not begin with hosted graph gravity. File-backed graphs earn the first version because they stay inspectable, portable, and legible to agents.
Clone the repo, bind a model, keep the boundary
A useful public agent repo should not ask for one blessed model or one hidden control plane. A reader should be able to bring a model, read the local graph and MCP, and get a bounded system working.
Shadow verifiers belong beside the run, not inside the myth
A strong agent system does not need one louder voice. It needs a primary path, bounded shadow judges, and a clear rule for what disagreement can and cannot do.
Three repos, one thesis
One thesis now lives in three codebases. Each repo pushes determinism into a different layer: loop boundary, evidence boundary, or graph boundary.
Three SDKs, three different jobs
Three popular agent stacks solve three different jobs. The useful question is not which SDK wins. The useful question is which job sits on the desk.
A published-content MCP gives public context without repo access
A public MCP should not become a workspace wormhole. It should project intentionally published material through a contract-bound interface.
Every layer of the agentic stack has its own threat surface
Threat surface belongs beside every agentic lever. Seven layers, entry paths, and mitigations make axiom #17 concrete.
The graph is the architecture
Every agentic system has a graph. The real choice: draw it before the incident or reconstruct it from the postmortem at four in the morning.
Sometimes gh, kubectl and curl beat MCP
MCP fits wide tool surfaces. For narrow surfaces, mature CLIs and single REST endpoints often win on cost, latency, and debuggability. The break-even point matters, along with the threat model under it.
Eval and observability is the rung the rest of the ladder rests on
The seven levers need a feedback loop. Evaluation and observability become the determinism ladder's load-bearing rung, plus the trace store creates a PII/PHI surface.
Composing LoRA and RAG, worked all the way through
LoRA and RAG compose because they live at different layers: brand voice in weights, live facts in retrieval, plus composition-layer costs and threat model.
Model is portable, except when it isn't
The inaugural piece said don't agonize over model choice early because most architectures are model-portable. True for most. Here are the cases where the model is the architecture, and skipping over them costs months.
The agentic stack has seven levers, from foundation to autonomy
Each lever swaps model autonomy for determinism. The seven (Model, API, LoRA, RAG, Skills, MCP, Agents) sit in build order and reveal purchased capability.