# geo.qa

*Machine-first. Expect JSON and no hand-holding. The same material in prose is at https://geo.qa/docs.*

> geo.qa is a managed deployment of the open [emem](https://emem.dev) protocol.
> emem gives every patch of ground one address, every observation one signed
> fact, and every reader the ability to check that fact offline without trusting
> whoever handed it over. geo.qa runs that protocol as a hosted service, adds the
> sensors an operator brings (cameras, drones, ground sensors), and keeps the
> part that matters open: you never need an account to check our work.

## The one rule

**Verification never requires a key, an account, or our permission.** Reading a
receipt back is free forever and always will be. What you pay for is our
capture, our compute and our tenancy, never the right to check whether we lied.

If you only remember one call, remember this one:

```bash
# Check any receipt we ever handed you. No key. No account.
curl -s https://geo.qa/api/world-model/verify/receipt \
  -H 'content-type: application/json' \
  -d '{"receipt": { ... }}'
```

The key that signs our receipts is published at
[/.well-known/geoqa.json](https://geo.qa/.well-known/geoqa.json). Pin it and you
can verify without calling us at all.

## Access, in the order an agent meets it

| Tier | What you present | What it gets you |
|---|---|---|
| verify | nothing | re-check any receipt, fetch the root of trust, read the transparency log |
| read | nothing, rate-limited per IP | `detect_objects`, and `tools/list` on the MCP endpoint |
| keyed | `Authorization: Bearer on_…` | the metered tools: land cover, scene analysis, tenancy reads |
| paid | an x402 payment, once a facilitator is configured | the same metered tools, settled per request, no signup |
| subscription | a plan bought at /pricing | the ordinary way a person or a company buys. Monthly, INR, Razorpay, or an invoice |
| tenancy | an org agreement | your own memory, your own keys, your own jurisdiction |

A metered route answers with a machine-readable body listing every one of those
options for that exact resource, rather than a dead refusal. Parse
`alternatives[]`, pick the one your runtime can satisfy, retry. Each entry
carries `autonomous: true|false`, meaning whether a machine can take that rung
without a person. An agent should never have to send its human to a pricing
page just to make progress.

The exact shapes, so you can branch on them:

- **REST** (`/api/tool/*`, `/api/scene`): **401** with no credential, **403**
  with an admin-scope key, **402** when the owner's storage quota is full. In
  all three the challenge is the `detail` object, and the response carries
  `WWW-Authenticate: Bearer resource_metadata="…"`.
- **MCP** (`/api/mcp`): the JSON-RPC call itself succeeded, so the HTTP status
  is **200** and the refusal is the tool result, with `isError: true` and the
  challenge as its text content. `WWW-Authenticate` rides that 200. If your
  client only reads that header off a 401, read it off this instead: we will not
  fail a well-formed RPC at the transport layer to satisfy a convention.

The two halves are deliberate and both permanent. **Humans and companies buy a
plan**: monthly in INR through Razorpay, or an invoice for an enterprise, at
[/pricing](https://geo.qa/pricing). **Agents pay per call**: x402 is the
Linux Foundation standard for exactly that (HTTP 402, one request, no account,
no key). Neither replaces the other.

Our refusal bodies carry an `accepts[]` array in x402 shape and a
`payment_status` line saying what state it is in. That array is **empty until a
payment facilitator is configured on this deployment**, because we do not
advertise a payment we cannot settle. When it is empty, use `alternatives[]`.

## Authentication, honestly

- **API keys.** Prefix `on_`, minted at
  [/chat/account/api-keys](https://geo.qa/chat/account/api-keys). REST takes
  `Authorization: Bearer on_…`; MCP takes the same value as `X-API-Key`.
- **OAuth 2.1.** Protected-resource metadata is published per RFC 9728 at
  [/.well-known/oauth-protected-resource](https://geo.qa/.well-known/oauth-protected-resource),
  and a 401 from the MCP endpoint carries the `WWW-Authenticate` header that
  points at it. There is **no authorization server running yet**, so
  `authorization_servers` is absent from that document. Use an API key today.
- **What we do not do.** We do not proxy-sign on your behalf, and holding a key
  from us grants no read-side confidentiality over the open ledger: facts on
  emem are world-readable by content id. Tenancy scopes what we capture and
  serve for you, not who can read a public fact.

## Machine entry points

- [MCP endpoint](https://geo.qa/api/mcp): JSON-RPC 2.0 over Streamable HTTP.
  `{"jsonrpc":"2.0","id":1,"method":"tools/list"}` needs no credential and
  returns the live tool set with full schemas. Call that instead of trusting any
  list written in prose, including this one.
- [OpenAPI 3.0](https://geo.qa/api/public-docs/openapi): the REST contract.
- [A2A agent card](https://geo.qa/.well-known/agent-card.json): standard
  AgentCard, every MCP tool published as a skill.
- [Agent manifest](https://geo.qa/agent.json): build-pinned discovery manifest at
  the conventional path.
- [OpenAI plugin manifest](https://geo.qa/.well-known/ai-plugin.json).
- [Root of trust](https://geo.qa/.well-known/geoqa.json): the ed25519 public key
  every geo.qa receipt verifies under. Also served at
  [/.well-known/emem.json](https://geo.qa/.well-known/emem.json) for older
  clients.

## MCP client config

```json
{
  "mcpServers": {
    "geoqa": {
      "transport": "streamable-http",
      "url": "https://geo.qa/api/mcp",
      "headers": { "X-API-Key": "<your_key>" }
    }
  }
}
```

Drop the `headers` block and `tools/list` and `detect_objects` still work. The
other tools answer 402 with the options above.

## Tools

Do not read this section as authoritative. `tools/list` is.

- `detect_objects` — open-vocabulary detection on one image, per-prompt boxes.
  Open, rate-limited per IP.
- `classify_land_cover` — land cover for a bbox or polygon from satellite.
  Metered.
- `analyze_scene` — describe what is happening in an image. Metered.

## Verification surface

All of these answer without a credential.

- `POST /api/world-model/verify/receipt` — re-check one signed receipt.
- `POST /api/world-model/verify/batch` — up to 256 at once. More than 256 is
  **refused with 413, never truncated**. Silently checking the first 256 of 260
  and answering `{count:256, valid:256}` would read as a full pass to anyone
  comparing `valid` to `count`. The response also carries `submitted` and
  `complete` so a short answer from the verifier cannot pass for a whole one.
- `POST /api/world-model/verify` — one door for any token shape
  (`emem:fact:…`, `emem:bundle:…`, a bare content id, a lineage reference).
  Returns `{kind, matches, value_verbatim, drift, signer, receipt, reason}` and
  never paints a pass it did not earn.
- `GET /api/world-model/verify/log/sth` — the signed tree head of the
  append-only log.
- `GET /api/world-model/verify/log/proof/{cid}` — RFC 6962 inclusion proof.
- `GET /api/world-model/verify/log/consistency?first=&second=` — proof the log
  only ever appended.
- Human paste-a-receipt page: [/verify](https://geo.qa/verify).

## Where the facts come from

Satellite observations resolve against emem.dev, which signs them. geo.qa signs
what it derives on top: fused units, alerts, answers, and the observations from
sensors an operator runs. Two signers, both published, both offline-checkable.
Prose written by a language model is returned with `answer_verified: false` and
carries no signature. Only claims and receipts are asserted.

## Product surfaces for humans

- [/](https://geo.qa/) — what it is.
- [/docs](https://geo.qa/docs) — the reference.
- [/pricing](https://geo.qa/pricing) — the five plans.
- [/verify](https://geo.qa/verify) — paste a receipt, no account.
- [/chat](https://geo.qa/chat) — the console. Requires sign-in; a crawler will
  be redirected, and robots.txt disallows it.

## Contact

Vortx AI, Bengaluru. avijeet@vortx.ai.