Semantic anchors for agents

Agents don’t read intentions — they read anchors: the stable, parseable, verifiable artifacts that carry the meaning an agent needs to act (and to be held accountable for acting). A semantic anchor is any artifact where meaning is encoded in the artifact’s shape rather than in prose interpretation: a contract, schema, spec, manifest, instruction file, grammar, test, or structured output format. The claim this note tracks: an agent’s competence ceiling is the quality of the anchors it’s given — the same model with a FEATURES.md contract and without it is two different agents.

The anchor taxonomy (all observed in captured sources)

1. Instruction files — AGENTS.md / CLAUDE.md / system instructions: the cheapest anchor. Field evidence: chimolog7’s Strata tips (“if your goal is task completion, write an AGENTS.md” — the difference between “it won’t work” and works); Cranmer’s “system instructions let you define what good work is.” Ghuntley’s counterweight (“agency, not AGENTS.md”) is about anchor insufficiency, not anchor rejection — instructions anchor behavior, not judgment.
2. Skills (two-tier) — the Agent skills load model is an anchor discipline: name+description (discovery), SKILL.md workflow + request→tool map (activation), references/ + scripts (execution). ffmpeg-skill’s pinned report format makes output shape part of the anchor; Deep Agents’ binding/pinning/reloading adds runtime semantics.
3. Contracts & schemas — the strongest anchor class: ffmpeg-skill’s machine-readable contract (frameworks that speak neither skills nor MCP can still consume it); shield_optimizer’s docs/FEATURES.md as the canonical spec both implementations build against, updated in the same commit as the feature (spec drift prevented by process, not hope); MangaDex’s JSON Schema validation on path/query/body (the anchor enforced at the boundary — invalid meaning never enters); readeck’s in-tree OpenAPI spec (the substrate that made its agent surface a thin wrapper).
4. Manifests & provenance — the capture pipeline’s manifest.json (sha256 of every note body; verify = 0 problems); the Clef dedup’s AI-Gateway logs + pipeline-results.json (“any mistake is traceable to the exact images and probabilities”); provenance anchors make agent work auditable after the fact.
5. Grammars / syntax — Pele’s design rule, “follows its syntax, not its layout”: the Mermaid grammar is the stable semantic layer while three layout engines churned underneath. A grammar is an anchor that survives implementation swaps — the same reason Clean/Lean proofs outrank prose math for verifiability (Cranmer: “run Lean on the proof, therefore it’s right”).
6. Deterministic outputs — Cranmer’s plots-over-essays (“pretend you’re my student bringing a plot to a meeting”), structured redline batches, exit codes, typed decision outputs (Decision models’ probability-per-option with no generated tokens). Structured output is the return-path anchor: how the agent proves it understood.
7. Tests & consensus gates — the deterministic-gates doctrine: tests as the verifiable anchor for “done” (Capy’s smarter diffs; Clef’s unanimous-only apply; the vault’s own no-tautological-tests rule).

Properties of a good anchor

• Machine-parseable — schema’d or grammar’d, not vibes (“42 tools with a machine-readable contract”)
• Verifiable — checksum, validator, test, replay; disagreement is detectable (Clef’s ensemble disagreement = calibration audit)
• Single-source — one canonical spec, dual implementations reference it (shield_optimizer); two sources of truth means no source of truth
• Process-locked — changes ride the same commit/PR as the behavior (spec completion gate; FEATURES.md rule); anchor rot happens when updates are “later”
• Progressively disclosed — cheap discovery, deep detail on demand (skills’ three levels; MCP core-12/full-42)
• Enforced at the boundary where possible — validate at entry (JSON Schema), hash at rest (manifest), consensus before effect (unanimous-apply)

The failure mode is anchor rot: prose that drifted from behavior, docs updated “later,” unversioned API surfaces (Mermaid’s three layout engines = layout rot while syntax held), context-window folklore passed chat-to-chat. An anchor that can’t be verified is a rumor.

Why this matters now

The CLIs for agents lane says: give agents a callable surface. This note is the complement: the surface is worthless without anchors that make it legible. The 2026 products shipping “agent skills” (karakeep’s “OpenClaw, Hermes friendly,” Estuary’s Claude Code plugin, Traceway’s read-only error skills) are all, structurally, anchor shipments — a CLI plus a contract plus a scoped capability declaration. And the Agent knowledge systems thesis (“the truth of the company has to sit somewhere they can read”) generalizes it: organizational knowledge becomes agent-usable exactly to the degree it’s anchored — spec’d, hashed, schematized, tested — rather than narrated.

Practical audit for any agent-facing system (the vault’s own checklist):

1. What does the agent read first? (discovery anchor)
2. What proves it understood? (output anchor)
3. What catches it being wrong? (verification anchor)
4. Where is the drift between anchor and reality? (rot check)

Kin

• CLIs for agents — the callable-surface lane; anchors make surfaces legible
• Agent skills — the two-tier anchor discipline at ecosystem scale
• Agent knowledge systems — org knowledge as anchors (spec’d/hashed/tested) vs narration
• Decision models — typed questions + probabilities as judgment anchors
• Agent tests / deterministic-gates doctrine — verification anchors
• shield_optimizer’s FEATURES.md, ffmpeg-skill’s contract, MangaDex’s JSON Schema, readeck’s OpenAPI — the specimen shelf