CSE Roadmap

Common tier · about 6 hours · 14 parts

Part 6 of 14 · 4 min read

What the example found

Round-trip counts, the tamper table, the scaling comparison, address screening, capability gating, and the sampling controls.

How to read the round-trip table: each row is a different call against the expense tool, under the modern multi round-trip mechanism.

Call Requests Prompts Ledger entries
250 expense, person accepts 2 (ids 1, 2) 1 1
50 expense (under the confirmation threshold) 1 0 1
Person declines 2 1 0
Person dismisses (cancel) 2 1 0
Greedy server asking 50 rounds, client limit 3 4 (at most) up to 3 0, abandoned

What to notice: the 50 expense needing only 1 request and 0 prompts is not a special case; it's the same mechanism with nothing to ask. The request count is simply "1 plus 1 per round of questions," which is also what caps the greedy server at 4 requests once the client's own round limit kicks in.

How to read the tamper table: each row presents a different altered version of the same sealed requestState token to open_state.

Presented Result
untouched accepted
one character changed rejected: bad signature
price edited, old signature kept rejected: bad signature
by another user rejected: issued to a different principal
on a different request (quantity 2 became 20) rejected: belongs to a different request
after its lifetime rejected: expired
signed with another key rejected: bad signature
hello rejected: malformed state
presented twice, no server-side record accepted both times
presented twice, with a nonce record accepted once, rejected second time

What to notice: eight of the ten rows are about forgery and staleness, and sealing catches every one of them. The last two rows are the separate question of replay, which sealing alone does not answer; only a server-side nonce record does.

How to read the era-comparison table: each row is a different operational situation, run against identical tool code in both the earlier (server waits) and modern (state travels) eras.

Situation Earlier era (server waits) Modern (state travels)
Server threads parked while the person thinks 1 0
The answer reaches a different instance (round-robin balancer) timed out, 0 entries completed, 1 entry
The server instance dies while waiting call lost, 0 entries finished on a new instance with the same key, 1 entry
New instance has a different key n/a refused: bad signature

What to notice: the modern era's one new failure mode (a new instance with a different signing key) is the price of removing the other three. A server that shares its signing key across instances trades "lost calls on a crash" for "a slightly more careful key-distribution problem," which is a trade worth making at scale.

How to read the address-screening table: each row is a URL the example's inspect_url was asked to check before a client would show it to a person.

Address Verdict
https://mcp.example.com/connect?id=lnk1 fine
http://mcp.example.com/connect?id=1 blocked: plain http
https://[email protected]/connect blocked: user-name trick, real host is evil.example
https://xn--mcp-example-9ub.com/connect allowed with warnings: punycode, not the server's host
javascript:alert(1) blocked: scheme
https://other.example/login allowed with a warning: not the server's host
https://mcp.example.com/connect?token=abc123 allowed with a warning: a secret in the address

What to notice: three of the seven addresses are outright blocked, but the other four are merely flagged with a warning. The checker can catch a disguised host. But "not the server's host" is sometimes a legitimate third-party sign-in page. So the decision is handed to the person as a warning rather than resolved automatically.

How to read the capability-gating table: each row removed one declared capability from the client and ran the matching request.

Capability missing What happened
No elicitation at all server sent 0 requests; tool returned a message for the model, not a crash
elicitation without url URL mode refused to a forms-only client
No sampling sampling refused to a client that declared none
sampling without tools tool-using sampling refused to a client that declared sampling with no tools

What to notice: every row produces a message the model can act on, never a raw error. One case was followed through. The model retried with confirmed=true after being told the client cannot ask. The entry was still submitted. That is exactly why section 6 below treats that fallback as weaker than a real control.

How to read the sampling-controls table: each row removes or keeps one host-side control, against a greedy server asking for 100,000 tokens, 50 times.

Control Result in the example
Client never declared sampling.context server's includeContext request never sent; 0 model calls
Cap on tokens per call the model saw at most 30 instead of 100,000
Limit on calls stopped after 5 calls with "too many sampling requests"
Token budget 45 tokens spent against a budget of 60
Leave the shared context out secret in the host's history leaked: false
A host that honours includeContext secret leaked: true
Person denies the request 0 model calls; the call is abandoned
Person edits the prompt the reply reflected the edit (Lisbon became Porto)

What to notice: the two includeContext rows are the same host, same server, same request, differing only in one setting. This is the cleanest demonstration in the whole module that a single host-side flag can be the entire difference between a secret staying put and a secret leaking.

{{svg:state|What is in a sealed state, and what happens when it comes back changed}} {{svg:controls|The two attacks that matter, and where the real control sits}}