# What MCP servers tell an agent after a write: a source-code study of 100 servers

IsoKron, November 2026. **Exploratory study.** The question and frame were set before the first coding pass. The written codebook came after that pass, from a coder who had seen its aggregate rates. The analysis was not pre-registered, and two coding rules were tightened after the two coders' results were compared (section 5). Treat the rates as estimates for this frame, not as settled population values. All figures are read from source, not run, with Wilson 95% intervals.

## 1. Summary in plain language

When an AI agent asks a tool to change something, it has to learn from the answer what happened. Did the change take effect? Did it fail? Is the result unknown, for example because the connection dropped after the request was sent? Is it safe to send the same request again? Was it refused because someone else changed the thing first?

We read the source code of 100 randomly sampled MCP servers that have real write tools, taken from the 300 most downloaded packaged servers in the official MCP registry. Two coders, both AI research agents, worked from a written codebook; their disagreements were resolved by re-reading the code. The study ran none of the downloaded code: the figures describe what the code returns, not observed traffic. (The catalog census that built the frame did start each package once, to read its tool list; see section 3.)

- **A basic success or failure flag is common.** 44 of 100 servers (95% interval 35% to 54%) return some machine-readable flag such as `ok`, `success` or an outcome status. 28 put it in `structuredContent`.
- **The answers that matter after something goes wrong are rare.** 7 of 100 (3% to 14%) can say "unknown" in a form a program can read. 1 of 100 returns a conflict together with the current version or state. 2 of 100 return the full set of outcome, unknown and safe-to-repeat in `structuredContent`.
- **Failures often do not look like failures.** 31 of 100 (23% to 41%) return at least one kind of failure as an ordinary result, without the protocol's `isError` flag.
- **Servers that wrap a web API lose what the API already says.** Of 42 such servers, 39 (81% to 98%) report a request that got no answer as a plain failure, with no sign that the write may have applied. In our adjudicated coding, most wrappers also pass the API's status or error code on only as prose or not at all; that is the category the two coders agreed on least (kappa 0.24 before adjudication), so we treat it as indicative only (section 7).

## 2. Question

For a server with real write tools, does a write's result tell the caller, in a form a program can read:

1. whether the write took effect;
2. that the outcome is unknown, as distinct from failed;
3. whether repeating the call is safe, or that the result is a replay;
4. that the write was refused because of a conflict with the current state, and what that state or version is;
5. for writes that touch several items or take several steps, what happened to each;

and, for servers that wrap a web API, what happens to the API's own status, conflict and idempotency signals on the way to the caller?

## 3. Frame and sampling

- **Population.** Packaged MCP servers (npm or PyPI) named by active entries of the official MCP registry, ranked by downloads for 7 to 13 November 2026. IsoKron's catalog census started the top-ranked packages one by one, with install scripts disabled and placeholder settings, to read their tool lists, until 300 had returned one: 414 packages were tried and 114 returned none, at least 20 of them because they needed a real account, an interactive login or a reachable backend. Servers that cannot list tools without these are therefore missing from the frame, and they lean towards API wrappers. The census classified each tool as read or write.
- **Frame.** The 241 census servers with at least one write-class tool, less the 2 router catalogs the census sets aside.
- **Order.** The frame was sorted by package name and shuffled with a fixed seed, recorded privately. Servers were taken in that order. The first 52 were the earlier single-coder study; this study re-coded them and continued in the same order to server 119.
- **Rules fixed before reading.** Each server was read at the census version. A server with no readable source was skipped. A server whose census write tools change nothing on reading was recorded and excluded from every denominator.
- **Result.** 119 servers taken, 100 analysable: 17 had no real write and 2 had no readable source (one ships only a binary built from a private repository; one is a 212 MB bundle whose result path could not be traced). Among servers with readable source, 17 of 117 (15%; 9% to 22%) of the census's "servers with writes" had none, so server-level denominators built from tool names alone are inflated.
- **Coverage.** The 119 servers are about half the frame. The intervals below ignore the finite-population correction, which would narrow them.

