Agent-Callable Fexr Skills for Any LLM
One skill wires any LLM to Fexr's whole stack through a typed contract — so the calls it makes are the real ones: right endpoints, right params, right auth. No hallucinated APIs.
The skill and MCP server are free to add. You pay only for the data a tool fetches — per call in USDC over x402, or from Compute Units (CU) with a Fexr account — and 4 tools are free outright.
Pointing an LLM at raw infra breaks in predictable ways.
Ask a model to build against an API it half-remembers and you get confident, wrong code. Three failure modes eat most of the debugging.
The model invents a plausible route like /api/wallet/create that never existed. You find out at runtime, with a 404.
Right endpoint, wrong body — a misnamed field, a string where an amount goes, a missing header. A 400 you have to reverse-engineer.
DPoP, API keys, x402 payment headers — the model guesses the scheme and stalls on 401s instead of shipping.
The skill removes the guessing. It gives the model Fexr's typed contract — every endpoint, parameter, and auth rule, generated from the live registry — so it calls the real thing correctly instead of improvising.
What the skill hands your model.
One typed contract, generated from Fexr's live registry. Add it once; your LLM builds against the real API surface — not its best guess.
29 typed tools — 22 paid per call over x402, 3 paid in CU, 4 free — generated from Fexr's running services at api.fexr.io/v1/mcp. Names, routes, and types stay in sync with production — the model can't call something that isn't there.
Every tool carries its request and response schema, and where a call is metered, its USDC price and CU (1 CU = $0.01). The model validates params before it calls, and budgets a paid call before it makes one.
DPoP, API keys, and x402 payment headers are part of the contract — configured once on the MCP server, or carried in the x402 flow — so the model wires auth correctly instead of guessing the scheme. Run more than one agent and each still carries its own key, never one shared credential for the whole fleet.
Build anything on Fexr.
The skill covers the whole stack — all three families reachable from the same typed contract. Market data is one of them, not the main event.
Prices, fundamentals, flows, and research as typed reads — from asset metrics to smart-money flow and deep research. Every response is schema-typed and carries a freshness age, so the model knows exactly what it got.
Self-custody wallets, staking and liquidity contracts, and an on-chain execution engine — exposed directly as typed REST with replay-safe webhooks.
What "auth handled" actually means underneath.
Six separate guarantees, each one a real backend change rather than a policy commitment — and none of them a shared secret with a nicer error message on top.
Each agent gets its own ES256 keypair — never a shared secret across a fleet. Compromise one agent's key and you revoke exactly that key, not the whole integration.
API keys are stored as peppered HMAC hashes, never plaintext, each with its own capability scopes and expiry. A leaked log line doesn't leak a usable key.
Wallet & Execution calls require DPoP (RFC 9449) — a fresh signed proof on every request. A captured token alone can't be replayed on the next call.
Deep research, signals, and other paid async calls write to a transactional outbox in the same commit as the charge. A broker hiccup can't drop work you already paid for.
Every fund-affecting action gets a signed receipt, chained to the one before it. Verify it yourself against the published key at /receipt-keys — you don't have to take our word for it.
Desk workspaces add OIDC sign-in, roles, and SCIM deprovisioning. Revoke at the workspace and every agent's outstanding grant goes stale at once. Full picture at fexr.io/plans.
Same task, with and without the skill.
A wallet-balance call, generated two ways. Without the typed contract the model improvises the route and the auth; with it, the call is correct and the auth is already wired.
Works in the LLM you already use.
Add the skill and the same typed catalog is reachable from every major client. Tool-calling, webhooks, and DPoP-gated keyed endpoints vary by surface.
Everything the skill can reach.
The full typed surface behind the contract — each product callable as an MCP tool, over REST, or paid per call over x402. Reference, not required reading.
1 CU = $0.01: the CU column is the same price counted in CU. Over x402 you pay the USDC price with no account. With a Fexr account, the trade plan, weekly review, validated strategies and token dossiers come out of the plan's CU first (Plus 6,000 and Desk 83,333 every 30 days; Free has none, but a first $100 deposit brings a free month of Plus with 6,000), then bought CU; CU top-ups are $0.01 each, from 100. On Free an alert fire costs 2 CU and a digest 5 CU. Data calls on Plus and Desk don't use CU — they sit inside the daily limits. Per-asset prices multiply by the assets in the call, up to 10. Full price table
Self-custody wallets, staking/liquidity contracts, and the on-chain execution engine, with replay-safe webhooks.
Add the skill in minutes.
api.fexr.io/v1/mcp — 29 typed tools, schemas and USDC/CU prices embedded.402 with the USDC price, pay on Base, and retry with X-PAYMENT.Ship on Fexr without the errors. Add the skill to the LLM you already use, and your model builds against Fexr's real, typed surface — right endpoints, right params, auth handled — from the first call.
Add the MCP server in a minute — no account needed to try it.