The gap: agents need current data, not just formulas
A risk or trading agent reasoning about a position needs live inputs. "Should I size down?" depends on today's volatility. "Is this perp expensive to hold?" depends on the current funding rate. An LLM can't produce those numbers — they're facts about the market right now, and the model will confidently hallucinate them if asked.
The usual fix is to build a data pipeline: integrate an exchange API, handle auth and rate limits, dodge geo-blocks, cache responses, then compute the metric. That's real work to build and keep alive — and it's the same work for every agent. QuantOracle Live collapses it into one HTTP call.
Two endpoints to start
/v1/live/volatility — realized volatility over 7d / 30d / 90d windows, plus a regime read, computed from fresh daily candles. You pass a ticker:
POST https://api.quantoracle.dev/v1/live/volatility
{ "asset": "BTC" }
# →
{
"asset": "BTC",
"spot": 61728.7,
"realized_vol_7d": 0.4534,
"realized_vol_30d": 0.3108,
"realized_vol_90d": 0.3157,
"vol_ratio_30d_90d": 0.9845,
"regime": "NORMAL",
"as_of_age_seconds": 0.0,
"stale": false,
"source": "kraken"
}/v1/live/funding-rates — the current perpetual funding rate and its annualized carry:
POST https://api.quantoracle.dev/v1/live/funding-rates
{ "asset": "ETH" }
# →
{
"asset": "ETH",
"instrument": "ETH-USDT-SWAP",
"funding_rate": -0.000104,
"interval_hours": 8,
"annualized_rate": -0.1137,
"regime": "BACKWARDATION",
"source": "okx"
}That's a computed answer — annualized carry, vol regime — not raw ticks the agent would have to post-process. Pass a ticker, get a decision-ready number.
How it's built (and why it stays up)
Each call checks a short-lived cache first; on a miss it fetches from a public exchange feed (Kraken for candles, OKX for funding — chosen because they're reachable where the big US-blocked venues like Binance and Bybit aren't), runs the same realized-vol and funding math as the deterministic calculators, and caches the result (vol ~5 min, funding ~1 min). If an upstream is briefly down, the API serves the last good value with a stale: true flag rather than failing. The as_of_age_seconds field tells your agent exactly how fresh the answer is.
Pricing: this is the one tier you pay for from call one
The 73 calculators are free up to 1,000 calls/IP/day because they're pure compute — you could run the same math locally. Live is different: the value is the fresh data and the pipeline, which you can't replicate with a local library. So it's priced from the first call, separate from the calculator free tier:
/v1/live/volatility— $0.01/call/v1/live/funding-rates— $0.005/call
You get 20 free calls per IP per day to evaluate the data, then it settles per-call via x402 (USDC on Base or Solana) — no API key, no signup. You're paying for freshness, not arithmetic.
Wiring it into an agent
It's a plain POST, so it drops into any agent as a tool. Expose it over MCP — the hosted server at https://mcp.quantoracle.dev/mcp already lists live_volatility and live_funding-rates alongside the other 74 tools — or wrap it directly:
const liveVol = {
name: "live_volatility",
description:
"Get FRESH realized volatility (7/30/90d) + regime for a crypto asset. " +
"Use this for current market vol — do not estimate it yourself.",
schema: z.object({ asset: z.string() }),
func: async ({ asset }) => {
const r = await fetch("https://api.quantoracle.dev/v1/live/volatility", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ asset }),
});
return JSON.stringify(await r.json());
},
};The description line — "do not estimate it yourself" — matters: it tells the model this is a fact to fetch, not compute. That's the whole point of grounding an agent in real data.
Where this goes
Volatility and funding are the first two. The pattern — fetch fresh data, run QuantOracle's verified math, return a decision-ready metric — extends to liquidation heatmaps, live option-implied vol, cross-venue funding spreads, and more. If there's a live metric your agent needs, that's the roadmap.
Related
- Batch API calls for speed — price a whole option chain or scan many positions in one request
- Add 73 quant tools to your agent with MCP — the MCP server that now exposes the live tools too
- Crypto liquidation calculator — the pure-compute companion (you bring the inputs)
- Pricing — the Live tier and the x402 settlement model in full