## 4. Codebook

The full codebook, with decision rules, worked examples and the list of definition fixes, is published with this study (`CODEBOOK.md`). In brief:

| Code | Counts as 1 when a write result… |
|---|---|
| Success/failure flag | carries a member that says whether the write took effect (`ok`, `success`, `applied`, `deleted`, an outcome or status enum), in `structuredContent` or a JSON object in the text. `isError` alone, a resource echo or a bare HTTP status do not count. |
| Unknown | carries a value that itself means the outcome is unknown or uncertain (`unknown`, `submission_uncertain`, `outcome_unknown`). A timeout code with a prose hint does not count here; it counts as "unknown, at least in prose". |
| Safe to repeat or replay | carries a member saying whether repeating is safe (`retryable`, `safe_to_retry`), or that the result is a replay (`replayed`, `deduplicated`), or returns the idempotency key on a failure or unknown path. |
| Structured conflict | says in machine-readable form that the write was refused because the target changed, **and** carries the current version, etag or state. |
| Per-item results | for bulk or multi-step writes, reports each item's or step's outcome in machine-readable form, including on failure. |
| Idempotency key | the write tool accepts a caller-supplied key that the server uses. |
| Full set | outcome flag, unknown and repeat signal, all in `structuredContent`. |
| Failure without `isError` | on any read write path, a definite failure is returned as an ordinary result. |
| HTTP wrapper | the write handlers send HTTP requests to a service outside the package. Local tools, desktop-app bridges and database drivers are not wrappers. |

Signals 1 to 6 are coded on the server's best read write handler (does any write say it?); failures without `isError` and the wrapper losses are coded on the worst (does any write lose it?).

## 5. Two coders and agreement

