The problem you can’t see from your side
Your docs are written for humans — and they work for humans. But a growing share of your integrations are now attempted by AI agents, and for them the experience is different:- Agents mis-call you. Wrong parameter, wrong endpoint, an auth scheme inferred incorrectly from prose. On your side that’s malformed requests, retry storms, rate-limit pressure, and support tickets that read “your API doesn’t work” — when really, the agent guessed wrong.
- Agents can’t find you. An agent picks the API it can discover and call correctly today. If that’s your competitor, the traffic — and the integration — goes there. You never see the loss; it just never arrives.
- Your own changes break your integrators. A renamed field that no human would miss silently breaks every downstream agent. Their 2am incident becomes your support ticket and, eventually, your churn.
- A hand-rolled MCP server goes stale. Teams that ship their own agent surface cover a handful of endpoints, then drift out of date the next time the API ships.
What Gecko does about it
Gecko is the API comprehension layer for agents. Point it at your OpenAPI (or your docs — no spec needed) and your whole surface becomes question-shaped, first-call-correct agent tools: auth handled invisibly, operations an agent can’t satisfy hidden, everything provable offline first.Bringing your API onboard — five moves
Some moves are self-serve and free today; one is a deliberate manual handshake (we don’t want your credentials flowing through a form); a couple are still hands-on while we build them toward self-serve. Each is labeled with what’s real right now.1. Comprehend — prove it works, offline, for $0 (live · self-serve)
Paste your OpenAPI URL — or your docs, no spec needed — and get
question-shaped, first-call-correct tools back, provable offline before a single live
call. Run it yourself:
uvx --from "gecko-surf[serve]" gecko <your-openapi-url>. You
see your own API comprehended in one session, no account, no cost.2. Access — the one manual handshake (seam live · manual on purpose)
Most real APIs are auth-gated, so this is the step that needs a human exchange: hand
us a sandbox key and agree the safe scope — which operations agents may call;
anything that moves money is excluded or step-up-gated, not handed to an arbitrary
agent. Gecko stores the credential as an opaque reference and injects it at call
time — the agent never sees a token. See Access & auth.
3. Serve — your surface, one add-command (live · hands-on for new partners today)
Your comprehended surface is hosted at
/{you}/mcp with the agent-native breadcrumbs
— llms.txt, gecko.json, /.well-known/gecko.json, /.well-known/x402.json — so
agents discover you, not just call you (Agent discoverability).
Your own MCP, if you have one, keeps running untouched; Gecko sits beside it. You
get one line to hand your developers: claude mcp add --transport http you https://mcp.geckovision.tech/you/mcp.4. Settle — get paid, keep 100% (optional · proven offline, live is early)
Charge agents per call by wiring the generated tools to your own x402 endpoint
(PayAI, Metera, or pay.sh). The 402 challenge, the funds, and the settlement are
yours; Gecko composes the rail, holds nothing, signs nothing, and takes no cut.
You see the full challenge→settle handshake offline first (
X402_MODE=stub) before
any real money moves; on-chain settlement is proven on devnet, and any mainnet
transaction is run by you, never by us.5. Stay correct — drift-watch (Cloud — building)
Drift-watch re-comprehends your API when you ship and regenerates the tools, so your
next release doesn’t silently break downstream agents — the alert fires before their
prod does. The surface fingerprint that makes this tractable exists today; the
auto-update loop and the adoption dashboard are designed for V2, not yet shipped
(Stay correct).
What we need from you
To take a real API from comprehended to a live, measured surface:- A sandbox / test API key (+ the sandbox base URL) — unlocks the gated operations and keeps calls off production.
- Your current OpenAPI spec (or confirmation the docs URL is current) — so the surface reflects today’s API, and drift is measured against a real baseline.
- The safe scope — which operations agents may call; what to exclude or step-up-gate (anything that moves money).
- Distribution — put the add-command in front of your developers. Gecko measures the funnel (who connected, called, came back); it doesn’t create the traffic.
Who pays, in one sentence
The engine is free forever for builders; API providers pay a flat per-API subscription for hosted, drift-watched, agent-ready surfaces.Flat fee. Never a percentage of your revenue, never a cut of what agents pay you, never a public catalog listing you didn’t ask for. Illustrative shape on the Cloud page — prices land when Cloud ships.
Why this is measurable (unlike docs spend)
Human-docs spend is famously unattributable. Agent comprehension isn’t: a first-call-correct fix turns a failed call into a completed one — and if your API is x402-metered, into a settled one. The delta is visible per API revision. That’s the difference between a cost center and an ROI line.Honest status
The comprehension engine, the scorecard, discoverability artifacts, and the free self-serve flow are live today. Drift-watch, access analytics, and the hosted provider plane are building — with the first design partners, now. See Status and Roadmap for the exact line.Bring your API
Get the free scorecard
Join the Discord and drop your OpenAPI URL — we’ll run the comprehension scorecard
on your API and show you what agents see.
Self-serve it now
Run the open-source engine against your own spec today — comprehend, serve over
MCP, emit your agent-native surface.