mesh

A smaller AI bill.

Same answers — MESH sits in front of your LLM traffic and strips out wasted tokens without changing a single reply. You pay 1% of the savings, verified on the provider’s own usage, never our estimate.

One command · no signup · keep your own key · verify every number yourself

Install in one command.

$curl -fsSL https://www.mesh-technology.com/install.sh | sh

Then connect what you run.

Claude Code
$mesh start

Points Claude Code at MESH and runs alongside you. Ctrl+C puts Claude Code back exactly as it was.

Your own app or agent
$mesh proxy

Then set the one your app uses. Your code and your key stay the same.

ANTHROPIC_BASE_URL=http://127.0.0.1:8787 OPENAI_BASE_URL=http://127.0.0.1:8787/v1

Needs Node 22+ · no signup, no account · your key goes straight to your provider and is never stored · full setup guide

Measured savings.

45–73%

off repetitive API calls — the top of the range when they can wait a few seconds

57.7%

off background work that can wait a few extra seconds

37.6%

just from switching on Claude’s cache — many apps never do

Measured in our open test harness at the providers’ real prices, with answer quality checked on every task. Some setups save nothing — then we say it plainly: do not pay us. Every number comes with a command you can run → evidence.

Works with what you already use.

keep your own key

Point it at whatever you already use. MESH speaks Anthropic and OpenAI natively, plus anything with an OpenAI-style API — Grok, Llama, Mistral, DeepSeek and more. Full savings verification is live for Claude, GPT and DeepSeek today; other models are reduced and recorded while their price tables land. *Gemini via its OpenAI-compatible endpoint.

Watch a request lose its waste.

