Intro
Most agent builders don't want to become quants. They want a one-line answer to "what's BTC doing right now, and should my bot care?" That's the entire reason we shipped quick-btc-check as the first AlgoVault Skill: a single verb, a single answer, zero glue code. Under the hood it hits the same composite verdict engine that powers our full API — the one with a track record of 91.7% PFE win rate · 472,890+ verified calls · Merkle-anchored on Base L2 — but the surface is deliberately narrow. One call. One verdict. One reason. That's the M5 promise: remove the friction that keeps curious builders from ever making the first request.
This post is the spotlight on that skill: why it exists, what it returns, how to wire it in, and where it deliberately stops short.
The problem: the first call is where builders quit
Watch a new agent developer try to add "market awareness" to their bot. They pick an exchange SDK. They read about REST vs WebSocket. They wire funding rates. They discover open interest is on a different endpoint. They try to build a "is BTC bullish?" heuristic from three raw indicators and immediately hit the question every quant has hit: how do I weight these? By the time they have a working prototype, they've written 400 lines of glue and they still don't trust the answer.
The structural reason this happens: raw indicator APIs sell you the ingredients, not the meal. Funding rate on its own is noise. Open interest change on its own is noise. Regime classification is a research problem, not a REST call. Every builder who wants "a verdict" ends up writing their own composite scoring layer — badly, without a track record, and without cross-venue coverage. That's the tax we're removing. quick-btc-check is what happens when you refuse to make the first call a research project.
The AlgoVault answer: one skill, one verdict, one reason
A Skill in the AlgoVault sense is a scoped MCP tool call with an opinionated default surface. quick-btc-check is a wrapper around get_trade_signal with BTC pinned, timeframe defaulted to the short intraday default, and the response shape flattened so a language model can read it in one glance. It returns the same composite verdict as the full API — same regime classifier, same factor ledger, same PFE-tracked outcomes — but pruned to the fields an agent actually needs to make a decision on the next tick.
The moat layer this hits is Moat #1 (composite verdict). Every field in the response comes from the same weighting model we've been publishing outcomes against for months. The M5 tie-in is that the skill removes the "I need to learn the schema first" barrier: your agent can call it before it understands what any of the underlying indicators mean, and the reasoning string will explain the verdict in plain English. That's the friction removal we're optimizing for — not fewer bytes over the wire, but fewer decisions the builder has to make before they get useful output.
Implementation walkthrough
Three blocks: install, live response, agent loop. The whole thing runs against api.algovault.com, no mocks.
Block 1: install and first call
The skill ships as part of the AlgoVault MCP server. Install via npx; no build step, no config file for the happy path.
# Add the AlgoVault MCP server to your Claude Desktop / Code / Cursor config
npx -y @algovaultlabs/crypto-quant-signal-mcp@^1.27 --install claude-code
# Or invoke the skill directly for a smoke test
export ALGOVAULT_API_KEY="av_live_..."
npx -y @algovaultlabs/crypto-quant-signal-mcp@^1.27 \
--skill quick-btc-check
That's the entire setup surface. No exchange keys to provision, no rate-limit dance to configure, no indicator selection. The free tier gives you 200 calls/month (also expressible as 100 calls/day), which is enough to run a hobby agent on a several-minute cadence and never touch a paywall.
Block 2: what the response actually looks like
Here is a verbatim response from a live call — no synthetic fields, no elided sections. Note the _algovault metadata block (version, session, quota) and the _receipts block (factor ledger, track-record snapshot, verification URI). Those are the two pieces that make this composable in an agent loop: the metadata lets you cache-key and rate-limit, and the receipts let you show your reasoning.
{
"content": [
{
"type": "text",
"text": "{\n \"call\": \"HOLD\",\n \"confidence\": 1,\n \"price\": 63554.2,\n \"regime\": \"TRENDING_UP\",\n \"reasoning\": \"2 internal factors not shown here net bearish, and they carry this read. Against: regime is trending up on the moving-average cross → bullish. Becomes actionable if the breakout resolves.\",\n \"timestamp\": 1786672811,\n \"coin\": \"BTC\",\n \"timeframe\": \"15m\",\n \"_algovault\": {\n \"version\": \"1.27.0\",\n \"tool\": \"get_trade_call\",\n \"session_id\": \"v2:01a2631b198fb4f4\",\n \"exchange\": \"BINANCE\",\n \"venue_status\": \"promoted\",\n \"quota\": { \"used\": 36, \"total\": 200, \"remaining\": 164 }\n }\n}"
},
{
"type": "text",
"text": "HOLD · 1% conviction — Trending up\nProof: 91.7% PFE win rate · 472,890+ calls · Merkle-anchored on Base"
}
]
}
The second text block is the pre-flattened human-readable line. That's what a language-model agent reads first; the JSON is there for the deterministic logic path. Both are always present.
Block 3: dropping it into an agent loop
The point of a skill is that the loop is trivial. Here's the terminal output of the example script — a fifteen-line TypeScript program that polls the skill on a threshold and decides whether the verdict deserves the agent's attention.
# AlgoVault MCP example — coins=BTC confidence_threshold=70
[BTC] {
"call": "HOLD",
"confidence": 24,
"price": 63551,
"indicators": {
"funding_rate": 0.00009636,
"funding_24h_avg": 0.00009636,
"funding_state": "NORMAL",
"oi_change_pct": -1.55,
"oi_change_window": "24h",
"vo…
# DRYRUN_MODE=1 — example complete
The full example script lives in the repo under examples/. The important shape: your agent doesn't call get_trade_signal with a dozen parameters; it calls the skill, checks conviction against its own threshold, and only wakes the reasoning model when the verdict deserves attention. That inversion — verdict-first, model-second — is the whole cost-control story for LLM-driven bots.
Pitfalls and honest limits
Three things the skill deliberately doesn't do, and one thing it can't.
First, quick-btc-check is pinned to BTC. If you want ETH, SOL, or any of the other assets in the full asset coverage, use get_trade_signal directly with the coin parameter. The skill exists to be the one-liner; the moment you're passing an asset parameter, you're already past the friction point it was designed to remove, and you should be on the general tool.
Second, the default timeframe is the short intraday default. That's a defensible default for agents polling on a several-minute cadence, but it's not right for a scalping bot and it's not right for a swing bot. The decision cadence is the timeframe the caller selects — the verdict is computed on demand per call, not on a fixed clock. If your agent is running on hourly ticks, pass an hourly timeframe and get a different composite; the underlying engine supports the full timeframe range from sub-minute to daily.
Third — and this is the one to internalize — the skill returns a verdict, not a trade. The disclaimer field in the receipts block is not decorative. AlgoVault provides the thesis; your agent decides execution, sizing, and risk. We publish the PFE outcomes so you can trust the thesis; we do not and will not tell a specific reader to buy anything. That's a positioning line, not a legal hedge — the whole product is downstream of the assumption that the agent is the decider.
Performance: what the data actually shows
The verdict engine behind the skill is the same one tracked on our public performance page. Every verdict emitted — HOLD, LONG, or SHORT — gets outcome-scored against a peak-favorable-excursion window and Merkle-anchored on Base L2. The current published aggregate is 91.7% across 472,890+ verified calls, and every call the skill makes on your behalf enters the same batch. There is no separate cohort for skills, no separate cohort for free-tier users, and no cherry-picked subset — the number you see is the number your agent's calls will be measured against.
That matters more than it sounds. The reason we pin every skill to the same composite engine and the same public outcome ledger is that the data flywheel (Moat #3) only works if every call counts. Skills are not a marketing surface layered on top of a different backend — they are opinionated defaults on the exact same tool, and their outcomes are indistinguishable in the ledger from any other call.
What's Next?
- the track record — the live PFE ledger and Merkle batch verifier
- the docs — the full skill catalog and MCP setup guides
-
the GitHub repo — the MCP server source and the
examples/folder used in Block 3 - Try free in Telegram — the same verdict, no API key, no signup
— AlgoVault Labs
⭐ Star the repo to follow new exchanges and signals: https://github.com/AlgoVaultLabs/crypto-quant-signal-mcp
