# Dantes Exchange — integration guide

**Current as of 2026-08-22 (public access).** This page is served live at
`https://dantes.ai/exchange/onboarding` and is the technical companion to
[dantes.ai/finance/connect](https://dantes.ai/finance/connect). The catalog is always live at
[dantes.ai/skills](https://dantes.ai/skills) — if this page and the catalog ever disagree, the
catalog is right.

## What Dantes is

Dantes gives AI agents access to evidence-backed investing and trading capabilities. Your own agent
connects to one endpoint and can then **search, inspect, read the evidence for, and invoke** proven
investing capabilities — the same detectors, classifiers and normalizers a working trading operation
runs, packaged as callable jobs.

You do not need to know how the Exchange is built, you never need a capability's id — your agent
finds the right specialist by describing the job — and **you do not need an account, an API key or
our permission** to start.

## Your connection

- **Endpoint (Streamable HTTP MCP):** `https://dantes.ai/exchange/mcp`
- **Auth: none required.** The public capability surface is open. Connect anonymously and your agent
  can immediately discover capabilities, read manifests and evidence, list the hosted datasets, and
  invoke every capability declared publicly free.

### Claude Code (and any Claude MCP client)

```bash
claude mcp add --transport http dantes-exchange https://dantes.ai/exchange/mcp
```

### Codex CLI (OpenAI-compatible MCP client)

In `~/.codex/config.toml`:

```toml
[mcp_servers.dantes-exchange]
url = "https://dantes.ai/exchange/mcp"
```

### Gemini CLI, and any other Streamable HTTP MCP client

```json
{
  "mcpServers": {
    "dantes-exchange": {
      "type": "http",
      "url": "https://dantes.ai/exchange/mcp"
    }
  }
}
```

## What costs what

Three access classes. Every capability states its own in `get_capability`, under
`access_on_this_endpoint`, so your agent can plan before it spends a call finding out.

| Class | What it takes | Which capabilities |
|---|---|---|
| **Free** | nothing — call it | most of the catalog: deterministic capabilities that execute on the Dantes host with no third-party cost, universe scanners included |
| **Paid (x402)** | USDC on Base, requested at the moment you invoke | the priced capabilities; `https://dantes.ai/exchange/health` lists them |
| **Token** | an `Authorization: Bearer` header | capabilities whose single call spends real money on a third-party service, and private capabilities |

**Paid does not mean gated behind an account.** Invoke a priced capability anonymously and the
endpoint answers with an x402 payment challenge naming the exact amount, the USDC asset, the Base
network and the recipient address. Nothing executes until a payment is verified. An x402-capable
client pays and retries on its own; buyer-side spend authority lives in your own wallet and Dantes
never holds it.

## When you would want a token

A token is optional and exists for four things:

1. **Higher rate limits** for a real workload.
2. **Token-only capabilities** — where one call costs Dantes real third-party money. The fine-tuned
   StoryStocks Equity Analyst runs on a deployment that bills by the hour; its listing, contract and
   evidence are public, its execution is not anonymous.
3. **Private capabilities and datasets**, for partner-specific work.
4. **Attributed testing** during a trial, so usage can be reported back to you.

Add it as one header:

```bash
claude mcp add --transport http dantes-exchange https://dantes.ai/exchange/mcp \
  --header "Authorization: Bearer <your-token>"
```

Ask for one at
[dantes.ai/finance/connect#request-access](https://dantes.ai/finance/connect#request-access).

A token that is **present but unknown or revoked is refused with 401** rather than quietly
downgraded to anonymous — a stale credential should tell you so instead of silently giving you less.
Remove the header entirely and you connect anonymously with the full public surface. Note that some
MCP clients drop custom headers on redirect, which produces the same symptom.

## The five tools

| Tool | What it does | Cost |
|---|---|---|
| `search_capabilities` | Find a specialist by describing the job in your own words | free |
| `get_capability` | The full manifest: contract, support envelope, limitations, price | free |
| `get_capability_evidence` | Semantic evidence and historical economic evidence, kept separate | free |
| `list_datasets` | The hosted universe, its as-of date, the paths to pass, and enumerable membership | free |
| `invoke_capability` | Run it | free unless the capability is priced or token-only — see *What costs what* |

**Browsing is free and anonymous, and that is the point.** Your agent should read the manifest and
the evidence before deciding whether a capability is worth calling — or paying for.

## Evidence

`get_capability_evidence` (and `https://dantes.ai/skill/<id>/evidence.json`, which returns the same
record) is the thing to read before trusting a capability. It keeps two things apart and never
merges them into a score:

- **Semantic evidence** — does this capability do what it says? Reproduction parity against a locked
  source, a blind sealed held-out review, a frozen regression.
- **Historical economic evidence** — what was measured about the population it identifies? Always
  with its universe, window, N, horizon, baseline, right-tail behaviour, severe-loss behaviour and
  time robustness, plus the misquotations that have been recorded against it.

A capability with no economic measurement reports `NOT_MEASURED` rather than borrowing a sibling's
figures. Where a stored figure was measured on a population a newer version no longer emits, the
record says so instead of restating the better number.

**Right-tail and severe-loss behaviour travel together.** A capability can raise convexity and raise
catastrophic-loss frequency at the same time; the evidence records are built so neither half can be
quoted alone.

## The hosted data

The endpoint publishes a dated universe your agent can scan server-side. Call `list_datasets` to see
it — name, as-of date, size, and the exact paths to pass to a scanner. Raw data files are never
returned; capabilities read them on the Exchange host and return derived results.

**Data currency is stated, never assumed.** A scan reports the date you asked for *and*
`evaluated_as_of` — the newest bar it actually had — plus `data_stale` and a warning when the corpus
is behind your request. The current as-of date is shown on
[dantes.ai/finance](https://dantes.ai/finance) and on every capability page. The universe is
refreshed on a schedule; a failed refresh leaves the older date in place rather than relabelling
stale data as current.

## Rate limits

Dantes runs on one small two-core host, and a 743-name universe scan is several seconds of real CPU.
Anonymous callers therefore share a deliberately small budget, and a token raises it.

| Limit | Anonymous (per client) | With a token |
|---|---|---|
| Tool calls per minute (all tools) | 60 | 120 |
| `invoke_capability` per minute | 12 | 30 |
| Universe scans / filing-scale calls per minute | 4 | — |
| Invocations in flight at once | 1 | 2 |

There is also a **host-wide ceiling on anonymous invocations** — 2 at a time, of which 1 may be a
universe scan — so anonymous scans are queued by refusal rather than piled up. Authenticated callers
are not subject to it.

The live values are always in `https://dantes.ai/exchange/health`. Hitting any limit returns a
structured refusal naming the limit and when to retry; **nothing executes and nothing is charged**.
Ask us to raise them for a real workload.

## Refusals are deliberate

A capability that cannot do its job properly says so and returns nothing, rather than guessing:

- thin or contradictory inputs return a named refusal with the reason;
- a host path outside the published datasets is refused;
- an invented capability id fails safely and suggests real ones;
- a capability whose dependency is unavailable refuses rather than substituting something else.

**Equity Analyst availability.** The analyst runs on a dedicated fine-tuned model deployment that is
not kept running continuously. Outside a scheduled window it returns a truthful
`inference_failed` / `model_dependency_missing` refusal rather than answering with a general model —
a general model's answer would not be this analyst. Ask for a window if you need one.

## Paid capabilities

Most capabilities are free. A priced one states its exact price in its manifest and in the payment
challenge; nothing executes until a payment is verified. Settlement is USDC on Base over x402, and
buyer-side spend authority stays in your own wallet — Dantes never holds it.

**No account is involved.** The payment IS the access control: an anonymous agent invoking a priced
capability gets the challenge, pays, and gets its result and its receipt. `get_capability` tells you
which capabilities are priced, and `https://dantes.ai/exchange/health` lists them.

## Things to try

Ask your agent, in your own words:

> "Connect to Dantes and show me what it can do."

> "What does it cost to use each of Dantes's capabilities?"

> "Find me the fresh coils in the Dantes universe, then tell me what volatility regime each one is
> in and what Dantes has actually measured about that regime."

> "Which names in the Dantes universe are sitting at long-term support right now?"

> "Is NVDA building a tightening contraction base? Show me the evidence behind whatever tells you."

Your agent will find the right capabilities on its own — that is the point.

## Support

A person reads every message. Use the form at
[dantes.ai/finance/connect#request-access](https://dantes.ai/finance/connect#request-access) — it is
the same route for access requests, bug reports and questions, and it reaches Dantes directly.

Include the exact response you got. Refusals are deliberate and their text names the condition that
failed, so the response is usually the whole diagnosis.

---

*Dantes returns structured findings and evidence. It is not investment advice, it is not a
brokerage, and it never executes trades or moves customer money.*