Why obfus.link

1 — Lean by design (the context problem everyone hit)

Traditional MCP servers front-load every tool definition into the model's context on connect — so the agent pays that tax on every turn, before it does anything. That bloat is why so many teams cooled on MCP. obfus.link lists only search_utility_grid by default; the other 31 tools are discovered on demand and called by name (the server runs them whether or not they were in tools/list).

That is the same progressive-disclosure pattern as Anthropic's Tool Search Tool. Resident tool context scales O(1) with the grid instead of O(n) — add tools without growing the per-turn cost. Strict clients that can only call listed tools opt back into the full set with the X-Obfus-Toolset: full header.

RUN IT YOURSELFnode bench/context-test.mjs— headline is a measured ratio; absolute counts are a estimate (bytes/4) label

2 — Deterministic, not generative

Ask a model to base64-encode a string, write a Zod schema, repair JSON, or compute an HMAC and it generates the answer — variable run-to-run, sometimes invalid, billed in output tokens. A deterministic tool returns the one correct answer by construction: byte-identical every call, cacheable, testable, auditable.

We call each tool repeatedly through the live MCP and confirm the output hash is identical: 10 of 10 sampled tools were byte-identical across 4 runs, and the full core suite has a determinism assertion per tool (854 tests passing). We are also honest about the exceptions — 2 tools are intentionally non-deterministic and excluded by design:

• uuid_generator — generates random/time-based UUIDs by design
• link_obfuscator — creates a unique AES-encrypted short link + DB record per call

RUN IT YOURSELFnode bench/determinism-test.mjs— measured against the live MCP

3 — Machine-payable (MPP), so it stays alive

Free MCP servers get abandoned. obfus.link is built to be paid by agents directly. Exhaust the free tier and a call returns HTTP 402 Payment Required with a machine-readable challenge: a payment_intent_url, the exact unit_price_micros, and a publishable key. The agent buys a token at /api/agent-checkout and continues — no human in the loop.

• 50 free calls per IP across the whole grid — enough to evaluate before paying.
• Discovery is free forever — search_utility_grid never bills.
• Failures are not billed — a rejected or malformed call does not move your meter.

See the pricing page for the full per-tier breakdown and the MCP docs to add the endpoint to your agent.

4 — Why the tools cost money (and why that is cheap)

A tool call is $0.008–$0.025. It replaces three costs at once: the output tokens a model would spend generating the same artifact, the retries when that output fails validation, and the per-turn context tax (the ~97.9% above).

Illustrative (arithmetic on published Claude list prices — input/output per 1M tokens: Opus 4.8 $5/$25, Sonnet 4.6 $3/$15, Haiku 4.5 $1/$5; prices change): repairing a malformed ~2,000-token LLM JSON blob means reading it in and writing the cleaned version out. On Opus 4.8 that is roughly 2k×$5/1M + 2k×$25/1M ≈ $0.06 per attempt — and non-deterministic repair often needs a second pass, which doubles it. The deterministic llm_to_json_cleaner is one $0.025 call, valid the first time.

The honest caveat: on a cheap model doing a trivial transform, raw token cost can be lower than the tool price. There you are not buying token savings — you are buying determinism (zero retries, byte-identical, cacheable) and the lean context. The core logic is simple; you could self-host the commodity tools. What you pay for is hosted, tested, hardened, machine-payable, lean infrastructure you do not have to run.

Where it fits in your stack

Everyone is stacking harnesses, loops, skills, and connectors — all of which make the model reason and act better. Deterministic tools do the opposite: they remove the mechanical step from the model entirely. They complement whatever you already run.

• vs a Skill: a skill teaches the model how; it still generates (variable, billable). A tool returns the one correct answer. Use skills for judgment, tools for the mechanical steps in between.
• In your browser: every tool also runs as a free in-browser dev utility — no agent, no account, no install. The grid is an agentic infrastructure project and a suite of hand tools.
• Local coding agents: deterministic transforms without bloating your editor agent's context.
• CI/CD: reproducible by definition — generate schemas, validate .env before deploy, hash/verify artifacts. CI wants the same output every run.
• Multi-agent pipelines: tool calls as reliable contracts between agents.

Don't take our word for it

Every number on this page comes from a script you can run. Context and determinism are measured; the cost comparison is a clearly-labeled estimate from public prices. Clone the repo and run node bench/context-test.mjs and node bench/determinism-test.mjs against your own MCP connection. If you can reproduce it, you can trust it.

Ready? Add obfus.link to your agent or browse the 31 tools.