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}}