The Five Layers of Agentic Context: Why Canon Only Turns When Someone Signs Off

Every engineering team shipping AI agents into production eventually hits the exact same wall: the model can solve Olympiad-level math in milliseconds, yet it still tells a customer on live chat that your return policy is 90 days when you changed it last week, or approves an $800 refund without manager sign-off.

In The five layers of agentic context, Sanity co-founder and CEO Magnus Hillestad breaks down why the common advice to "just give the agent context" falls apart at scale. Building on Evan Armstrong's observation that value is shifting from systems of record (which store data) to context layers (which store meaning), Magnus makes a crucial architectural correction: context is not a singular thing.

Instead of dumping every Slack thread, ticket, database row, and policy doc into a single vector "company brain" (the 2026 equivalent of a 2016 data lake turning into a data swamp), production agents rely on five distinct layers of context: Situation, Records, Memory, Process, and Canon. Each layer turns at its own pace, has its own owner, and fails in its own unique way. And most importantly: Canon only turns when someone signs off.

Interactive demo: the Situation to Canon wheel

To bring the mechanical model from the Sanity article to life on CodingCat.dev, I built an interactive HTML and SVG version of the five-wheel apparatus below. Notice the pulsing signal on the right-hand lever: click the handle to start the machine and sign off a Canon revision, or click any of the five layer plates along the linear track to move the read-head carriage and inspect that layer's telemetry.

Breaking down the five layers of agentic context

Why does the wheel metaphor work so well for engineering teams? Because in a real production stack, context does not mutate at a uniform clock speed. Treating live conversational state the same way you treat approved pricing or refund policies guarantees hallucinations and compliance failures. Here is how the five layers compare across velocity, ownership, and failure modes:

Why "company brains" turn into data swamps for customer-facing agents

One of the sharpest insights in Magnus's piece is his comparison between today's all-in-one "company brain" vector stores and the data lakes of a decade ago. Internally, pointing an enterprise search bot at Slack, Notion, and Jira works fine because employees have enough institutional awareness to spot an outdated thread from 2024.

Customer-facing agents do not have that luxury. When your pricing page says $49, an old blog post says $39, and a sales battle card in Google Drive says something else, an agent reading your raw web pages burns extra tokens trying to reconcile contradictions, or worse, quotes the wrong price to a buyer. Moving from unstructured "pages" to a structured content model gives both humans and agents a single source of truth.

The overhead bridge: how Memory and Records promote into Canon

Look closely at the top of the mechanical wheel apparatus above: an overhead bridge arm connects the Memory drum (Wheel 3) directly to the orange Canon drum (Wheel 5). That mechanical link represents the most important operational loop in agentic engineering:

• Signals flow in from Records and Memory: Sales call transcripts, support tickets, and agent memory surface recurring customer corrections or product changes.
• Content teams act as Context teams: Instead of letting unreviewed agent memory drift into production policy, humans review candidate updates, resolve contradictions across sources, and sign off via Sanity Workflows.
• Compiled Canon ships over MCP: At Everything *[NYC] 2026, Matt Chamberlain from Braze demonstrated this exact loop by compiling Braze's public documentation into a Sanity Knowledge Base served over an MCP endpoint, watching sales calls for market changes, and routing proposed battle-card updates to humans for sign-off.

Why precompiled Canon makes fast, cheap models viable in production

If an agent has to grep raw documents and synthesize what your business stands for from scratch on every prompt, you are forced to pay for slow, frontier-class reasoning models on every turn. When Sanity Context precompiles Canon into a structured Knowledge Base exposed over MCP, the map of verified facts and relationships is already drawn. A smaller, faster, cheaper model can answer with low latency, and a lightweight classifier can verify every outgoing response against Canon before the customer ever sees it.

How the interactive HTML/SVG wheel is built

If you want to embed the Situation-to-Canon wheel in your own docs or architecture decks, the entire component uses zero external dependencies: just inline SVG geometry projected along a 19.075-degree isometric axle and a 60fps requestAnimationFrame loop. Each drum projects 18 radial ribs across the visible front-left half of a tilted ellipse, while the Canon drum remains locked until the handle click handler increments the target phase:

// Parametric isometric projection for each rotating context drum
const AXIS_ANGLE_DEG = 19.075;
const RAD = (AXIS_ANGLE_DEG * Math.PI) / 180;
const UX = Math.cos(RAD), UY = Math.sin(RAD);
const VX = Math.sin(RAD), VY = -Math.cos(RAD);

function ellipsePoint(cx, cy, rMaj, rMin, theta) {
  return {
    x: cx + rMaj * Math.cos(theta) * VX - rMin * Math.sin(theta) * UX,
    y: cy + rMaj * Math.cos(theta) * VY - rMin * Math.sin(theta) * UY,
  };
}

// Handle click signal: ratchets Canon forward by one approved step
function onHandleClick() {
  machineRunning = true;
  canonSignOffCount += 1;
  canonTargetPhase += (2 * Math.PI) / 9; // +40 deg ratchet step
  triggerOverheadBridgePulse();          // Plungers stamp Memory -> Canon
}

The bottom line for AI engineers

Magnus closes the article with a rule of thumb that belongs on every AI engineer's desk: the more autonomy you give an agent, the more of its context needs to be canon. Read the full post on the Sanity blog, try pulling the sign-off handle on the wheel above, and let us know on CodingCat.dev how you are governing canonical context in your own agent loops!