Updated 3 Oct 2026 · measured 2 Oct 2026
On our Hermes Agent v0.21.0 install (the default toolset of 31 tools, 97 skills, built-in memory), about 15,200 tokens ride along with every API call before your task starts. Tool schemas were about two thirds of that fixed overhead, followed by the system prompt, the skills index, and memory.
This week: run hermes prompt-size, turn off the toolsets you never call with hermes tools, then run it again and compare.
Definition
Scope: this is the token-component reference only, no dollar figures. For cost per useful run, the bill drivers, and the keep, migrate, or retire decision, see the Hermes Agent cost breakdown.
Fixed overhead is everything Hermes sends to the model on every API call before your request: the JSON schemas of every enabled tool, the system prompt, the skills index, and your memory and user profile. It repeats on every call, so a task that takes six calls pays it six times.
The opposite is task-specific work: your message, the tool results, and the model's replies. That is the part you are paying to get.
What this page reports, and does not: one test install, 3 runs per task, three small synthetic tasks, one model. The component split is an estimate from character counts, not a provider-reported figure. Treat it as one measured data point, then check your own install.
The split
Tool schemas lead by a wide margin. On our v0.21.0 test install, the 31 tool schemas were about 10,200 of the roughly 15,200 fixed tokens on each call.
The fixed prefix on this install is 15,169 tokens per call: 15,175 provider-reported input tokens on the first run of the one-word hello, minus about 6 for the prompt. The component shares are character-count estimates of that total, so the table sums to 15,168 after rounding.
Hermes sends the schema of every enabled tool on every call, whether the run uses that tool or not. A one-word hello that used no tools still sent 15,175 input tokens.
See the methodSwipe the table sideways for more columns.
| Component | Share | Est. tokens | Characters |
|---|---|---|---|
| Tool schemas (31 tools) | 67.0% | 10,159 | 51,168 |
| System prompt, without skills index and memory | 16.6% | 2,520 | 12,695 |
| Skills index (97 skills) | 12.3% | 1,861 | 9,375 |
| Memory and user profile | 4.1% | 628 | 3,163 |
| Fixed prefix | 100% | 15,168 | 76,401 |
The mechanism is vendor-documented. Anthropic's tool-use pricing documentation states that input-token pricing includes the tools parameter: the names, descriptions, and schemas of every tool in the request.
Per task
Hermes pays the fixed overhead per API call, so the number of calls drives the input bill more than the length of your prompt. Three tasks, three rounds each:
| Task | Fixed share of input | Input tokens, median (range) | API calls | Output tokens | Served from cache |
|---|---|---|---|---|---|
| T1: "Say hello in one word." | 99.96% | 15,175 (all 3 runs) | 1, 1, 1 | 5 | Run 1: 0%. Runs 2 and 3: 97.8% |
| T2: run one terminal command (date -u) | 99.7% | 30,436 (30,436 to 30,440) | 2, 2, 2 | 40 to 44 | 48.8% |
| T3: create a file, read it, append a line, read it again | 86.1% (86.1 to 97.6%) | 52,841 (52,841 to 93,274) | 3, 6, 3 | 202 to 239 | 62.0%, 95.5%, 62.0% |
The same T3 prompt took 3 calls in two rounds and 6 in the third. The 6-call run sent 93,274 input tokens instead of 52,841, and its fixed share rose from 86.1% to 97.6%. The model chose the extra steps; the task did not change.
Prompt caching helped, but it did not remove the overhead. On repeat runs the provider served 97.8% of the one-call prefix from cache. Cached tokens are still input tokens, and how they are billed depends on your provider.
Method
Setup. Our own test install of Hermes Agent v0.21.0 (release 2026.8.31), installed from git, on Linux:
Commands. Each run was one scripted call, from an empty scratch directory with no context files:
# one run: final answer on stdout, token report in a JSON file HERMES_DUMP_REQUESTS=true hermes -z "Say hello in one word." \ --usage-file usage-T1-R1.json # offline byte breakdown of the fixed prefix (no API call) hermes prompt-size --json
Token counts. The usage file reports provider-side input, output, cache read, and cache write tokens per run. Its input_tokens excludes cache reads, so input in the per-task table means input plus cache read plus cache write. Cache write was 0 on every run.
Component split. The provider reports one total, not a split. We took the character counts of each block from a request dump (HERMES_DUMP_REQUESTS) and from hermes prompt-size, then scaled them to the provider total of the first, cold, one-word run: 15,175 input tokens, minus about 6 for the prompt, gives about 15,169 fixed tokens. This assumes JSON schemas and prose use the same tokens per character.
Limits.
Command reference: the Hermes CLI commands documentation covers hermes -z, --usage-file, hermes prompt-size, and hermes tools.
Comparison
Issue #4379 measured Hermes v0.6.0 in April 2026: 6 request dumps from a deployment running Telegram, WhatsApp, and cron gateways, on claude-sonnet-4-5 via OpenRouter. It found about 13,900 fixed tokens per call, 73% of an average request. It is the older comparison point, and it holds for its setup.
Our 86% is not a correction of that figure. The model, the version, and the workload all differ. Their requests carried real conversation history, while ours are three short synthetic tasks, which pushes our fixed share toward the high end.
| Measure | Issue #4379 | Our trace |
|---|---|---|
| Hermes version, date | v0.6.0, April 2026 | v0.21.0, 2 Oct 2026 |
| Model and provider | claude-sonnet-4-5 via OpenRouter | gpt-6-luna via openai-codex |
| Workload | 6 request dumps from live gateway traffic | 9 runs of 3 synthetic tasks |
| Tool schemas | 31 tools, 8,759 tokens: about 63% of the fixed prefix (46.1% of the whole request) | 31 tools, about 10,200 tokens (67% of the fixed prefix, estimated) |
| Fixed tokens per call | about 13,900 | about 15,200 |
| Fixed share of input | 73% (average request) | 86.1% (3-call task, median); 99.96% (one-word hello) |
By component
For each part: what it is, what inflates it, where to read it on your install, and the lever that moves it.
The JSON schema of every enabled tool: its name, description, and parameters. Hermes sends all of them on every call, whether the run uses a tool or not.
Grows withMore toolsets enabled, more MCP servers, and longer tool descriptions. On our install, the browser toolset (10 tools) and computer use (1 tool) made up about a quarter of the tool schema bytes.
Measurehermes prompt-size --json: the tool schema bytes and the per-toolset breakdown.
LeverTurn off toolsets a platform never uses with hermes tools. This is the largest lever.
Identity and guidance text, plus context files such as AGENTS.md from the directory you start Hermes in.
Grows withLong SOUL.md or AGENTS.md files, and stray context files in the working directory.
Measurehermes prompt-size: the system prompt total and its stable, context, and volatile tiers.
LeverKeep context files short, and start Hermes from a directory without files it does not need.
The list of installed skills, placed in the system prompt so the model knows what it can load.
Grows withEvery installed skill. Our install had 97 skills and a 9,375-character index.
Measurehermes prompt-size: the skills index line.
LeverUninstall skills you do not use with hermes skills.
Your MEMORY.md and USER.md snapshots, sent with every call.
Grows withEntries that pile up and never get pruned.
Measurehermes prompt-size: the memory and user profile lines.
LeverPrune stale entries.
Check yours
Run hermes prompt-size for the offline byte breakdown by block. Then run hermes -z with a short prompt and --usage-file, and add input_tokens, cache_read_tokens and cache_write_tokens from the report. That sum is close to your fixed overhead per call.
# 1. offline breakdown: system prompt, skills index, memory, tool schemas hermes prompt-size # 2. one measured call for the token count hermes -z "Say hello in one word." --usage-file usage.json
hermes prompt-size reports bytes and characters, not tokens, so use the measured call for the token count. We checked that sum on the openai-codex provider only.
To cut it, start with tools. Turn off the toolsets you do not use with hermes tools, then re-run both checks and compare.
Tool Search, the opt-in deferral layer in Hermes, did not shrink this prefix. In v0.21.0, built-in tools always load and only MCP and plugin tools defer. The current Tool Search documentation also lets some cold built-ins, such as computer_use and session_search, defer. Our install had no MCP servers. We did not measure a trimmed install in this trace.
For cost per useful run, the bill drivers, and the keep, migrate, or retire decision, see the Hermes Agent cost breakdown.
Questions
Tool schemas. On our Hermes v0.21.0 test install (31 tools, measured 2 October 2026), tool schemas were about 10,200 of the roughly 15,200 fixed tokens sent on every API call, about 67 percent, estimated by character share. Issue #4379 found the same order on v0.6.0, where tool definitions were 46.1 percent of an average request.
Yes. Hermes sends the schema of every enabled tool on every call. In our trace, a one-word hello that used no tools still sent 15,175 input tokens to get 5 output tokens back.
Run hermes prompt-size for the offline byte breakdown by block. Then run hermes -z with a short prompt and --usage-file, and add input_tokens, cache_read_tokens and cache_write_tokens from the report. That sum is close to your fixed overhead per call.
No. Your message, the tool results, and the model's replies change with each task, so they are not overhead. On our 3-call file task they were about 14 percent of input tokens. The other 86 percent was the fixed prefix, sent three times.
It is accurate for its setup: Hermes v0.6.0, claude-sonnet-4-5 via OpenRouter, and 6 request dumps from live gateway traffic. Our v0.21.0 trace found 86 percent on a 3-call task, but the model, the version, and the workload differ, so the two numbers are not directly comparable.
No. Caching changes how the prefix is processed and billed, not whether it is sent. On repeat runs in our trace, the provider served 97.8 percent of the one-call prefix from cache, and those tokens still counted as input.