> ## Documentation Index
> Fetch the complete documentation index at: https://docs.geckovision.tech/llms.txt
> Use this file to discover all available pages before exploring further.

# For API providers

> Agents are becoming a consumer of your API — and they fail it silently. Make yours the API agents find, call correctly on the first try, and keep calling as you ship.

## 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.

None of this shows up in your analytics, because failed and never-attempted agent calls
are invisible by definition. That's the trap: the pain is real, and it's unmeasured.

## What Gecko does about it

Gecko is **where agents and APIs finally speak the same language**. Point it at your OpenAPI (or your
docs — [no spec needed](/from-docs)) 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.

<Steps>
  <Step title="0. Inspect — score your agent-readiness, offline & $0 (live · self-serve)">
    Before anything else, see where you stand. `gecko inspect <your-api>` grades your API
    across four dimensions — **first-call-correct**, **spec hygiene**, **agent-friendliness**
    (ambiguous routing traps a schema linter can't see), and **security** — and prints
    located, fixable findings. Integrate it into CI (`--min-grade B`) to fail a deploy that
    regresses. It's TDD for your API.

    ```bash theme={null}
    npx @geckovision/gecko inspect <your-openapi-url>    # or a bare domain / docs URL
    ```
  </Step>

  <Step title="1. Comprehend — prove it works, offline, for $0 (live · self-serve)">
    Paste your OpenAPI URL — or [your docs](/from-docs), no spec needed — and get
    question-shaped, first-call-correct tools back, provable offline before a single live
    call. Run it yourself: `npx @geckovision/gecko <your-openapi-url>`. You
    see your own API comprehended in one session, no account, no cost.
  </Step>

  <Step title="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](/access-and-auth).
  </Step>

  <Step title="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](/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`.
  </Step>

  <Step title="4. Settle — get paid, keep 100% (optional · proven offline, live is early)">
    Charge agents per call by pointing the generated tools at **your own** x402 endpoint
    (PayAI 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.
  </Step>

  <Step title="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](/stay-correct)).
  </Step>
</Steps>

## 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.

That's the whole ask. **No production credentials, no build work on your side, no money
changing hands to start, no exclusivity.**

## 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](/cloud) — 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.

## What's live

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 now** — with the first design partners. See
[Status](/status) and [Roadmap](/roadmap) for the exact line.

## Bring your API

<CardGroup cols={2}>
  <Card title="Get the free scorecard" icon="clipboard-check" href="/quickstart">
    `npx @geckovision/gecko inspect <your-api>` — your agent-readiness grade + fixable
    findings in one session. Self-serve, offline, \$0, no account.
  </Card>

  <Card title="Self-serve it now" icon="terminal" href="/quickstart">
    Run the open-source engine against your own spec today — comprehend, serve over
    MCP, emit your agent-native surface.
  </Card>
</CardGroup>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.