IsoKron, November 2026. An exploratory study: we read the source code of 100 MCP servers drawn from popular npm and PyPI packages, and did not run them. IsoKron audits MCP servers’ write paths, writes the MCP Write-Safety Requirements, and offers an optional result format and helper kits; see “Interests” at the end. Limits are under “Scope and limits”, and the method under “Method and data”.
The question
When an agent asks a tool to change something, such as creating an issue, updating a record or deleting a file, the tool’s result is all the agent has to go on. Five questions decide what it should do next:
- Did the write take effect?
- If the server cannot tell, for example because the connection dropped after the request went out, does it say the outcome is unknown rather than that the write failed?
- Is it safe to send the same call again, or is this answer a replay of an earlier one?
- If the write was refused because someone else changed the target first, does the result say so and give the current version or state?
- For a write that touches several items or takes several steps, what happened to each?
We sampled 100 servers at random from the most-downloaded packaged MCP servers in the official registry that have real write tools, read their write paths, and recorded whether their results answer these questions in a form a program can read. For the 42 that send their writes to a web API, we also traced what happens to the signals that API returns.
Sample at a glance. The frame is the packaged npm and PyPI servers named by active entries of the official MCP registry, ranked by downloads for 7 to 13 November 2026, that listed their tools when started without real credentials: the 241 census servers with a write tool, less 2 router catalogs. We shuffled it with a fixed seed and took servers in order until 100 had a real write and readable source (119 taken). Two coders, both AI research agents, worked from a written codebook; 44 servers were coded by both and adjudicated. The full protocol is under Method and data.
Summary
- A success or failure member is common. 44 of 100 servers (35% to 54%) return a machine-readable success or failure member.
- An explicit “unknown” and a conflict that carries the current state are rare. 7 of 100 (3% to 14%) carry a value that means “unknown”; 20 say it at least in prose. 8 return a structured conflict code; 1 also returns the current version.
- Many failures do not carry the protocol’s error flag. 31 of 100 (23% to 41%) return at least one definite failure without
isError. - Wrappers lose “no answer”. In 39 of the 42 servers that wrap a web API (81% to 98%), a request that got no answer has no machine-readable “unknown” value.
Why it matters
Agents act on results. “Failed” invites a retry; if the write had in fact landed, the retry can duplicate it. “Success” can end the task; if part of the write did not apply, that may go unnoticed. A failure returned without the protocol’s isError flag reads as success to a client that checks only the flag.
These fields report what happened. They do not protect data: that comes from the server refusing a stale write, which is a separate practice (recommendation 4). This study measures what results say, not what agents do with them.
What the underlying APIs already provide
Several widely used web APIs already carry these signals.
- HTTP (RFC 9110). Conditional requests let a client send the version it read (
If-Matchwith an entity tag). If the condition fails, the server must not perform the request, and normally answers412 Precondition Failed. RFC 9110 also defines which methods are idempotent, which is a property of the method, not a replay signal. - Stripe. For a
POSTwith an idempotency key, Stripe caches the result once the method begins executing, errors included, and a retry with the same key returns that cached response, markedIdempotent-Replayed: true. Its guidance says to “treat the outcome of a request that returns500as indeterminate”, and aStripe-Should-Retryresponse header says whether to retry (Stripe, Advanced error handling, API v1, read 15 Nov 2026). - GitHub REST. The Contents API requires the blob
shato delete a file, and to replace one. Both operations document409 Conflict. - Google’s API design guidance. Under AIP-154, a request whose etag does not match fails with
ABORTED(HTTP 409); AIP-193 gives each error a stable machine-readable reason and metadata beside the human message. - Kubernetes. An update that carries a stale
metadata.resourceVersionis refused with409 Conflict. Separately, server-side apply reports a conflict when it would change a field another manager owns, unless the apply is forced.
MCP gives a tool result an isError flag and an optional structuredContent object. The specification puts tool-execution failures, including API and business-logic errors, in the result with isError: true, so that the model still sees the error; protocol errors are a different mechanism. Tools can also declare hints such as idempotentHint, but these describe the tool in general, not the outcome of one call.
On 15 November 2026 we read the MCP specification (version 2026-07-28) and searched the issues and pull requests in modelcontextprotocol/modelcontextprotocol, where proposals (SEPs) are filed, for 43 terms, among them idempotency, “unknown outcome”, “partial success”, retry, outcome, conflict, isError and structuredContent; the queries, counts and items read are in the published search log. The specification has no field in a tool result for whether a write took effect or for an unknown outcome. One open draft proposal defines both for a narrow case: SEP-2848, an extension for tool calls held for out-of-band approval, requires a disposition in the result’s _meta of approved-executed, denied-not-executed, execution-error or outcome-unknown (#2848). Two closed proposals for signed audit records define a call-outcome status without an unknown value (#2828, #3350); for ordinary tool calls, an open issue asks whether the specification should call a lost response’s outcome ambiguous (#3394), and an open draft adds a retryable flag to failed results (SEP-3313).
What we found in 100 servers
| Of 100 servers with real write tools (in at least one of the one to three write handlers read) | Count | 95% interval |
|---|---|---|
| Did the write take effect? Any machine-readable success or failure member | 44 | 35% to 54% |
| Unknown outcome: a machine-readable value that means unknown | 7 | 3% to 14% |
| …says unknown or partly applied, at least in prose | 20 | 13% to 29% |
| Safe to repeat: a safe-to-repeat or replay signal | 17 | 11% to 26% |
| …accepts a caller-supplied idempotency key | 15 | 9% to 23% |
| Conflict: a structured conflict code or status | 8 | 4% to 15% |
| …together with the current version or state | 1 | 0.2% to 5% |
| Per item: per-item results, of the 29 with a bulk or multi-step write | 18 of 29 | 44% to 77% |
Returns at least one kind of definite failure without isError | 31 | 23% to 41% |
Exploratory; read from source, not run. Wilson 95% intervals describe sampling only; coding error is not included and is likely larger for the categories with lower agreement (see Method and data). Signals are counted if any read write handler has them; failures without isError if any read path has one.
A success or failure member is common; an explicit “unknown” and a conflict that carries the current state are rare. In this sample, 44 servers return something like ok, success or a status member. Seven carry a value that means “unknown”, and 20 say it at least in prose. Eight return a structured conflict code; one also returns the current version. In our own Kubernetes test the conflict code alone was enough for the agent to recover (box below), so the missing state is a gap in information, not in protection.
Many failures do not carry the protocol’s error flag. In 31 servers, at least one definite failure we read comes back without isError. Typical cases are an error object returned as data, a success: false without isError, or a batch in which every item failed returned as a normal answer. Sixteen of the 31 also return a machine-readable success or failure member somewhere in their write results, so for some of these a program that reads the content can see the failure; we did not code whether that member sits on the same failure path. A client that checks only isError cannot see it.
In this sample, 72 of 100 servers return JSON on success, so a resource or ID often comes back even where no outcome member does. We did not code that separately.
Where the wrappers lose it
42 of the 100 servers send their writes to a web API outside the package, directly or through the vendor’s SDK. That API answers with a status code, often an error code, and sometimes a version check or idempotency key.
A sent request that gets no answer has no “unknown” value. In 39 of 42 wrappers (81% to 98%), the results we read have no machine-readable value meaning “outcome unknown”, so a timeout or dropped connection after the request was sent comes back as a failure, with no sign that the write may have applied. The other 3 can say “unknown”. Some HTTP clients cannot tell “never sent” from “sent, no reply” without extra work, so part of this gap may be inherited from the client library. We did not classify the 39 by library.
Version checks and idempotency keys were rarely visible. A version check that the API offers was visible in the code for 5 wrappers; one of them switches it off. An idempotency key was visible for 9; one does not pass it through or return it on failure. Those counts are too small for rates.
Conflict codes pass through more often than state. 7 of the 42 wrappers keep the API’s conflict as a structured code; none returns the current state with it.
Cases from our audits (not part of the sample)
None of the five servers below is in the 100. They were chosen for audit, and show what these gaps can cost in live runs, not how often they occur.
- GitHub MCP server v2.1.0. Creating or editing a pull request “can succeed, then return an error if the reviewer request fails. On creation the new PR number and URL are lost; on update the edit stays applied although the call reports an error” (finding GH-05). Separately, “
delete_filetakes no sha, so it deletes content another writer changed after the caller’s read”, although the Contents API’s delete requires one (GH-02). - Payload MCP plugin 3.93.0. With one document of five refused in a bulk update, “the headline still said ‘Multiple documents updated’ and
isErrorwas unset, in 5 of 5 runs”, while Payload’s REST API answered 400 with the errors (PAY-05). 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”. Our research build refused the stale write; it differed from the vendor build in more than its message. - Grafana MCP server v2.2.0. “The tool saves every patch with
Overwrite: truehard-coded, so the version check in Grafana’s save API never runs.” Two simultaneous patches lost an edit on every run (n = 30 pairs on each of Grafana 13 and 11) while both calls reported success; Grafana’s own API rejected a stale save on every run (n = 10 on each version). Grafana’s save API also lost simultaneous saves with overwrite off, in 30 of 30 pairs on Grafana 13 and 20 of 30 on Grafana 11, so the audit attributes to the tool the skipped version check, not every lost edit. - Kubernetes MCP server v0.1.2. Upstream applies with force on purpose; the audit measured this and did not file it. After another writer changed a field, a full copy re-applied through the tool lost that change on every trial (n = 10 for replicas, n = 10 for a ConfigMap key), and in the ConfigMap case all 7 agent runs on v0.1.2 told the user “the other keys are unchanged: …”. With its stale
resourceVersionkept, the same copy was “Refused with 409 in 10 of 10”. A research build that refused the stale write with the API’s 409, a message that “says only that the object changed and to try again”, saw the agent re-read and keep the other writer’s change in all 20 runs of model A. - PostHog. Two calls updating different fields of one insight lost a write in 7 of 11 pairs through the hosted MCP server and in 6 of 11 straight to PostHog’s API; we saw no difference at this sample size. The loss was in the API, and PostHog merged the insights fix.
Other explanations
- SDK defaults and templates. Many servers share an SDK or starter template, and the SDK often decides how a thrown error is returned and whether
structuredContentis easy to use. If so, these rates describe SDK defaults as much as builders’ choices, and the most effective fix is in SDKs and templates. We did not record SDK or template per server. - Deliberate choices. Some builders return failures as ordinary results so the model reads the error and corrects itself. Under the specification,
isError: truedoes not hide the content from the model; it also tells programs, logs and retry logic that the call failed. A negative business outcome, such as an approval still pending, can be an ordinary result if its meaning is explicit. - Limits of the transport. Some HTTP clients and APIs cannot establish whether a sent write applied. Then “unknown” is the honest answer, and no read may settle it.
- Prose for models. A model can often act on an error written in prose. These fields matter most for programs that read results; this study does not show that they change what an agent does.
Recommendations: what builders can do
None of the following needs a new protocol feature. Recommendation 4 is the one that prevents loss; the rest report what happened. The evidence column gives the figures from this study and the audits above that each one rests on; none of the recommendations was tested here.
| Recommendation | Evidence |
|---|---|
1. Set isError honestly. A definite failure, a refusal, or a batch in which every item failed should carry isError: true. A write that applied should not be reported as an error because a later step failed; say both. isError says the call failed; an outcome field says what happened to the write. They answer different questions. | 31 of 100 return at least one definite failure without isError. Audits: Payload PAY-05 (bulk update with one of five refused, no isError, 5 of 5 runs); GitHub GH-05 (edit applied although the call reports an error). |
| 2. Say what happened, including “unknown”. State whether the write was applied, not applied, partly applied or of unknown outcome. Keep “the request got no answer” apart from “the request failed”. Where a read can settle an unknown outcome, name it; where none can, say the outcome stays unknown and do not call a retry safe. | 44 of 100 return a machine-readable success or failure member; 7 of 100 a machine-readable “unknown”; 20 say it at least in prose. In 39 of 42 wrappers, a request that got no answer has no “unknown” value. |
| 3. Accept idempotency keys and pass them through. If the API takes a key, let the caller supply one and forward it. A key the server generates should come back on failure and unknown outcomes too, not only on success. Mark a replay as a replay, and do not silently re-send a write after a timeout. | 15 of 100 accept a caller-supplied key; 17 return a safe-to-repeat or replay signal. A key was visible for 9 wrappers, and one does not pass it through or return it on failure: too few for a rate. |
4. Refuse stale writes. Keep the API’s precondition: send the version, etag, sha or resourceVersion the caller read. When the API refuses, pass the refusal on as an error that says the write was not applied and, where the caller may read it, gives the current version. If the tool forces an overwrite on purpose, say so in its description and its result. A thin wrapper does not need to build its own concurrency control, but it should not remove the one its API provides. | 8 of 100 return a structured conflict code; 1 also returns the current version. A version check was visible for 5 wrappers, and one switches it off: too few for a rate. Audits: Grafana (forced overwrite, an edit lost in 30 of 30 pairs); Kubernetes (forced re-apply lost the change on every trial; refused with 409 in 10 of 10 when the stale resourceVersion was kept; a refusing research build kept the other writer’s change in all 20 runs). |
| 5. Report each item of a bulk write. Say which items applied, which did not, and which were never attempted. | 18 of the 29 servers with a bulk or multi-step write return per-item results. Audit: Payload PAY-05. |
| 6. Keep the API’s status and error code as fields, not only inside a sentence. | No figure: our coders could not code this reliably across the sample (kappa 0.24 before adjudication; see Method and data). |
Tooling IsoKron offers
IsoKron publishes the MCP Write-Safety Requirements. Item B-9 of its Annex B describes an optional result shape, write-result/0.1, that puts outcome, unknown and safe-to-repeat in one member of structuredContent; two helper kits implement it, @mcp-write-safety/kit for TypeScript and mcp-write-safety-kit for Python (source). It is one way to follow the recommendations above; others work as well, for example a documented structuredContent object with an output schema, passing the API’s own error object through, AIP-193-style reason codes, or, for calls held for approval, the disposition in SEP-2848. The shape is version 0.1, has not been proposed to the MCP specification, and was not tested in this study. The table row for it in the full data is the count of servers with all three of its fields in structuredContent: 2 of 100.
The result-reporting requirements of MWS cover several of these signals. For what each term means in practice, see What is MCP write safety?.
Scope and limits
- Read, not run. Codes describe what the source would return on the paths we read. Configuration, unread dependencies and paths that never run can make real behavior differ.
- Exploratory, not pre-registered. 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. Two rules were tightened after the two coders’ results were compared, and both moved results in the same direction (see Method and data).
- Frame. Packaged npm and PyPI servers in the official MCP registry, among the most downloaded in one week, that listed their tools when started without real credentials. Servers that needed a real account, an interactive login or a reachable backend to list tools are missing, and these lean towards API wrappers. Hosted-only servers, container images and other package types are outside the frame. The results describe this frame, not every MCP server.
- Coverage within a server. We read one to three write handlers per server, with the shared result and error code; other tools may differ. Several servers were read through minified bundles, and for a few an error path was not traced in full.
- Coding by AI agents only. Both coders were AI research agents; no person coded any server. 44 servers were coded twice and adjudicated, and the other 56 by one coder. Blinding was partial. Disagreements were resolved by an AI agent re-reading the code, in the second coder’s own workflow, not by an independent adjudicator. Both coders ran on the same model, so their agreement measures consistency, not independence or correctness; the kappas are under Method and data. A blind recode by a person of about 20 sampled servers and the five audited servers is future work.
- Small counts. Rates near zero rest on one or two servers, and their intervals are wide.
- The audits are not a sample. No audited server is in the 100, and no sampled server is named.
- Results, not agent behavior. This study measures what results say, not what agents do with them.
Method and data
This section is meant to be enough to repeat the study. The full write-up, the codebook, the specification search log and the per-server codes are published with this page; links are under Data availability.
Sampling frame
- Census. IsoKron’s catalog census took the most-downloaded packaged servers named by active entries of the official MCP registry (downloads for 7 to 13 November 2026) and started each one, with install scripts disabled and placeholder settings, to read its tool list. It continued until 300 returned a tool list: 414 packages were tried and 114 returned none, at least 20 of them because they needed a real account, a login or a reachable backend. The census classified each tool as read or write.
- Frame. The 241 census servers with a write tool, less 2 router catalogs.
- 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 an earlier single-coder pass; this study re-coded them and continued in the same order to server 119.
- Eligibility, fixed before reading. Each server was read at the census version. A server counts as eligible when at least one census write-class tool, on reading, changes state outside the call (a remote service, a file, a database, a process or device, an application document), and its write path can be traced in readable source. 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.
- How 100 were reached. We took servers in order until 100 had a real write and readable source.
| Step | Count |
|---|---|
| Packages tried by the census | 414 |
| …returned no tool list | 114 (at least 20 needed a real account, a login or a reachable backend) |
| …returned a tool list | 300 |
| Census servers with a write tool | 241 |
| Less router catalogs, which the census sets aside | 2 |
| Taken from the shuffled frame | 119 |
| Excluded: no real write | 17 |
| Excluded: no readable source | 2 (one ships only a binary built from a private repository; one is a 212 MB bundle whose result path could not be traced) |
| Eligible and coded | 100 |
Tool names alone overstate writes: 17 of 117 readable servers had none (15%; 9% to 22%), so server-level denominators built from tool names alone are inflated. The 119 servers taken are about half the frame.
Reading
The study ran no downloaded code: packages were fetched with install scripts disabled and read as source. npm packages were fetched with npm pack <pkg>@<ver> --ignore-scripts; PyPI packages as a wheel with pip download --no-deps --only-binary=:all:, or, where no wheel exists, as the source archive by its PyPI URL, unpacked and never built. GitHub was used only when a package ships a native binary or no readable source. Each package was unpacked into its own empty folder and deleted after coding.
Each server was read at the census version: one to three write handlers, preferring update, delete and create, and every shared wrapper they pass through, including how the SDK returns a thrown error. Signals were coded on the best write handler (does any write say it?); failures without isError and wrapper losses on the worst (does any write lose it?). A wrapper’s write handlers send HTTP requests, directly or through the vendor’s SDK, to a service outside the package; local tools, desktop-app bridges, localhost daemons of the same product and database drivers are not wrappers. Every code of 1, and every judgment call, cites a file and line, or a unique code string for minified bundles.
Codebook
The full codebook (version 1.1), with decision rules, worked examples and the list of definition fixes, is published as CODEBOOK.md. In brief:
| Code | Counts as 1 when a write result… |
|---|---|
Success/failure flag (C1) | 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 (C2) | 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” (C2p). |
Safe to repeat or replay (C3) | 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 (C4; C4a without state) | 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 (C5) | for bulk or multi-step writes, reports each item’s or step’s outcome in machine-readable form, including on failure. |
Idempotency key (C6) | the write tool accepts a caller-supplied key that the server uses. |
Full set (B9) | outcome flag, unknown and repeat signal, all in structuredContent. |
Failure without isError (C7) | on any read write path, a definite failure is returned as an ordinary result. |
HTTP wrapper (H) | the write handlers send HTTP requests to a service outside the package. Local tools, desktop-app bridges and database drivers are not wrappers. |
For wrappers, W1 records how the API’s status reaches the caller (kept as a member, prose only, or dropped), and L1 to L5 the five loss patterns: status turned into prose or dropped; a refusal returned as a non-error; the API’s conflict check switched off; no answer collapsed into “failed”; an idempotency key not passed through or not given back.
Two coders
Both coders were AI research agents working for IsoKron, and both ran on the same model. The first coded the first 52 servers in an earlier pass. The second wrote the codebook from the first pass’s stated method, then re-coded the same servers from freshly downloaded source before opening the first coder’s table. The second coder had read the first pass’s method section, which gave aggregate rates and named a few servers as examples; the per-server codes were not seen until the re-coding was saved. Agreement between the two measures consistency, not correctness: two AI agents can share blind spots. Servers 53 to 119 were coded by the second coder alone, under the adjudicated codebook.
Agreement
Cohen’s kappa before adjudication, on the 44 servers both coders analyzed, under the codebook as first written:
| Category | Agreement | Kappa | Coder 1 | Coder 2 |
|---|---|---|---|---|
| Real write (eligibility), 51 servers | 98% | 0.91 | None | None |
| Success shape (prose / JSON text / structured) | 93% | 0.89 | None | None |
| 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 | None | None |
How a wrapper passes on the API’s status could not be coded reliably, so we report no figure for it. There is no separate agreement figure for the no-“unknown” wrapper count; it follows from the wrapper and “unknown” codes. 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 pass 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, and one shared error found while re-reading, was resolved by re-reading the code, in the second coder’s workflow rather than by an independent adjudicator; no person and no independent third agent adjudicated. 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 tightened after the comparison. Both moved results in the same direction, and both were applied to all later coding.
- “Unknown” (F11) now needs a value that itself means unknown; a timeout code with a prose hint counts only as “unknown, at least in prose”. This removed 3 servers among the 44 double-coded ones, so under the original rule at least 10 of 100 would count. The other 56 were coded only under the tightened rule, so their count under the original rule is not known.
- A batch returned without
isErrorwhen every item failed (F12) now counts as a failure withoutisError. At least 2 of the 15 such servers among the 44 rest on this rule. The 56 did not record it separately.
By coding. Adjudicated 44 against single-coded 56: a success or failure member 23 and 21; “unknown” 5 and 2; failures without isError 15 and 16; wrappers 16 and 26.
Intervals
Wilson 95% intervals, without a finite-population correction. About 200 servers in the frame would meet the eligibility rules, so the sample is about half of them; the correction would narrow the intervals by roughly a quarter.
Specification search
The dated statement under “What the underlying APIs already provide” rests on a search run on 15 November 2026: the MCP specification version 2026-07-28 read in full for tools, a full-text check of the published documentation, and 43 terms searched in the issues and pull requests of modelcontextprotocol/modelcontextprotocol, with the counts and every item read. The log is published as an appendix: SPEC-SEARCH-2026-11-15.md. GitHub counts change over time, so a rerun will not match them exactly.
Data availability
We publish with this page the full study write-up, the codebook, the specification search log and the per-server codes.
| File | What it holds |
|---|---|
STUDY.md | The full write-up: frame, codebook summary, agreement, results, wrapper loss patterns, limits |
CODEBOOK.md | Codebook version 1.1 with decision rules, examples and fixes F1 to F12 |
SPEC-SEARCH-2026-11-15.md | The dated search of the specification and proposals |
data/per-server-codes-pseudonymised.csv | One row per server taken: pseudonym, eligibility, double-coded, wrapper, coarse category, every code |
data/README.md | Column definitions, what is withheld and why, how to recompute the counts |
In the per-server file each of the 119 servers taken is identified only by a random pseudonym (S001 to S119), with its codes, whether it was double-coded, whether it is a wrapper and a coarse category. Every count in the findings table can be recomputed from the rows with eligible = 1; for example C2 = 1 in 7 rows, C7 = 1 in 31, and among wrapper = 1 rows L4 = 1 in 39 of 42.
Withheld. Package names, versions, sample order, download rank and the file-and-line evidence notes are left out, because they would identify the server. The category is withheld wherever fewer than three servers would share it (13 eligible rows). Most rows still have a unique combination of codes; someone who re-reads the source of the most-downloaded packaged MCP servers and codes them with the codebook could match some rows to packages, which the file does not make easier than repeating the study. The evidence notes, the blind re-code, the extension and the adjudication record are available on request. The five audited servers are named because their audits are published.
Audit sources. Named findings are quoted from IsoKron’s published audits: GitHub MCP server (9 November 2026), Grafana and PostHog MCP servers (10 November), Kubernetes MCP server (12 November, addendum 13 November) and Payload MCP plugin (14 November).
Interests
IsoKron sells audits of MCP servers’ write paths, writes the MCP Write-Safety Requirements, and publishes the optional write-result/0.1 shape and helper kits described above. The recommendations here overlap with what that shape carries. This study did not test the shape. No server maintainer or vendor funded or reviewed this work.