counts built from the sample
reducer — a busy agent’s turn 5 1102 tokens · $0.00220
{"model":"claude-sonnet-5-5",
 "tools":[ {"name":"lookup_0","description":"Look up records in subsystem 0…","input_schema":{"$schema":"http://json-schema.org/draft-07/schema#","type":"object","additionalProperties":false,"properties":{"id":{"type":"string"}}}}, …11 more verbose schemas… ],
 "system":"You are a careful assistant. Cite sources. Escalate anything risky.",
 "messages":[
   {"role":"user","content":"Step 1: inspect account 1001."},
   {"role":"assistant","content":"Records 0-19: settlement entry nominal, reconciliation standard, no notification sent, annotation routine. Records 0-19: settlement entry nominal, reconciliation standard, no notification sent, annotation routine. Records 0-19: settlement entry nominal, reconciliation standard, no notification sent, annotation routine."},
   {"role":"user","content":"Step 2: reconcile the ledger entries.
     Records 0-19: settlement entry nominal, reconciliation standard, no notification sent, annotation routine.
     Records 0-19: settlement entry nominal, reconciliation standard, no notification sent, annotation routine."},
   {"role":"tool","content":"Row 1 of 400: settlement nominal… Row 2 of 400: settlement nominal… Row 3 of 400… (397 more rows)"},
   {"role":"user","content":"Investigate account 1009 and summarise."}]}
watching… the answer cannot change — only safe moves run by default

A demonstration of the moves — token counts computed at build time from the full sample request (abridged on screen). Your real number comes from your own traffic. How we measure.

One URL. Three exchanges.

your code stays the same

First, point your client at it.

$ mesh proxy
# then one setting for your app — keep your own key
ANTHROPIC_BASE_URL=http://127.0.0.1:8787
mesh proxyrunning
MESH is running
proxy    http://127.0.0.1:8787
ledger   ~/.mesh/ledger  (hash-chained; recompute any time with: mesh verify)
connect  Anthropic clients   ANTHROPIC_BASE_URL=http://127.0.0.1:8787
         OpenAI-style        OPENAI_BASE_URL=http://127.0.0.1:8787/v1

Then run your traffic as normal.

await anthropic.messages.create({ model, system, messages })  // unchanged
~/.mesh/ledger/proxy-anthropic.jsonlhash-chained
{"seq":0,"prevHash":"000…0","event":{"requestId":"a1f2…","model":"claude-sonnet-5-5",
  "usage":{"inputTokens":1695,"outputTokens":412},"levers":[{"leverId":"duplicate-context-removal",
  "kind":"lossless","savedUsd":0.00130,"basis":"estimated-baseline"}],"status":"succeeded"}}

Last, check our maths yourself.

$ mesh verify
mesh verifyall checks passed
✓ provenance   cached runtime matches its download checksum
✓ ledger       hash-chain verified across 1 spool(s), 2 record(s)
✓ determinism  invoice recomputes identically: $0.0000 verified (do_not_charge)

The ledger is yours; this command recomputes the invoice from it with no network calls.
Output from a fresh install after two requests: nothing worth billing yet, so the verdict is do_not_charge. Savings you already had don’t count. Our losses count against us.

Proven, line by line.

Most savings claims are projections. Ours come with the receipt: we ran real requests, published every line, and the rows add up to the total — check them.

37.9%

saved by a single lever — switching Claude’s cache on — measured both ways on identical prompts, answers unchanged. The receipt beside is our latest small live run: 22.0% of real spend saved and billing on every active agent, the cache lever earning live. The full measured range is 26–73% by traffic type → evidence.

MESH — LIVE EXPORT

Second export · 2026-10-19 · claude-sonnet-5-5 · 30 requests · 5 hash chains verified

SPEND, BY AGENT

coding-agent$0.0691
rag-docqa$0.0406
batch-classifier$0.0355
support-chat$0.0522
already-lean$0.0057

VERIFIED SAVINGS, BY LEVER

coding-agent — cap + schemas, net of cache$0.0206
batch-classifier — cache stamp, earning$0.0101
rag-docqa — duplicate excerpt removed$0.0086
support-chat — tool-schema compaction$0.0054
already-lean — nothing to remove$0.0000
NET VERIFIED SAVINGS$0.0447 · 22.0%

Meet Theo, your token engineer.

Theo ships with MESH. He studies your own traffic, finds new waste to cut, and only ever tunes MESH — never your prompts, never your answers.

When he finds a saving he tells you what it is and what it might cost in quality, then waits for your yes. Anything that could touch an answer stays off until a replay of your own traffic proves it safe — and once a month he reports his own honesty: what he tried, what he saved, and where he held back.

One price.

No subscription. No seats. No minimum. You pay a slice of what MESH actually saved you — and you can recheck the maths behind every invoice yourself.

1%

of verified savings, monthly — nothing else

  • Savings counted per finished task, from your provider’s own numbers
  • Save nothing, pay nothing
  • If a move loses money, that loss is ours, not yours
  • Already efficient? Our quote will say: do not pay us
Run the quote on your own export

The catch, printed.

Can MESH break my app?
The default levers are lossless: compacted schemas decode identically, removed duplicates are exact, prefix repair reorders without deleting, and the reducer never throws — a failure returns your request untouched. Lossy levers stay off until a replay gate proves on your own recorded requests that quality held. Full answer
Why a range and not one number?
Savings depend on your traffic’s shape. The quote comes from your own export and names your segment; sometimes the verdict is literally do not pay us. The bands, by segment
How can you bill for money I didn’t spend?
The way energy performance contracts have done it since 1995: a defined baseline, provider-verbatim measurements, an agreed adjustment method. Every request writes an append-only hash-chained event; the invoice is a pure function over those events. Methodology
What do you do with my prompts?
Analysis runs locally; prompts never leave your machine. The ledger records usage numbers, lever names and hashes — not content. Your API key passes through the proxy verbatim and is never stored.
Where does MESH lose?
Busy interactive agents cap around 29% before cache enablement; already-optimised stacks get 0–5% and a do-not-pay-us verdict; a free trimmer may be all you need if you don’t need the saving verified. The honest comparison
Are these numbers real?
Every figure traces to a runnable command and a commit. The bands are simulator-measured at published provider prices and labelled so; the 22.0% receipt above is real traffic. Your pilot replaces all of it with your own number before any fee exists. Evidence

Start with one URL.

Point your app’s baseURL at MESH and keep your own key. Five minutes later you have a tamper-evident record of what you spend — and what you stopped spending. Open to everyone: no signup, no waiting list, and the source is public.

Install MESH

Stuck, or want a hand setting it up? Ask us on GitHub · Read the setup guide