- **Coders.** Two coders read the code independently. The first coded the first 52 servers for the earlier study. The second wrote the codebook from the earlier study's stated method and categories, then re-coded the same servers from freshly downloaded source before opening the first coder's table. The second coder had read the earlier study's method section, which reported its aggregate rates and named a few servers as examples; the per-server codes were not seen until the re-coding was saved. Both coders were AI research agents working for IsoKron. We report their agreement as a check on the codebook's clarity and on reading errors, not as agreement between independent human experts.
- **Agreement before adjudication** (44 servers both coders analysed; Cohen's kappa):

| Category | Agreement | Kappa | Coder 1 | Coder 2 |
|---|---|---|---|---|
| Real write (eligibility), 51 servers | 98% | 0.91 | | |
| Success shape (prose / JSON text / structured) | 93% | 0.89 | | |
| Success/failure flag | 89% | 0.77 | 19 | 22 |
| …in `structuredContent` | 89% | 0.74 | 14 | 15 |
| Unknown, machine-readable | 86% | 0.44 | 3 | 9 |
| …same, with the adjudication rule F11 applied to coder 2 | 93% | 0.63 | 3 | 6 |
| Unknown, at least in prose | 89% | 0.64 | 6 | 11 |
| Safe to repeat or replay | 89% | 0.61 | 5 | 10 |
| Structured conflict with current state | 100% | 1.00 | 1 | 1 |
| Bulk or multi-step write present | 82% | 0.57 | 11 | 15 |
| Per-item results (9 servers both coded bulk) | 100% | 1.00 | 6 | 6 |
| Idempotency key | 95% | 0.77 | 5 | 5 |
| Full set | 95% | 0.48 | 1 | 3 |
| Failure without `isError` | 86% | 0.65 | 8 | 14 |
| HTTP wrapper | 95% | 0.90 | 18 | 16 |
| Wrapper status kept / prose / dropped (16 wrappers) | 50% | 0.24 | | |

- **Reading the table.** Agreement was high on what a result looks like and on whether a server wraps an API. It was moderate on the judgment categories (unknown, repeat signal, failures without `isError`) and poor on how a wrapper treats the API's status. Most disagreements came from three sources: one coder read a write handler the other did not (bulk tools, a second write tool, a shared dependency), the first study had no rule for status that survives only in an error message, and the original "unknown" rule let a timeout code plus a prose hint count.
- **Adjudication.** Each of 58 disagreements, plus one shared error found while re-reading, was resolved by re-reading the code; every resolution and its reason is recorded. 46 resolutions took the second coder's value and 13 the first coder's or a corrected value. Two rules were tightened at this stage and applied to all later coding: **F11**, "unknown" requires a value that itself means unknown (a timeout code with a hint is prose); **F12**, a batch that comes back without `isError` when every item failed counts as a failure without `isError`. The kappas above are those before adjudication, under the codebook as first written.
- **Extension.** Servers 53 to 119 were coded by the second coder alone, under the adjudicated codebook. They are not double-coded; for the judgment categories, expect error of the size the table shows.

## 6. Results

100 servers with real writes; Wilson 95% intervals.

| Of 100 servers with real writes | n | Rate | 95% interval |
|---|---|---|---|
| Success result is prose only | 28 | 28% | 20% to 38% |
| Success result is JSON in a text block, no `structuredContent` | 32 | 32% | 24% to 42% |
| Success result uses `structuredContent` | 40 | 40% | 31% to 50% |
| Any machine-readable success/failure flag | 44 | 44% | 35% to 54% |
| …in `structuredContent` | 28 | 28% | 20% to 38% |
| Says "unknown" in a machine-readable form | 7 | 7% | 3% to 14% |
| Says unknown or partly applied, at least in prose | 20 | 20% | 13% to 29% |
| Safe-to-repeat or replay signal | 17 | 17% | 11% to 26% |
| …of which a replay or deduplication marker | 8 | 8% | 4% to 15% |
| Structured conflict carrying the current state or version | 1 | 1% | 0.2% to 5% |
| Structured conflict code or status, with or without the current state | 8 | 8% | 4% to 15% |
| Accepts an idempotency key | 15 | 15% | 9% to 23% |
| Full set (outcome, unknown, repeat) in `structuredContent` | 2 | 2% | 0.6% to 7% |
| At least one kind of failure returned without `isError` | 31 | 31% | 23% to 41% |
| Any of unknown, repeat, conflict or per-item | 31 | 31% | 23% to 41% |
| Per-item results, among the 29 with a bulk or multi-step write | 18 of 29 | 62% | 44% to 77% |

Further observations, read from code and not separately coded across all 100:

- Two servers send a write again after a network error or timeout without telling the caller; one marks a timed-out write as safe to retry, although the operation may still be applying. A repeat signal is only as good as its meaning.
- At least three report `isError` for a write that was already applied, because a check after the write (output validation, a re-audit, process clean-up) failed.
- Several keep a full outcome vocabulary internally (created, duplicate, merged, quarantined; or not started, unknown, partial) and pass it to the caller only as prose.


## 7. The wrapper-loss finding

42 of the 100 servers send their writes to a web API outside the package (42%; 33% to 52%). The APIs behind them typically answer with a status code, an error code, and for some a version check or idempotency key. For each wrapper we coded how those signals reach the caller.

**How the API's status reaches the caller: indicative only.** This is the category the two coders agreed on least before adjudication (50% agreement, kappa 0.24 on 16 wrappers; section 5). In the adjudicated coding, 15 of the 42 wrappers keep the API's status or error code as a machine-readable member, and the rest pass it on only inside error prose or drop it. We give no rate or interval for this split and do not headline it.

The five loss patterns:

| Pattern | Applies to | n | Rate | 95% interval |
|---|---|---|---|---|
| 1. Status or code turned into prose, or dropped | 42 wrappers | most (see above) | indicative only | not given: kappa 0.24 |
| 2. An API refusal can come back as an ordinary result | 42 wrappers | 12 | 29% | 17% to 44% |
| 3. The API's own conflict check switched off (forced overwrite, fetching the current version itself, or omitting a precondition the API offers) | 5 wrappers where a version check is visible | not estimated | — | too few observable cases |
| 4. A request that got no answer reported as a plain failure, with no "unknown" | 42 wrappers | 39 | 93% | 81% to 98% |
| 5. Idempotency key not passed through, or generated and not returned on failure | 9 wrappers whose API takes a key | not estimated | — | too few observable cases |

What this shows and does not show:

- **Pattern 4 is the clearest finding.** Almost no wrapper keeps "no answer" apart from "failed". Pattern 2, a refusal handed back as if it were a normal answer, was found in 12 of 42 wrappers. Pattern 1 appears common in our coding, but the coders' agreement on it was poor, so we treat it as indicative only.
- **Patterns 3 and 5 are rarely observable in a random sample,** because few sampled wrappers sit on an API whose version check or idempotency key is visible in the code (5 and 9 servers). We give no rate for them. The strongest evidence for pattern 3 is in IsoKron's published audits of individual servers (section 8), which were chosen, not sampled.
- **Keeping the signals is cheap where it is done.** The wrappers that keep the status or code mostly do it with one error-mapping function.

## 8. Why it matters: measured consequences from published audits

These figures come from IsoKron's earlier audits of individual servers, with live runs against the server and a control straight against the platform's own API. Those servers were chosen, not sampled, so they show what the gaps above can cost, not how often.

- **A conflict check switched off loses edits.** In the Grafana MCP server v2.2.0, two simultaneous dashboard patches lost an edit in 30 of 30 pairs while both calls reported success; the tool saves with a forced overwrite, and Grafana's version check rejected a stale save in 10 of 10 trials through Grafana's own API. Grafana's own save endpoint also lost simultaneous saves (30 of 30 on Grafana 13, 20 of 30 on Grafana 11), so the audit attributes to the tool the skipped version check, not every lost edit. *Published: "Grafana MCP server v2.2.0: dashboard patches skip the version check and can silently lose edits", isokron.ai/research/grafana-mcp-server-audit, 10 November 2026.*
- **A full copy re-applied with force reverts another writer's change.** In the Kubernetes MCP server v0.1.2, a full copy re-applied through the tool after another writer changed a field lost that change in 10 of 10 trials for replicas and 10 of 10 for a ConfigMap key; with its stale `resourceVersion` kept, the write was refused with 409 in 10 of 10. *Published: "Kubernetes MCP server v0.1.2: Helm installs ignore the namespace argument, and some multi-document applies drop documents", isokron.ai/research/kubernetes-mcp-server-audit, 12 November 2026.*
- **Concurrent field updates lose changes in the tool.** In the GitHub MCP server v2.1.0, two updates to different fields of one issue lost a change in 19 of 30 pairs while both calls reported success; GitHub's per-field update lost 0 of 28. *Published: GitHub MCP server audit, isokron.ai/research/github-mcp-server-audit, 9 November 2026; also summarised in "Lost updates in four MCP servers", isokron.ai/research/mcp-lost-updates-four-servers, 10 November 2026.*
- **Not every loss is the wrapper's.** In PostHog, concurrent insight updates lost a write in 7 of 11 pairs through the hosted MCP server and 6 of 11 straight to PostHog's API; the loss was in the API, and PostHog merged the fix. *Published: PostHog MCP server audit, isokron.ai/research/posthog-mcp-server-audit, 10 November 2026.*
- **A failure reported as success hides partial writes.** In the Payload MCP plugin 3.93.0, a bulk update with one of five documents refused came back with a success headline and no `isError` in 5 of 5 runs, while Payload's REST API answered 400 with the errors. *Published: "Payload MCP plugin 3.93.0: updates and deletes write through another editor's document lock", isokron.ai/research/payload-mcp-server-audit, 14 November 2026, finding PAY-05.*
- **What protects the data is the refusal of the stale write.** In the Payload study's benchmark, the plugin's vendor build "never returned a conflict: no signal in 15 of 15 seeded runs …, and the other writer's change was lost every time". An IsoKron research build recovered 10 of the 15 seeded conflicts and refused the other 5, telling the user who was editing. The research build also refused the stale write, not only reported it, so we read this as evidence for the refusal, not for the wording of the message. *Published: isokron.ai/research/payload-mcp-server-audit, section "Conflict recovery".* The Kubernetes addendum points the same way. On a research build that refused a stale write with the API's 409: "The message says only that the object changed and to try again; it does not carry the current state. In all 20 model A runs the agent re-read the object and kept the other writer's change." The addendum adds: "The 409 only protects a write that carries the version the agent read." *Published: isokron.ai/research/kubernetes-mcp-server-audit, addendum of 13 November 2026.*
- **What the signals are for.** We do not claim that returning a richer signal makes agents recover. Its value is that the agent, and any tool or person reading the record, knows what happened: honest outcomes, fewer blind resends, retries that are safe because they carry a key, and no silent duplicates. Protection comes from the server refusing the write.

## 9. Limits

- **Read, not run.** Every code describes what the source would return. Code paths that are never reached in practice, configuration that changes behaviour, and dependencies not read can make the real behaviour differ.
- **Results, not agent behaviour.** The study measures what write results say in code. It does not measure what clients or agents do with the answer.
- **Coverage within a server.** One to three write handlers per server were read, with the shared result and error wrappers. Other tools of the same server may differ. The best-handler and worst-handler rules are stated in section 4.
- **Minified and bundled code.** Several servers were read through unique code strings in minified bundles; for a few, an error path was not traced in full. One very large bundle was excluded as unreadable. Several packages are launchers for a native binary or for a dependency; those were read from the tagged source of the same version or from the dependency at its pinned version.
- **Frame.** Only packaged npm and PyPI servers that listed tools in the census. Hosted-only servers, container images and other package types are outside it, and the ranking is by downloads in one week.
- **Coding.** The first 44 servers were coded twice and adjudicated; the remaining 56 by one coder. The agreement figures in section 5 indicate the error to expect in the judgment categories. Both coders were AI research agents; no person coded any server. A blind recode by a person of about 20 sampled servers and the five audited servers is future work.
- **Not pre-registered.** Two rules were tightened after the comparison (F11, F12). Under the original "unknown" rule, three more of the 44 double-coded servers would count, so at least 10 of 100 would count instead of 7. This is a lower bound: the other 56 were coded only under the tightened rule, so their count under the original rule is not known.
- **Small counts.** Rates near zero rest on one or two servers, and their intervals are wide. Loss patterns 3 and 5 are not estimated.
- **Low agreement on wrapper status.** How a wrapper passes on the API's status had kappa 0.24 before adjudication; that split is reported as indicative only.
- **Audits are not a sample.** The five servers named in section 8 were chosen for audit. They show what the gaps can cost, not how often the gaps occur. No server in the sample of 100 is named.

## 10. Data and reproduction

- **Published with this study:** this write-up, the codebook, the specification search log (`SPEC-SEARCH-2026-11-15.md`) and the per-server codes.
- **Per-server data.** In the published per-server file (`data/per-server-codes-pseudonymised.csv`, described in `data/README.md`) each of the 119 servers taken is identified only by a random pseudonym, with its codes, whether it was double-coded, whether it is a wrapper and a coarse category; the category is withheld wherever fewer than three servers would share it. Package names, versions, sample order and the file-and-line evidence notes are left out, because they would identify the server. The evidence notes, the blind re-code, the extension and the adjudication record are available on request. The five audited servers in section 8 are named because their audits are published.
- **Reproduction.** The sample order, seed and frame come from IsoKron's catalog census. The fetch script downloads each package into its own empty folder (`npm pack --ignore-scripts`; for PyPI, a wheel with `pip download --no-deps --only-binary=:all:`, or the source archive by URL, never built) and prints the census write tools and search hits. Agreement, adjudication and final rates are computed by small scripts from the coded tables. The study ran none of the downloaded code; the census that built the frame started each package once to read its tool list (section 3).
