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

# Gecko 101

> Your agent tries the call before it makes it. One URL, no install, no key — and a receipt before anything is signed.

## The problem

Your agent's first call is the real one. There is no rehearsal.

A wrong call that errors is the cheap failure. You find out.

The expensive one is quiet. Well-formed, accepted, nothing throws — and the world is now
wrong. Nobody gets an alert for a call that worked and was wrong.

## Watch it run

Ten questions, four programs, one landed transaction. Every command real, one take.

<video autoPlay muted loop playsInline controls className="w-full aspect-video rounded-xl" src="https://mintcdn.com/gecko-d0bce12a/-uR_A6N66TKVZQ4z/assets/gecko-101.mp4?fit=max&auto=format&n=-uR_A6N66TKVZQ4z&q=85&s=00ffee1883237ce6000db12428b12ffe" data-path="assets/gecko-101.mp4" />

## What Gecko is

Gecko reads an API — its spec, its docs, or for a Solana program its IDL and source — and
turns it into tools your agent calls correctly the first time, every fact tagged with
where it came from.

For anything that costs money, it runs the call somewhere that doesn't count first and
hands back a **receipt**. Then someone else signs.

<Note>
  Gecko is not the agent. It holds no key, signs nothing, broadcasts nothing.
</Note>

## Your first call

No install, no account, no key, no spend.

```bash theme={null}
claude mcp add --transport http gecko https://mcp.geckovision.tech/pegana/mcp
```

Ask, in plain words:

```
Is USDC still pegged right now?
```

```
USDC   PEGGED   $0.9998   confidence: high
```

Live answer, real production API. Your agent picked the right tool out of 28 and filled
the parameter — first try.

<Note>
  **Another client?** Put the same URL in your `mcp.json` under `mcpServers`. If it only
  speaks SSE, use `/pegana/sse` — same tools, older transport.
</Note>

Three more, same shape:

```
/orquestra/mcp   route an intent to a Solana instruction
/jupiter/mcp     quotes and swaps
/gecko/mcp       point it at your own API
```

## "I already have an OpenAPI spec and an MCP server"

Good — keep both. Gecko reads the spec and speaks MCP.

**A specification tells you what a call looks like. It cannot tell you whether it will
work.** That is structural, and just as true of a perfect spec as a bad one.

| a spec cannot tell you                 | what that costs                                                                                                       |
| -------------------------------------- | --------------------------------------------------------------------------------------------------------------------- |
| **that the endpoint still answers**    | a documented endpoint we were served returns 404. It was never real.                                                  |
| **facts that aren't about your API**   | Jupiter's route surface declares 9 accounts. The call carries 25. The other 16 belong to a route chosen a second ago. |
| **a join to a spec it never heard of** | "is it pegged, and what can I exit at" spans three APIs. None declares the mint that connects them.                   |
| **how to be an interface**             | 113,072 bytes of surface competing with your task, every turn. Gecko projects 23,382 — 79.3% less, correctness held.  |
| **a dry run**                          | neither a spec nor an MCP server has one.                                                                             |
| **when it stopped being true**         | a spec is a snapshot with no expiry.                                                                                  |

And one thing an MCP server *does*: it leaves your key in `mcp.json` or `.env`, inside the
agent's context. Gecko keeps it in your OS keychain and injects it at call time. The model
never sees it.

## The model underneath

<Steps>
  <Step title="Comprehend">
    Read the surface. Tag every fact `extracted`, `recovered`, or `flagged` as genuinely
    unknown. Never invented — below the retrieval floor it says "no start found" instead
    of guessing.
  </Step>

  <Step title="Plan">
    Turn an intent into one specific call, including the accounts the surface does not
    carry. Solana programs derive addresses from seeds; those recipes are often missing
    from the IDL, and a guess gives you a valid-looking address for the wrong thing.
  </Step>

  <Step title="Simulate">
    Run it against real chain state. \$0, unsigned, nothing broadcast.
  </Step>

  <Step title="Receipt">
    Does it land, what does it cost, and if not — which class of failure.
    See [The Receipt](/receipt).
  </Step>

  <Step title="Someone else signs">
    Gecko hands back the plan and the receipt. A wallet decides. Different jobs, and we do
    exactly one of them.
  </Step>
</Steps>

## The proof

Eleven real mainnet purchases across two days. Every receipt predicted the compute units
exactly, and the chain charged exactly that.

All eleven are public and linked on [A real transaction](/mainnet) — open any of them.

## What is not built yet

* **The receipt is not bound to the signed bytes' hash.** The gate checks the verdict.
* **A receipt is true for the state it was taken against.** Take it when you sign.
* **Nothing re-checks on a schedule.** Drift is detected across runs you make.
* **Five Solana programs are wired deep.** The catalog lists thousands. Different numbers.
* **Simulation is local.** The hosted surfaces give tools and plans; receipts need an RPC.
* **Gecko does not check whether an answer is true** — only that the call is right, and
  on-chain, that the transaction lands.

## One next step

<CardGroup cols={2}>
  <Card title="Evaluating — see it decide" icon="magnifying-glass">
    ```bash theme={null}
    npx @geckovision/gecko@latest prove "buy a token on pump.fun"
    ```

    The whole candidate field, not just the winner — including the accounts it flags
    instead of guessing.
  </Card>

  <Card title="Building — point it at your API" icon="wrench">
    ```bash theme={null}
    npx @geckovision/gecko@latest add https://your-api.com/openapi.json
    ```

    No OpenAPI? Give it the docs URL. Then [Quickstart](/quickstart).
  </Card>
</CardGroup>

<Note>
  `prove` routes and shows provenance with no setup. A **receipt** additionally needs an RPC
  — pass `--rpc-url`, or see [The Receipt](/receipt).
</Note>