400 commands cost 9,989 tokens. 400 agents cost 20,404.
A plugin is not one thing, and its parts are not priced alike. Skills and slash commands both cost about 40 tokens each and then collapse to under 6 once you pass a few hundred. Subagent definitions cost 51 each and never get cheaper, at any count measured up to 400.
Correction, 2026-08-21. The two figures in this post’s title were wrong, and the reason matters more than the numbers do. Every cumulative cell here is bimodal: a 198-token intermittent component either fires on a call or does not, so four rounds land two-two, and the median that summarised them returned the midpoint of the two modes. That midpoint is a value no round produced and the machine cannot emit. The title said 10,088 and 20,503; nothing ever measured either. The values are 9,989 and 20,404, or exactly 198 higher in the rounds where the component fires. The re-verification note at the foot of this post identified the split on 2026-08-14 and printed the corrected values, and then the wrong ones were left standing in the title, in both tables, in the receipts and on three summary pages elsewhere on this site. Diagnosing a defect is not the same as removing it. The estimator here is now the site’s guarded mode, which refuses a tied cell instead of averaging across it, and the assembler that produced the midpoints has been rewritten so it cannot produce one again. The URL still carries the old figures, and it keeps them.
The advice circulating about plugin bloat is specific enough to check. One widely shared write-up puts it at “approximately 100 words of metadata each”, arriving at “With 30 plugins, that is roughly 3,000 tokens of overhead”, and recommends “keeping 4-6 active plugins maximum”. Note that its own arithmetic treats one word as one token, and English runs closer to 1.3 tokens a word, so the figure is already low before anything is measured. A closed Claude Code issue, #49170, reports a configuration of 17 plugins and skills “consuming ~35% of context window”.
None of that is in a vendor doc, so the only way to settle it is to run it. And the first thing running it shows is that the question is malformed: a plugin is not one thing. It ships skills, slash commands, subagent definitions and MCP servers, and those are priced differently enough that a per-plugin average is close to meaningless.
Three parts, three curves
Each measured on its own on a clean project, in isolation, against a floor re-measured every round.
| Count | Slash commands | Subagent definitions |
|---|---|---|
| 10 | 404 | 514 |
| 50 | 2,004 | 2,554 |
| 200 | 8,004 | 10,204 |
| 400 | 9,989 | 20,404 |
| 800 | 12,237 |
Each of those cells also occurs 198 tokens higher, in the rounds where the intermittent component fires. The figure quoted is the component-free one: 2.1.232 measured every cell in this table with zero spread at exactly these values across all four of its rounds.
Read as the marginal cost of one more:
| Between | Command | Agent |
|---|---|---|
| 10 → 50 | 40.0 | not resolved, 46–56 |
| 50 → 200 | 40.0 | not resolved, 51.0–52.3 |
| 200 → 400 | 9.9 | 51.0 |
| 400 → 800 | 5.6 |
These are paired inside each round: the same round’s adjacent cell is subtracted, so a component that fired in both cancels instead of being carried into the difference.
A slash command costs about 40 tokens, which is what a skill costs, and it collapses in the same place, between 200 and 400, falling to 9.9 there and to 5.6 by 800. A subagent definition costs 51.0 tokens between 200 and 400, in all four rounds on 2.1.231 and in six of eight on 2.1.238. Below 200 the estimator refuses a single figure, because a 198-token component divided across fifty items or fewer dominates the signal, but every value observed at those steps falls between 46 and 56. There is no collapse anywhere in the agent column and no sign of one starting.
The 0-to-10 band is not quoted for either column, and neither are the two agent steps below 200. At ten items the whole signal is about 500 tokens and a single 198-token intermittent component is nearly two fifths of it, with a 396-token spread across rounds. The rule applied throughout is that a step is quoted only where the estimator returns a supported figure on both releases.
That is the finding. Two of the three things a plugin ships get dramatically cheaper in bulk. The third does not, at any count measured.
Which is why 400 agents cost twice what 400 commands do
9,989 against 20,404, measured in the same rounds against the same floors, a ratio of 2.04. Against the ladder block’s floor of 22,375, that is 45% of a clean startup context for the commands and 91% of it for the agents, paid again before anything happens.
Nobody has 400 agents. The point is the shape: if you are pruning configuration on the theory that quantity is what costs you, quantity is the wrong axis for two of the three things you would prune, and the right axis for the one people rarely look at.
What actually changes the price of a skill
The same fixtures answer a question this site published unexplained yesterday. A machine with its own configuration loaded charges 3.8 tokens per skill where a clean project charges 39, and counting that machine’s skills refuted the obvious explanation: it loads 65, well inside the expensive range.
So: add one element at a time, and re-measure the cost of forty skills beside it.
| Forty skills, measured beside | Tokens each | Population |
|---|---|---|
| nothing | 39.2 | floor-paired, 8 runs |
| 200 slash commands | 25.7 | cell-to-cell |
| 200 subagent definitions | 39.0 | cell-to-cell |
| 50 subagent definitions | 39.0 | cell-to-cell |
| a 72,783-byte CLAUDE.md | 39.0 | cell-to-cell |
The three null arms land on 39.0, measured here, against a clean arm of 39.2 also measured here. Only the commands arm moves.
The 200-agent row is there because the first pass did not have it, and without it the comparison was worth little: it conditioned on 200 commands but only 50 agents, a quarter of the weight, and below the entry count where the effect shows up at all. At 240 combined entries either way, the two arms separate. Every round of the commands arm (828, 1026, 1026, 1026) falls below every round of the agents arm (1039, 1560, 1560, 1758), so the arms do not overlap, but the nearest pair is only 13 tokens apart, which is far inside the 198-token intermittent component documented below. The claim rests on the declared estimator rather than on that margin: modes of 1,026 against 1,560, a gap of 534.
That cell is also the clearest argument in this corpus for running four rounds before writing anything. Its first round came in at 1,039, which is 26.0 tokens a skill and would have reversed the finding. The other three are 1,560, 1,560 and 1,758.
On populations. The four element rows are each one treatment cell minus another in the same round, never touching the floor. Three have a round-to-round spread of 198 tokens; the 200-agent row has 719, from the outlier round above. The baseline row cannot avoid the floor, since there is no second cell to subtract from it, and its spread across all eight published runs is 917. So the 39.2 against 25.7 comparison crosses populations by construction. The one that does not is commands against agents, both cell-to-cell.
What it means for yesterday’s question, precisely. That machine ships 65 skills and 82 commands on disk, so the denominator is at least 147 rather than 65, plus 7 subagent definitions that this result says do not count toward it. But 147 counts only what is on disk: Claude Code’s own built-in commands and agents are not counted and are not measurable from disk, so 147 is a floor and the true entry count is higher by an unknown amount. The transition is bracketed rather than located, and at 147 the clean curve predicts no discount at all while the machine measures the fully collapsed 3.8. This raises the denominator without yet producing the effect. It is a lead, not an answer.
So what does a plugin cost
There is no single answer, and that is the finding rather than a dodge.
A plugin’s price is the sum of its parts at whatever rate your setup is currently paying. Two plugins sitting side by side on a marketplace can differ by an order of magnitude: one shipping fourteen skills is fourteen listing entries, one shipping a language server is zero entries on the axis measured here. Four of the ten plugins installed on the machine used for these runs ship no skills, commands or agents at all. Three of those four contain nothing but a README and a language-server entry; the fourth ships an MCP server, which this site prices separately and which is not on this axis either.
So “4 to 6 plugins maximum” is a rule about the wrong quantity. Six skill-heavy plugins can carry more listing entries than twenty thin ones. Count items, not plugins, and count your subagent definitions separately because they are the ones that never get cheaper.
I am deliberately not converting that into a per-plugin token total. Doing it honestly needs three things this measurement does not have: the rates here are measured at 90-character descriptions while the real skills on that machine average 397, which pushes the per-item price up; the machine itself is already in the collapsed regime, which pushes it down; and no plugin was installed in any of these 88 runs, since the isolation flag that makes them clean is the same flag that keeps plugins out, so any per-plugin overhead beyond the per-item rates is unmeasured here. Two large corrections in opposite directions and one unmeasured term is not a number worth printing, and I am not going to say which way it nets out.
What this does not settle
The 35% claim is not adjudicated. Issue #49170 reports a whole real configuration, including skill bodies, MCP servers and everything else a session loads. This measurement prices listing entries on a clean project and cannot reach it in either direction.
Every figure here is a clean-project rate, and they do not transfer. The same forty skills that cost 1,558 tokens in isolation cost 152 on a machine with its own configuration loaded. So the ladders, and the 45% and 92% above, are what these things cost from an empty start. On a configured machine the two that collapse will already have collapsed. Whether a subagent definition still costs 51 there is untested.
The conditioning effect is measured at one count. Both conditioning arms sit at 200 of the element. Nothing here measures the skill price beside 20 commands or beside 800.
The agents ladder stops at 400. The commands ladder runs to 800, twice past its collapse point. “Agents never collapse” is established to 400 and not beyond.
No mechanism. This shows commands move the skill price and agents and CLAUDE.md do not. It does not show what the listing does internally, that a single shared budget exists, or how it is accounted.
CLAUDE.md density is content-dependent, and the calculator has one constant for it. 72,783 bytes of prose measured 0.2844 tokens per byte here, against the 0.26 this site publishes and the 0.368 it measured on a real user-level file. The rate belongs to the text, not the file, and no single constant is right for all three. That is a live weakness in the calculator and it is now stated there too.
The version is certain at the start of the session and not at the end. Claude Code read 2.1.231 when these runs began and 2.1.232 an hour later, so it updated itself in between, and none of the harnesses recorded a version per run at the time. The first 72 runs finished within four minutes of the start and are 2.1.231; the 16 size-matched runs finished later and cannot be pinned from the data. Every harness now records the version, and this corpus will be re-run in full on 2.1.232 rather than have the ambiguity argued away.
One machine, one model, one description shape. Opus, project-scope fixtures, every description 90 characters of ordinary English.
Controls
Element arrival, per element. Each element was measured alone against the floor before being used as a condition: 200 commands moved it by 8,010, 200 agents by 10,210, and 50 agents by 2,560. An element that failed to move the floor never loaded and could not condition anything.
A known-answer positive control. The CLAUDE.md arm has a predicted value from this site’s own published rate: 106 tokens plus 0.26 a byte puts 72,783 bytes near 19,000. It measured 20,699, 8.8% high, and that gap is reported above as a finding rather than smoothed away.
The ladders assert their own variable. Both read the file count back off disk each run and require it to equal the requested count, so a ladder that quietly stopped scaling fails instead of publishing a flat curve.
Two populations, labelled everywhere. Floor-paired and cell-to-cell figures are named individually in the corpus and in the prose. Where a comparison has to cross them, as the baseline row does, the post says so, and the finding is carried on the size-matched pair that does not.
Two intermittent components. A 198-token and a 521-token component each fire on some calls and not others. The estimator is the site’s guarded mode, which refuses a cell where nothing repeated or the top count is tied. It replaced a median on 2026-08-21, for the reason given in the correction at the top.
Non-overlap asserted in code. The assembler refuses to build the corpus unless every round of the commands arm falls below every round of the size-matched agents arm, so the claim cannot survive data that stops supporting it.
Arrival, 88 of 88. Every reply had to be exactly OK. No exclusions, all 88 runs scored. Isolation asserted onto the command line on every call.
Every run is published in plugin-parts-2-1-231.json.
Re-verified 2026-08-14 against Claude Code 2.1.232, and the version ambiguity above is resolved. The whole measurement was re-run on the current release, sequentially, with every harness recording the version it ran against. Every point either reproduced exactly or came in 99 tokens lower, which is half of the 198-token intermittent component documented above: a two-two split whose median landed on the other side. 400 commands measured 9,989 against 10,088; 400 subagent definitions measured 20,404 against 20,503. The marginal rates are unchanged to a tenth (40.0 and 51.0 against 40.7 and 51.7), and the ablation reproduced to the decimal: 25.7 tokens per skill beside 200 commands, 39.0 beside 200 agents, 39.0 beside 50 agents, 39.0 beside a 72,783-byte CLAUDE.md. Every run: plugin-parts-2-1-232.json.
Re-verified 2026-08-21 against Claude Code 2.1.238, at eight rounds instead of four. The ladders were re-run to settle whether the two-two splits were resolvable, and they are not: three cumulative cells came back tied four-four between values exactly 198 apart. That is what a near coin flip looks like, and it means more rounds is the wrong instrument for this shape rather than a slower route to the same answer. Those cells are published as two values and their counts, not as one number. The marginal rates do resolve, because they are paired inside each round and a component that fired in both cells cancels rather than being carried into the difference: a slash command costs 40.0 tokens between 50 and 200, 9.93 between 200 and 400 and 5.62 between 400 and 800, and a subagent definition costs 51.0 between 200 and 400 in six rounds of eight. Every claim this post rests on reproduces seven releases later. Every run: plugin-ladder-8x-2-1-238.json.