Open source · MCP and agent skills

Know what you feed your agent.

Every MCP server and every skill you install is loaded into the context window before you type a word, and you pay for it on every request after that. efaimo measures what it costs and audits what you got for it, from your terminal, against your real config.

See a real measurement Why July 28 matters
License
Apache 2.0
Runtime
Node 20+
Target
v0.1, Jul 24

1,062 dots · 13 tools · one MCP server

One dot per token, measured off the official MCP reference server. That is what it puts in your context before you type a word. The bright cluster is gzip-file-as-resource, its heaviest tool, at 202 of them. It condenses into the 13 things you installed and disperses into the one mass the model receives. Both are the same measurement.

The cost

You are paying for tools
you never called.

Every tool definition goes to the model on every request, called or not. That is a budget, and a budget nobody reads is not a budget. Here is one, read.

One request, replayed
server instructions · 312 13 tool definitions · 1,062 tokens; the seams between the blocks are the 58 of markup that join them your message

server instructions · 312

13 tool definitions · 1,062 tokens; the seams between the blocks are the 58 of markup that join them

the dashed block is your message, typed after all of it

The bright block is gzip-file-as-resource, 202 tokens, the same tool the hero clusters around. The message clears between requests; the rest does not, and it is about 0.6% of a 200k window, magnified here. Widths are the committed run; only the message is not to scale, because that part is yours.

The answer, for one server efaimo v0.1.0 · 2026-07-17 04:26 UTC

1,120

o200k tokens of tool definitions from one MCP server, resident on every request. About 0.6% of a 200k window before you type a word.

same 13 tools, three serializations

Claude-style 1,120
OpenAI tools 1,142
raw JSON 1,607

Per-tool bars, the 58 token gap between the parts and the whole, and why you cannot add a column of token counts: the full accounting is one page deep.

The full accounting ->

The tool

Five commands.
One question each.

A CLI and nothing else: no account, no hosted service, no daemon. It reads what you already have and prints what it found. All five exist today.

Where it sits one wire, read instead of trusted
YOUR MACHINE THE PROVIDER @modelcontextprotocol/ server-everything 13 tools · measured your second server your agent skills YOUR HOST 312 1,062 across 13 yours 1,062 +58 seams = 1,120 you the model any provider measured, from the run yours, unmeasured here efaimo weigh -> 1,120 o200k estimated · read off the same wire tools/list · definitions the request, every request

Drafted from the run everything here derives from: the strip's inner seams sit at the thirteen tools' true cumulative positions, and the dimension line under it does the only addition the tokenizer permits. The instrument reads the wire that was already there.

  • efaimo weigh

    What does this cost me?

    Counts the tokens a server or a skill adds to your context, reproducing the way your host actually serializes it. Point it at a stdio command, a URL, a repo, a skill folder, or a whole installed client config.

    mcp + skills v0.1, Jul 24
  • efaimo check --mcp

    Does this survive July 28?

    Runs a server against the 2026-07-28 specification, then against description quality and annotation hygiene. Every rule names the SEP it came from.

    mcp v0.1, Jul 24
  • efaimo check --skill

    Is this skill worth loading?

    Frontmatter schema, trigger collisions across everything you have installed, token budget, reference integrity, injection patterns.

    skills v0.2
  • efaimo mcp

    And when your agent is the one asking?

    A read-only MCP server over efaimo itself: efaimo_check_skill and efaimo_weigh_skill, files only, nothing that spends money. It is graded by its own check --mcp like any other server.

    mcp built, in repo
  • efaimo test

    Did the skill actually help?

    Runs the same task with the skill and without it, then reports the delta. In its first live runs one skill moved a task from 0/8 to 8/8 and another moved nothing, and both lint clean, which is the point.

    +0 8/8 with · 8/8 without +100 8/8 with · 0/8 without
    skills first live runs

Real runs, the self-audit, and the first test deltas ->

July 28, 2026

The protocol
goes stateless.

The specification that publishes on July 28 removes sessions and initialization outright. It is a breaking change in the spec's own words, with a twelve month window to move.

2025-11-25
2026-05-21
2026-07-28
2027-07-28
4 removed
5 added
2 deprecated
1 moved
Every change, linked to its pull request ->

Method

A number you cannot defend
is worse than no number.

reproducelabelcitedogfood

The measurements are the product, so the method is the warranty. This site holds itself to it: every figure here is computed from one committed run, and the build fails if a caption stops explaining its own number.

How the numbers are made ->

Nothing here
has shipped.

The npm name efaimo is unclaimed. The GitHub org is empty. v0.1 targets July 24, four days before the specification it checks. You can verify all three of those sentences in under a minute, which is more or less the point.

Watch on GitHub -> Read the method