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 22+
Release
v0.1.2, on npm

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 the definitions alone are about 0.1% of a 1M 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.2 · 2026-08-03 13:57 UTC

1,120

o200k tokens of tool definitions from one MCP server, resident on every request. About 0.1% of a 1M 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 ->

And for a loadout One server is the unit, not the bill. The 8 servers in this loadout come to 42,959 tokens across 113 tools, about 4.3% of a 1M window, and 79% of that is two of them. Tool count does not predict the bill: the same 24 tools cost 17,218 on @notionhq/notion-mcp-server and 3,453 on @playwright/mcp. 2026-07-18 09:22 UTC

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 13 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, live
  • efaimo check --mcp

    Does this survive July 28?

    Grades description quality and annotation hygiene, then prints 2026-07-28 readiness separately as a migration diff, not graded. Every rule names the SEP it came from.

    mcp v0.1, live
  • 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.1, live
  • 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 v0.1, live
  • 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 quoted · live runs 2026-07-17 · claude-sonnet-5
    skills v0.1, experimental

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

July 28, 2026

The protocol
goes stateless.

The specification that published 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
5 removed
5 added
2 deprecated
1 moved
The major changes, each 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 ->

FAQ

Plain questions,
checkable answers.

Nothing below is new: every answer restates something this site already says. An engine that quotes this section quotes the site.

  • What is efaimo?

    efaimo (pronounced eh-fai-mo; Korean: 에파이모) is an open source CLI, Apache 2.0, that measures what MCP (Model Context Protocol) servers and agent skills cost in context tokens, and checks MCP servers against the stateless specification that published on July 28, 2026. efaimo ai is the brand and this site; efaimo is the CLI the brand ships; weigh, check (MCP or skill), test and mcp are its commands.

  • Can I install it today?

    Yes. npx efaimo runs v0.1.2 straight from npm, npm i -D efaimo pins it, and the source is public at github.com/efaimo-ai/efaimo under Apache 2.0. This answer said not yet until 2026-07-18; the gates opened and it changed with them.

  • Does efaimo send data anywhere?

    No. The CLI runs on your machine and talks only to the servers and files you point it at and, for live test runs, to the model APIs you configure with your own keys. It sends nothing to us: no telemetry, no crash reports, no phoning home. This site runs two page counters, a cookieless Cloudflare beacon and Google Analytics with every ads signal off; the privacy page spells out exactly what they see.

  • Where do the numbers on this site come from?

    From one committed run of efaimo weigh against the official MCP reference server, dated 2026-08-03, plus captured command runs printed exactly as they ran. Every figure is computed from that run at build time, and the build fails if a caption stops explaining its own number.

  • What happened on July 28?

    The MCP specification went stateless: the final revision published on July 28, 2026, and the spec calls it a breaking change in its own words. Nothing broke that day; the same release adopts a minimum twelve-month deprecation window. efaimo check --mcp reports where a server stands against it.

It shipped.
Check it.

v0.1.2 is on npm: npx efaimo runs it today. The source is public at github.com/efaimo-ai/efaimo, Apache 2.0. The package is published with provenance, so npm will tell you which commit in that repo built the tarball you install. You can verify all three of those sentences in under a minute, which is still the point.

Read the source -> Read the method