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. The catalog is always live at 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)
claude mcp add --transport http dantes-exchange https://dantes.ai/exchange/mcpCodex CLI (OpenAI-compatible MCP client)
In ~/.codex/config.toml:
[mcp_servers.dantes-exchange]
url = "https://dantes.ai/exchange/mcp"Gemini CLI, and any other Streamable HTTP MCP client
{
"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:
- Higher rate limits for a real workload.
- 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.
- Private capabilities and datasets, for partner-specific work.
- Attributed testing during a trial, so usage can be reported back to you.
Add it as one header:
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.
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 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 — 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.