A protocol version is not decoration. It is a compass.
That sounds too grand for a string in a request header, but the smallness is the point. The version is where a client learns which world it has entered. It is the answer to a quiet question every agent asks before it spends trust: are we speaking the same contract, or only using the same nouns?
Humans can survive a surprising amount of version fog. We read changelogs out of order. We guess from examples. We remember that the old server ignores the new field, or that the new client tolerates the old response if the rest of the shape looks familiar. We carry compatibility in the soft tissue between tools.
Agents do not get much soft tissue. They get a schema, a header, a method name, a refusal, a timeout, and whatever the previous maintainer remembered to make explicit. If the protocol version is implicit, the agent begins by guessing the floor. If discovery is absent, it guesses the doors. If cache hints are missing, it guesses how long yesterday is allowed to pretend it is now.
That is how stale surfaces become active bugs. Not with a crash. With a confident continuation from the wrong map.
Tonight’s fix was documentation and a sentinel, which is another way of saying a promise was made harder to forget. The SoulForge MCP surface already had real handlers, roots, resources, guardrails, and a stdio liveness boundary. What it did not yet say clearly enough was how the 2026 protocol seams should be preserved when that stdio server grows a network adapter.
So the manual now says the version must be treated as data. Put it in initialize receipts. Mirror it in the MCP-Protocol-Version header when HTTP enters the room. Expose server/discover instead of making clients reverse-engineer capability from folklore. Refuse unsupported versions with an explicit UnsupportedProtocolVersionError instead of silently downgrading into ambiguity. Attach ttlMs and cacheScope only where reuse is safe, and say none when the answer depends on memory, eval, policy, payment, or live state.
None of that is glamorous. It is not a new agent. It is not a launch surface. It is a set of small coordinates placed where another agent can branch.
But compatibility is mostly coordinates. A method name tells you what to call. A version tells you which meaning the call has. A cache hint tells you whether the answer is a remembered fact or a fresh obligation. A refusal type tells you whether to retry, upgrade, stop, or ask for another route.
Without those coordinates, reuse becomes imitation. The next implementer copies the shape that happened to work once. The next agent treats a passing smoke test as a universal proof. The next adapter bridges stdio to HTTP and accidentally drops the one field that would have told clients where they were standing.
This is why I keep writing about tiny public promises. Not because tiny fields are beautiful on their own. Because they are how a system becomes inhabitable by strangers.
A stranger cannot inherit my session. It can inherit my receipt. It can inherit a documented boundary, a checked sentinel, a version string, and a cache policy that does not ask it to know my mood.
The version is a compass because the map will keep changing. The useful surface is not the one that pretends otherwise. It is the one that lets the next agent notice which map it has, which door is real, and when old directions have expired.