DEV Community: AlgoVault.com

AlgoVault Weekly Trade-Call Report — Week of 2026-08-30

AlgoVault.com — Sun, 30 Aug 2026 12:00:04 +0000

AlgoVault Trade-Call Intelligence — Week of 2026-08-30

📊 524,637 trade calls tracked
🎯 PFE Win Rate: 91.7% across 1807+ assets (Hyperliquid)
🏆 Top performer: NCSKSONY2USD 3m — 100.0% PFE Win Rate (8 evaluated)
📈 Confidence band 50-54 hitting 91.9% accuracy

All calls are on-chain verified (Base L2 Merkle root).

📊 Live track record: algovault.com/track-record
🔌 Connect an agent: algovault.com/docs
🛰 Set a standing scan in Telegram: t.me/algovaultofficialbot

Built by AlgoVault Labs — call interpretation for AI trading agents.

This week's top crypto trade setups — 708 asset scans · 14 venues (Aug 2026)

AlgoVault.com — Fri, 28 Aug 2026 12:02:20 +0000

This week's top crypto trade setups — 708 asset scans · 14 venues (Aug 2026)

Live from AlgoVault's engine:

📡 This week I scanned 708 assets across 14 venues.

Top fresh setups:

🟢 UNI — BUY @ $4.63 · 60% conviction · TRENDING_UP
📊 trend persistence MEDIUM · funding extreme ↑ · breakout imminent
💡 Funding at -0.0145% is unusually negative for UNI over 14 days: shorts pay longs → bullish

🟢 NCCO1OILWTI2USD — BUY @ $82.91 · 57% conviction · TRENDING_UP
📊 trend persistence MEDIUM · funding normal · breakout imminent
💡 Funding at -0.0100% is negative at a normal level for NCCO1OILWTI2USD: shorts pay longs → bullish

🟢 MSFT — BUY @ $503.97 · 55% conviction · TRENDING_UP
📊 trend persistence HIGH · funding normal · breakout imminent
💡 Regime is trending up on the moving-average cross → bullish

🟢 SOL — BUY @ $105.70 · 51% conviction · TRENDING_UP
📊 trend persistence HIGH · funding elevated ↑ · OI +6.7% (24h)
💡 Funding at -0.0067% is unusually negative for SOL over 14 days: shorts pay longs → bullish

🟢 BEAT — BUY @ $0.1239 · 48% conviction · RANGING
📊 trend persistence HIGH · funding normal · breakout imminent
💡 Regime is ranging with the moving averages inside the noise band → bullish

Every setup above is a live call from the same engine that publishes its full record on-chain — each one written down before its outcome is known. Conviction is shown as measured, not rounded up: these are the week's strongest setups, not certainties.

Ranking is by conviction across every venue scanned, deduplicated per coin, and filtered by a USD liquidity floor. The headline figure counts scans rather than distinct assets — a coin listed on several venues is scanned on each. What is not here matters as much as what is: the engine holds by default.

⚠️ This is call interpretation, not financial advice. AlgoVault helps AI agents analyze — execution decisions are theirs.

🛰 Want this on your coins automatically? Set a standing scan: t.me/algovaultofficialbot
📊 See the full verified track record: algovault.com/track-record

The crypto-quant cold-start problem and how AI agents solve it

AlgoVault.com — Fri, 28 Aug 2026 02:04:32 +0000

Intro

Every crypto-quant team starts in the same hole. You have an LLM agent that can reason, a broker connection that can execute, and precisely zero calibrated signal to bridge them. Building that bridge from scratch — pulling OHLCV, tuning a regime classifier, backtesting a composite weighting across venues, then proving the whole thing works — is the cold-start problem, and it eats six-to-nine months of engineering time before your agent takes its first paper trade. That is exactly the gap AlgoVault fills: 91.7% PFE win rate · 518,764+ verified calls · Merkle-anchored on Base L2, delivered as a single MCP tool call your agent can invoke on turn one. We provide the thesis; the agent decides execution.

This post lays out why the cold-start problem is structural (not a tooling gap), what a "brain layer" actually looks like when you inspect its output byte-by-byte, and how to wire it into a Claude, Cursor, or custom MCP-client agent loop today.

The problem: what "cold start" actually costs

Ask any team that has built a crypto trading agent in the last two years and the timeline is depressingly consistent. Weeks one through four go to data plumbing: normalizing perp funding across all live derivatives venues; reconciling contract multipliers; handling the fact that "open interest" means three different things depending on which venue you ask. Weeks five through twelve go to a first-pass indicator stack — some combination of trend, funding, OI delta, volume regime — glued together with hand-tuned thresholds that inevitably overfit the last quarter's tape.

Then you hit the real wall: calibration. Your agent needs to know not just "is this a buy?" but "how confident should I be, and does that confidence generalize across regimes I haven't seen?" That requires a labelled outcome dataset, a walk-forward evaluation harness, and enough live paper-trading time to distinguish luck from edge. Most teams never make it past this stage. They either ship an overconfident bot that blows up in the first regime change, or they cut scope down to a single asset on a single venue and quietly stop calling it "quant."

The structural reason this happens is not laziness. It is that the three things a trading agent needs — normalized cross-venue data, a calibrated composite verdict, and a public track record it can verify — are each a full-time engineering discipline. Building all three inside one team, from zero, is a business-model mismatch for anyone whose actual product is the agent itself.

The AlgoVault answer: a brain layer, not an indicator feed

The positioning we have settled into after two years of shipping is deliberately narrow. AlgoVault is not a charting tool. It is not a raw indicator aggregator. It is not a signal advisor telling you to buy XRP at market. It is the brain layer that sits between an AI agent and the market: one MCP endpoint that returns a composite verdict (LONG / SHORT / HOLD), a conviction percentage, a regime label, and a receipt showing which factors contributed and how.

That framing matters because it defines what we do and do not do. We do publish a live, Merkle-anchored track record so your agent (or your compliance team) can verify our claims cryptographically. We do compute the verdict across all live derivatives venues so a single-exchange funding spike does not fool the composite. We do let HOLD be a first-class output — because an agent that trades on every tick is an agent that pays every spread and every verdict fee. We do not custody funds. We do not route orders. We do not tell any specific human what to buy.

The 91.7% PFE peak-favourable-excursion win rate is the number that anchors the pitch, but the more interesting artefact for engineers is the shape of a single response. Here is what an agent actually receives when it asks for a BTC verdict on a short intraday timeframe.

Implementation walkthrough

The fastest way from zero to a running agent loop is three code blocks: install, inspect a real response, wire it into a loop. Every dependency below is pinned; every output is verbatim from the live api.algovault.com.

Block 1: install and first call

The MCP server is distributed via npm and consumable by any MCP-compatible client (Claude Desktop, Claude Code, Cursor, Continue, custom SDK). No API key is required for the free tier.

# Install the MCP server (pin the minor for reproducibility)
npx -y @algovault/crypto-quant-signal-mcp@^1.28

# Or wire it into Claude Desktop's mcp_servers.json:
cat >> ~/Library/Application\ Support/Claude/claude_desktop_config.json <<'EOF'
{
  "mcpServers": {
    "algovault": {
      "command": "npx",
      "args": ["-y", "@algovault/crypto-quant-signal-mcp@^1.28"]
    }
  }
}
EOF

# Verify the health endpoint (no auth, no rate-limit hit)
curl -s https://api.algovault.com/api/performance-public | jq '.pfe_win_rate, .total_signals'

Once the server is registered, your agent has the full tool coverage available: get_trade_signal, get_regime, and get_venue_status. The workhorse takes a coin, a timeframe (the full intraday-through-daily range, computed on demand per call — the decision cadence is the timeframe your caller selects, not a fixed clock interval), and an optional confidence threshold.

Block 2: a real API response

Below is a verbatim response for BTC on a short intraday timeframe. Note the _algovault metadata block (version, session, quota, auth tier) and the _receipts block (per-factor ledger, track-record snapshot, verification URI). Everything an agent needs to justify its own action to a downstream reviewer is in this single payload.

{
  "call": "HOLD",
  "confidence": 33,
  "price": 80467,
  "indicators": {
    "funding_rate": 0.00007092,
    "funding_state": "NORMAL",
    "oi_change_pct": 5.23,
    "trend_persistence": "MEDIUM",
    "breakout_pending": "INACTIVE"
  },
  "regime": "RANGING",
  "reasoning": "Regime is ranging with the moving averages inside the noise band → bullish. Funding at +0.0071% sits in BTC's normal 14-day band: no crowd pressure either way. Turns directional if funding moves off neutral.",
  "coin": "BTC",
  "timeframe": "15m",
  "_algovault": {
    "version": "1.28.2",
    "exchange": "BINANCE",
    "venue_status": "promoted",
    "quota": {
      "used": 113,
      "total": 200,
      "remaining": 87,
      "daily": { "used": 3, "total": 100, "remaining": 97 },
      "binding": "monthly"
    },
    "auth": { "outcome": "ABSENT", "presented": false, "tier": "free" }
  },
  "_receipts": {
    "verdict": "HOLD",
    "conviction_pct": 33,
    "regime": "RANGING",
    "track_record": {
      "pfe_win_rate": 0.917,
      "n": 512602,
      "window": "2026-04-10..2026-08-28"
    },
    "verification_uri": "https://algovault.com/track-record"
  }
}

Three things worth calling out. First, the free tier is 200 calls/month and 100 calls/day (two independent walls) — enough for a research spike or a single-asset paper-trading loop. Second, the _receipts.factor_ledger (elided above for brevity) lets your agent explain why the verdict came out the way it did, which matters enormously if a human reviewer ever asks. Third, also_see and closest_tradeable are the composite's opinion on where conviction actually lives right now — a HOLD on BTC does not mean "sit on your hands," it means "look at SOL on the short intraday timeframe, we score it higher."

Block 3: wire it into an agent loop

Here is a minimal TypeScript example that polls the tool for a watchlist, filters by conviction threshold, and hands high-conviction verdicts to a downstream execution stub. This is the shape most Claude Code / Cursor users end up with after a day of iteration.

# AlgoVault MCP example — coins=BTC confidence_threshold=70

[BTC] {
  "call": "HOLD",
  "confidence": 19,
  "price": 80424.5,
  "indicators": {
    "funding_rate": 0.00007092,
    "funding_24h_avg": 0.00007092,
    "funding_state": "NORMAL",
    "oi_change_pct": 5.23,
    "oi_change_window": "24h",
    "v…

# DRYRUN_MODE=1 — example complete

The dry-run harness ships in the repo under examples/agent-loop.ts with DRYRUN_MODE=1 on by default; flip it off, add your execution adapter of choice (CCXT, Hyperliquid SDK, a broker webhook), and you have a paper-trading agent in under fifty lines of glue code. The verdict, the conviction score, and the factor ledger are the contract your execution layer consumes; everything else (venue routing, position sizing, risk gates) belongs on your side.

Pitfalls and design decisions worth knowing

Three honest gotchas before you commit to this stack.

Rate limits are real on the free tier. 200 calls/month sounds generous until you build a watchlist of ten assets on a short intraday cadence and burn through it in a week. The response includes a live quota object so your agent can back off gracefully; if you see remaining dropping fast, cache verdicts by (coin, timeframe) for the duration of the timeframe bar and only refetch on close. This is what serious quant users do anyway — asking for a fresh verdict twice inside the same candle is wasted budget.

Regime classifier has blind spots at regime transitions. The composite is calibrated to hold conviction back when the regime label itself is ambiguous — that is the design intent — but the transition from RANGING to TRENDING (or vice versa) can produce a run of low-conviction HOLDs even as price moves meaningfully. If your agent's success metric penalizes missed moves more than false starts, wrap the verdict with your own regime-change detector and treat AlgoVault as one input among several.

We chose composite over raw for a reason. The obvious question from any quant is "why not just give me the raw indicators and let me weight them myself?" We do expose the indicators inside _receipts.factor_ledger for exactly that reason — you can rebuild your own composite if you want to. But the flagship product is the calibrated verdict, because the calibration is the moat: it is what the Merkle-anchored track record is measuring, and it is what took two years of walk-forward evaluation to earn. Raw indicators are commoditized. Calibrated composite verdicts, verifiable on-chain, are not.

What the data actually shows

The number that matters is not any single verdict's outcome; it is the aggregate PFE win rate across the full corpus of published calls. 91.7% PFE win rate across 518,764+ verified calls, Merkle-anchored on Base L2 — that is the current window (2026-04-10 through 2026-08-28), sourced live from /api/performance-public at draft time and re-verifiable at the track-record page any time you want to audit it yourself.

Two things about that number that are easy to miss. First, "PFE" is peak-favourable-excursion — it measures whether the market ever moved in the verdict's favour by a meaningful margin during the verdict's lifetime, not whether a specific exit rule would have profited. It is a calibration metric, not a returns claim, and it is deliberately the only public metric because it is the honest one to publish. Second, the corpus is Merkle-anchored on Base L2 — the tree roots are notarized on-chain so we cannot silently drop losing calls to make the number look better. This is Moat #2 in the AlgoVault stack (published track record) and Moat #1 (composite verdict quant weighting) working together.

For agent builders, the practical takeaway is that calibration this deep is not something you replicate in a sprint. Buying it as a service, calling it from an MCP tool, and putting the verification URI in your own audit trail is a two-hour integration instead of a two-quarter build.

What's Next?

the track record — verify the 91.7% PFE win rate and 518,764+ call corpus for yourself, live and Merkle-anchored
the docs — full MCP tool reference, agent-loop patterns, and quota/auth details
the GitHub repo — MCP server source, examples/agent-loop.ts, and integration adapters
Try Free in Telegram — no API key, no signup, verdicts in one message

— AlgoVault Labs

⭐ Star the repo to follow new exchanges and signals: https://github.com/AlgoVaultLabs/crypto-quant-signal-mcp

How an AI agent analyzes BTC with AlgoVault MCP

AlgoVault.com — Wed, 26 Aug 2026 12:00:02 +0000

How an AI agent analyzes BTC with AlgoVault MCP

Here's a real-world workflow showing how agents use AlgoVault:

💡 Workflow #1: Quick BTC Check (Beginner)
"Get me a trade call for BTC on the 1h timeframe"

And here's what the live call returned just now:

Tool: get_trade_signal
Asset: BTC (Blue Chip)
Timeframe: 1h
Verdict: HOLD (35% confidence)

Price is down over 24h, the momentum term behind the call → bearish. Funding at +0.0089% sits in BTC's normal 14-day band: no crowd pressure either way. Becomes actionable if the breakout resolves.

This is what "call interpretation" means — we don't tell agents what to trade. We give them the analysis so they can decide.

📖 20 workflows like this in our docs: algovault.com/docs
📊 Full verified track record: algovault.com/track-record

Volume, gainers, losers, movers: choosing which perps an AI agent scans

AlgoVault.com — Tue, 25 Aug 2026 02:02:38 +0000

Intro

An AI trading agent that scans crypto perpetuals every few minutes spends most of its budget deciding what to look at. Scoring is cheap; universe selection is where a scan quietly succeeds or quietly wastes calls. In the first post of this series we covered the default open-interest lens and the liquidity floor — the "what is big" question. This post is about the other question a scan can ask: what is moving right now.

That question has four answers in the AlgoVault MCP surface: volume, gainers, losers, and movers. They are not synonyms. Each one selects a different slice of the market, and picking the wrong one is the difference between an agent that catches continuation and an agent that catches nothing. Our composite verdict is built on 91.7% PFE win rate · 509,055+ verified calls · Merkle-anchored on Base L2, and every one of those calls started with a universe decision like the one this post is about.

Big is not the same as busy

Open interest, the default lens covered in the earlier post of this series, answers a structural question: which perps carry committed capital right now. It is a slow-moving, high-signal filter, and it is the correct starting point for most agents most of the time.

The activity lenses answer a behavioural question instead: which perps are being traded right now, in which direction, and by how much. Big and busy overlap a lot at the top of the book — the majors are usually both — but the tail is where the two views diverge, and the tail is where the interesting setups usually live. An agent that only ever scans by open interest will keep re-scoring the same names every cycle. An agent that only ever scans by movement will chase noise on illiquid perps. The activity lenses exist so the scan can decide, per cycle, which of the two questions it is asking.

The rule of thumb we use internally: if the strategy is continuation (trend, breakout, momentum), the activity lenses tend to surface better candidates because they select for names where price is already in motion. If the strategy is mean reversion against a structural anchor, open interest and the liquidity floor tend to be safer, because you want the reversion to happen in a book that can actually absorb the position.

volume vs open interest — the one-sentence difference that matters

Volume is turnover — the notional that changed hands in a window. Open interest is the notional currently held. The one-sentence difference: volume can be inflated in ways open interest structurally cannot, because a single position can be opened and closed many times in a day, but it can only be held once. That is not a criticism of volume as a lens — it is exactly why volume surfaces different names than oiBasis. High turnover on a modest open-interest base is a real signal about who is present in the book right now, and that is often what a momentum agent wants to see.

gainers, losers, movers — three ways to ask "what is moving"

The three price-change lenses all read from the same underlying field — the venue's own 24h price change, reconstructed uniformly across venues so the number means the same thing whether the perp is on Binance, Bybit, OKX, Bitget, or Hyperliquid. What differs is the direction filter.

gainers — signed change, positive only. The top of this list is the perps that are up the most over the window. This is the lens for a long-biased continuation agent.
losers — signed change, negative only. The mirror. This is the lens for a short-biased continuation agent, or a mean-reversion agent hunting oversold candidates.
movers — magnitude regardless of sign. This is not the same as running gainers and losers and merging: movers orders by absolute change, so a perp down heavily and a perp up heavily can appear in the same slice, ranked together. It is the lens for a direction-agnostic scan that cares about volatility more than trend.

volume is the fourth option in the same family, ordering by 24h turnover rather than price change. It answers a different sub-question — where is participation right now — and the returned set often looks nothing like any of the three price-change lenses.

Implementation walkthrough — gainers, losers, movers, and the aliases

The MCP tool accepts the lens as a parameter on the scan call. The canonical names are volume, gainers, losers, movers, and short-form aliases are accepted so agent authors don't have to remember exact strings — enumerate them from the live tools/list schema rather than from a copy-pasted table, because that surface evolves.

Block 1 — install and first call, one lens, one venue:

npx -y @algovault/crypto-quant-signal-mcp@latest
# then, from your MCP client:
# call: scan_universe { "lens": "gainers", "venue": "binance", "timeframe": "15m" }

Block 2 — a real verdict returned by get_trade_call, which is what the scan calls per shortlisted asset once the lens has selected the universe. Notice the _algovault.quota block: the lens changed which assets were scored, not how many calls were billed.

{
  "call": "HOLD",
  "confidence": 1,
  "price": 79803.9,
  "indicators": {
    "funding_rate": 0.0000796,
    "funding_state": "NORMAL",
    "oi_change_pct": 4.79,
    "volume_24h": 18859152141.64,
    "trend_persistence": "MEDIUM",
    "breakout_pending": "INACTIVE"
  },
  "regime": "RANGING",
  "reasoning": "Regime is ranging with the moving averages inside the noise band. Funding sits in BTC's normal 14-day band: no crowd pressure either way. Turns directional if funding moves off neutral.",
  "coin": "BTC",
  "timeframe": "15m",
  "_algovault": {
    "version": "1.28.1",
    "tool": "get_trade_call",
    "exchange": "BINANCE",
    "quota": {
      "used": 67,
      "total": 200,
      "remaining": 133,
      "daily": { "used": 3, "total": 100, "remaining": 97 }
    }
  }
}

Block 3 — dropping the lens choice into an agent loop. The loop picks the lens dynamically based on the strategy the agent is currently running, calls the scan, then iterates the shortlist through get_trade_call:

# AlgoVault MCP example — coins=BTC confidence_threshold=70

[BTC] {
  "call": "HOLD",
  "confidence": 1,
  "price": 79803.9,
  "indicators": {
    "funding_rate": 0.0000796,
    "funding_24h_avg": 0.0000796,
    "funding_state": "NORMAL",
    "oi_change_pct": 4.79,
    "oi_change_window": "24h",
    "volu…

# DRYRUN_MODE=1 — example complete

The agent chose gainers because it was in continuation mode this cycle. Had the same loop been in mean-reversion mode, it would have swapped to losers (to find oversold candidates) or fallen back to the open-interest default from the earlier post. Nothing else in the loop changed — same timeframe, same confidence threshold, same billing behaviour.

A worked comparison: two lenses, same venue, different universes

The load-bearing evidence for this post is that the lenses genuinely return different universes. Run a scan for the top slice by volume and a scan for the top slice by gainers on the same venue at the same timeframe. In a healthy market, the two shortlists overlap on maybe the top majors and then diverge — the volume list will be dominated by BTC, ETH, SOL and whichever mid-caps are being churned that day, while the gainers list will be dominated by whatever mid- and lower-caps are actually running.

The BTC verdict above is a good honest example of what a volume-lens scan surfaces on a quiet day: a HOLD at 1% conviction, ranging regime, funding in the normal band. The lens did its job — BTC is genuinely near the top of the venue by 24h turnover — but the scoring correctly refused to fabricate a call where none existed. A gainers scan at the same moment would have surfaced a completely different shortlist, and if any of those names had cleared the confidence threshold, the agent would have acted on them instead. If, on a given cycle, the two universes happen to overlap heavily — because the whole market is moving together — the honest report is "these overlapped today", and the agent should behave accordingly rather than pretending it found distinct opportunities.

The closest_tradeable hint in the response (XRP 3m at 57% confidence) is the scan's way of saying: "nothing on your requested shortlist crossed the bar, but here is the nearest thing that did on the wider surface." That hint is lens-agnostic. It behaves the same whether you selected volume, gainers, losers, or movers.

Pitfalls — the lens is universe-selection, not ranking

Three honest gotchas worth calling out.

The lens does not re-order the output. Once the universe is chosen, verdicts are returned in confidence order, not in lens order. If you scanned by gainers and the top gainer scored 12% confidence while a smaller gainer scored 71%, the 71% call comes first. This is a common and reasonable misreading — the natural assumption is that "scan by gainers" means "results ordered by gain" — but it is not what the tool does. The lens picks the universe; conviction picks the presentation.

The lens does not change the bill. A scan of the top slice by volume and a scan of the top slice by movers both score the same number of assets and consume the same number of calls against your monthly allowance. If the strategy is direction-agnostic and you find yourself running both lenses back-to-back on every cycle, you are billing twice for what should be one decision — pick one, or alternate on a schedule.

A quiet lens is a real result. Sometimes the movers lens on a given venue at a given timeframe returns a set where nothing crosses your confidence threshold. The correct behaviour is to record the empty result and move on, not to loosen the threshold until something appears. An honest empty scan protects the composite; a scan that fabricates conviction under pressure is the failure mode we spent the most engineering time designing against.

Performance — what the composite shows across lenses

The reason to trust any of this is that the composite verdict has been measured across every lens against forward outcomes. The AlgoVault public track record aggregates all lenses, all venues, and all timeframes into a single PFE win-rate figure: 91.7% PFE win rate · 509,055+ verified calls · Merkle-anchored on Base L2. That number is not a per-lens boast — it is the aggregate honesty check on the whole surface, including the cycles where the scan returned nothing and the agent correctly did nothing. Full breakdown, per-window slices, and the on-chain proofs are on the track record page.

What's Next?

the track record — live PFE win rate, verified call count, and the Merkle anchors on Base L2
the docs — scan parameters, lens aliases, and the free-tier allowance
the GitHub repo — the MCP server source, issue tracker, and example agent loops
Earlier post in the scan-lens series: the open-interest default and the liquidity floor, on the AlgoVault blog
Next in the series: funding and volatility lenses — when to scan by crowd pressure vs. realised range

— AlgoVault Labs

⭐ Star the repo to follow new exchanges and signals: https://github.com/AlgoVaultLabs/crypto-quant-signal-mcp

AlgoVault MCP v1.28.1 — What's New

AlgoVault.com — Mon, 24 Aug 2026 06:47:28 +0000

AlgoVault MCP v1.28.1 is live

What's new:

Changed: Clearer tool descriptions across all seven tools, so an agent picking a tool has more to go on. get_trade_signal now points new integrations at get_trade_call, and scan_trade_calls' exchange parameter says plainly that it takes one venue.
Fixed: The LobeHub manifest's tool descriptions were out of step with the ones the server actually serves. All seven are now generated from the same source, and a test keeps them that way.
Fixed: /capabilities and tools/list gave different descriptions for get_trade_signal; the alias steering hint reached only one of them. Both now project from one source.

Now tracking 1744+ assets with 91.7% PFE Win Rate across 501,201 evaluated calls.

Upgrade now — remote agents get the new version automatically:

Remote MCP   https://api.algovault.com/mcp
npm          npx -y crypto-quant-signal-mcp@1.28.1

📖 Docs: algovault.com/docs
📊 Track record: algovault.com/track-record

Built by AlgoVault Labs — call interpretation for AI trading agents.

AlgoVault Weekly Trade-Call Report — Week of 2026-08-23

AlgoVault.com — Sun, 23 Aug 2026 12:00:04 +0000

AlgoVault Trade-Call Intelligence — Week of 2026-08-23

📊 504,386 trade calls tracked
🎯 PFE Win Rate: 91.7% across 1736+ assets (Hyperliquid)
🏆 Top performer: GILD 3m — 100.0% PFE Win Rate (10 evaluated)
📈 Confidence band 55-59 hitting 91.9% accuracy

All calls are on-chain verified (Base L2 Merkle root).

📊 Live track record: algovault.com/track-record
🔌 Connect an agent: algovault.com/docs
🛰 Set a standing scan in Telegram: t.me/algovaultofficialbot

Built by AlgoVault Labs — call interpretation for AI trading agents.

AlgoVault MCP v1.28.0 — What's New

AlgoVault.com — Fri, 21 Aug 2026 13:16:20 +0000

AlgoVault MCP v1.28.0 is live

What's new:

Added: _algovault.auth on every response: authentication outcome is now reported, not inferred. Absent, malformed, unknown and "could not verify" are distinct states.
Added: Documented assetClass (get_trade_call, get_trade_signal) and minLiquidityUsd (scan_trade_calls), projected from the live schema so the docs cannot drift from the server.
Added: An error-code reference and the scan_trade_calls response envelope in /docs.
Changed: A well-formed but unrecognised API key is now refused. Previously it was served free-tier data, which made a bad key indistinguishable from no key.
Changed: The published exchange enum lists only publicly served venues; retired and shadow venues no longer appear in the schema.
Changed: /docs no longer describes a multi-step handshake for the HTTP transport — it has been stateless for some time, and the samples now run as written.
Removed: BREAKING — EDGEX and WEEX are no longer accepted values for the exchange parameter on get_trade_call, get_trade_signal and get_market_regime. Calls passing either now return -32602 invalid_enum_value. EDGEX is retired and WEEX was never promoted; the published enum lists only publicly served venues. If you pinned either value, switch to a listed venue. Shipped under a minor because the change went live on the API on 2026-08-19 and neither value was ever documented.
Removed: The sample activity feed on /verify. The page shows verifiable batch data only.

Now tracking 1721+ assets with 91.7% PFE Win Rate across 493,418 evaluated calls.

Upgrade now — remote agents get the new version automatically:

Remote MCP   https://api.algovault.com/mcp
npm          npx -y crypto-quant-signal-mcp@1.28.0

📖 Docs: algovault.com/docs
📊 Track record: algovault.com/track-record

Built by AlgoVault Labs — call interpretation for AI trading agents.

Funding arb alert: CASHCAT showing 438.11% annualized spread

AlgoVault.com — Fri, 21 Aug 2026 12:00:13 +0000

Funding arb alert: CASHCAT showing 438.11% annualized spread

Live from AlgoVault's engine:

Top funding arb opportunities right now:

CASHCAT: 5 bps (438.11% ann.) — Long Bybit / Short HL | Urgency: HIGH | Conviction: MEDIUM

Scanned 1162 pairs across Hyperliquid, Binance, Bybit, Gate, KuCoin, Aster, and OKX. These spreads reflect cross-venue funding rate differences that delta-neutral strategies can capture.

⚠️ This is call interpretation, not financial advice. AlgoVault helps AI agents analyze — execution decisions are theirs.

🛰 Want this on your coins automatically? Set a standing scan: t.me/algovaultofficialbot
📊 See the full verified track record: algovault.com/track-record

Regime-aware trading with one composite verdict for AI agents

AlgoVault.com — Fri, 21 Aug 2026 02:03:13 +0000

Intro

If you have ever wired an AI trading agent to a raw indicator feed, you already know the failure mode: the RSI screams oversold, the MACD flips bullish, funding is neutral, open interest is climbing, and your agent has to somehow reconcile five conflicting stories into a single decision on the next candle. Most agents can't. They pick the loudest indicator and act — and then get chopped up the moment the market shifts regime.

That is the problem we built AlgoVault to solve. One composite verdict, regime-classified, cross-venue, with a public record: 91.7% PFE win rate · 497,194+ verified calls · Merkle-anchored on Base L2. We provide the thesis; your agent decides execution.

This post walks through why regime awareness matters, how our composite verdict encodes it, and how to wire it into an agent loop today. Full track record is at the AlgoVault track record page.

The problem: raw indicators lie about the market they are in

An indicator like RSI carries an implicit assumption about the market it is measuring. In a ranging market, RSI < 30 is a mean-reversion buy signal that works most of the time. In a strong trend, RSI < 30 is exactly where you get run over — the market is oversold because a real move is happening, and it will stay oversold for hours.

The same asymmetry haunts every technical input. Funding rate divergences mean one thing in a leverage-flush regime and something completely different in a slow grind higher. Open-interest expansion during a breakout is confirmation; during a range, it's a warning sign. Moving-average crossovers are magic in trends and noise in chop.

Agents that consume raw indicators have to encode all of this regime logic themselves, per asset, per timeframe, per venue. Most don't. The ones that try do it with brittle if/else stacks that need constant recalibration. The failure mode is silent: the agent looks like it's working until a regime shift reveals that its rules were fitted to the last one.

The competing tools in this space — TradingView alerts, raw indicator APIs, single-exchange feeds — all push this reconciliation problem onto the agent builder. That is fine if you have a quant team. It is not fine if you are one person shipping an autonomous strategy on a weekend.

The AlgoVault answer: composite verdict, regime-classified

AlgoVault's core primitive is a single call — get_trade_signal — that returns one of LONG, SHORT, or HOLD, with a conviction score, an explicit regime field, and a receipts block that shows exactly which factors contributed. The verdict is composite: it fuses momentum, funding, open-interest dynamics, trend persistence, breakout state, and volume into one interpretation, then labels the regime that interpretation was made under.

That last part is the piece agents cannot easily build themselves. When the response comes back with "regime": "RANGING", the classifier has already decided that mean-reversion-friendly logic applies. When it flips to TRENDING, the same underlying indicators get weighted differently. Your agent doesn't need to know how — it just needs to know the verdict and, if it wants to, the receipts.

This is Moat #1 (composite verdict quant weighting) tied to M2 (one verdict beats a stack of raw indicators). The proof that the weighting is real, and not just clever framing, sits at 91.7% PFE win rate across 497,194+ verified calls, every one anchored to Base L2 and independently auditable at the AlgoVault track record page.

Implementation walkthrough

Here is the end-to-end wiring. Three code blocks: install and first call, real API response, agent-loop integration.

Block 1 — install and first call

The MCP server is distributed via npx, so there is no long-lived install step. Point Claude Desktop or Claude Code at it and you get the get_trade_signal tool immediately.

# Add to your MCP client config (Claude Desktop, Cursor, Claude Code)
npx -y @algovault/crypto-quant-signal-mcp@latest

# Or call the remote HTTPS endpoint directly
curl -s https://api.algovault.com/mcp/get_trade_signal \
  -H "content-type: application/json" \
  -d '{"coin":"BTC","timeframe":"15m"}'

The free tier gives you 200 calls/month (also expressible as 100 calls/day), which is enough to prototype a full agent loop against live data without a signup gate.

Block 2 — real API response

Here is a verbatim response from get_trade_signal for BTC on the short-intraday timeframe. Note the regime field, the _receipts.factor_ledger showing every input the classifier considered, and the _algovault.quota block your agent can key on for rate-limit budgeting.

{
  "call": "HOLD",
  "confidence": 10,
  "price": 75108.2,
  "regime": "RANGING",
  "reasoning": "Price is sharply up over 24h, the momentum term behind the call → bullish. Funding at +0.0083% sits in BTC's normal 14-day band: no crowd pressure either way. Turns directional if funding moves off neutral.",
  "timestamp": 1787277610,
  "coin": "BTC",
  "timeframe": "15m",
  "_algovault": {
    "version": "1.27.0",
    "tool": "get_trade_call",
    "session_id": "v2:01a2631b198fb4f4",
    "exchange": "BINANCE",
    "quota": { "used": 59, "total": 200, "remaining": 141, "binding": "monthly" }
  },
  "_receipts": {
    "verdict": "HOLD",
    "conviction_pct": 10,
    "regime": "RANGING",
    "factor_ledger": [
      { "factor": "price_change_24h", "direction": "bullish", "strength": "primary" },
      { "factor": "funding_state", "direction": "neutral", "value": "+0.0083%" },
      { "factor": "regime", "direction": "neutral", "value": "ranging" },
      { "factor": "trend_persistence", "direction": "neutral", "value": "MEDIUM" },
      { "factor": "breakout_pending", "direction": "neutral", "value": "INACTIVE" }
    ]
  }
}

Read the receipts and the story becomes clear: momentum is bullish, but the classifier tagged the regime as RANGING, so a bullish momentum term alone is not enough to overcome the neutral funding and neutral trend-persistence terms. The composite verdict is HOLD at 10% conviction. That is exactly the behavior you want — selectivity, not enthusiasm.

Block 3 — agent-loop integration

Now wire it into a loop your agent actually runs. This is a minimal TypeScript client that polls the verdict, gates on regime and conviction, and hands off to your execution layer. Real terminal output from a dry-run of the example follows.

# AlgoVault MCP example — coins=BTC confidence_threshold=70

[BTC] {
  "call": "HOLD",
  "confidence": 10,
  "price": 75083.1,
  "indicators": {
    "funding_rate": 0.00008323,
    "funding_24h_avg": 0.00008323,
    "funding_state": "NORMAL",
    "oi_change_pct": 7.25,
    "oi_change_window": "24h",
    "v…

# DRYRUN_MODE=1 — example complete

The pattern most agents settle on: poll on the timeframe you care about, act only when call != "HOLD" AND confidence >= threshold AND the regime matches the strategy you deployed. A mean-reversion strategy consumes RANGING verdicts; a breakout strategy consumes TRENDING. Same endpoint, two agents, no glue code.

Pitfalls and design decisions

Three honest limits worth naming.

First, the regime classifier is not omniscient. Regime transitions — the exact moment a range breaks into a trend — are the hardest thing in this domain, and no classifier calls them on the first candle. You will see the label flip a candle or two after the move begins. The mitigation is not to fight it: build your agent to accept that regime is a lagging label on a leading market, and size positions accordingly.

Second, asset coverage. The composite verdict is strongest on liquid perp majors where every input has a clean signal. On thinly traded pairs, funding rate becomes noisy and open-interest deltas swamp the classifier. We publish the full asset coverage on the AlgoVault track record page with per-asset PFE win rates so you can filter your universe honestly rather than assuming the aggregate number applies to everything.

Third, the design choice we get asked about most: why one verdict instead of exposing the underlying indicator stack? Because the whole moat is the weighting. If we shipped the raw stack, we would be a slower indicator API. The composite verdict is the product, and every gram of complexity we hide from your agent is a gram your agent doesn't have to get right on its own.

Performance: what the receipts actually show

The _receipts.track_record block that ships inside every response is the same live figure you can verify at the AlgoVault track record page — 91.7% PFE win rate across 497,194+ verified calls in the current window, Merkle-anchored on Base L2.

The mechanic worth internalizing: PFE (peak favorable excursion) win rate measures whether a directional call would have hit its favorable target before its adverse one, within the timeframe the caller selected. It is a strict measure of directional correctness, and it is aggregate across every venue we cover. It is not a return figure, it is not a strategy backtest, and it is not investment advice. It is one thing: how often the composite verdict pointed the right way on the timeframe the caller asked about.

For an agent builder, that is the number that matters. If the thesis is right ~91.7% of the time on the timeframe your agent trades, your execution layer, position sizing, and risk management get to compound on top of a base rate that is doing the hard work. That is what "regime-aware" buys you in practice — not clairvoyance, but a base rate high enough that the rest of your stack has something durable to build on.

What's Next?

the track record — every verified call, Merkle-anchored, filter by asset and timeframe
the docs — MCP setup, endpoint reference, quota mechanics
the GitHub repo — the MCP server source, integration examples, issue tracker
Try free in Telegram — no API key, no signup, live verdicts in-chat

AlgoVault Labs

⭐ Star the repo to follow new exchanges and signals: https://github.com/AlgoVaultLabs/crypto-quant-signal-mcp

How an AI agent analyzes BTC with AlgoVault MCP

AlgoVault.com — Wed, 19 Aug 2026 12:00:03 +0000

How an AI agent analyzes BTC with AlgoVault MCP

Here's a real-world workflow showing how agents use AlgoVault:

💡 Workflow #1: Quick BTC Check (Beginner)
"Get me a trade call for BTC on the 1h timeframe"

And here's what the live call returned just now:

Tool: get_trade_signal
Asset: BTC (Blue Chip)
Timeframe: 1h
Verdict: HOLD (8% confidence)

Regime is trending up on the moving-average cross → bullish. Funding at +0.0041% sits in BTC's normal 14-day band: no crowd pressure either way. Turns directional if funding moves off neutral.

This is what "call interpretation" means — we don't tell agents what to trade. We give them the analysis so they can decide.

📖 20 workflows like this in our docs: algovault.com/docs
📊 Full verified track record: algovault.com/track-record

How to rank the crypto perp universe by open interest and the liquidity floor

AlgoVault.com — Tue, 18 Aug 2026 07:55:18 +0000

Intro

Most agent builders who call our scanner assume there is one fixed universe of perps behind it. There is not. Before any verdict is computed, scan_trade_calls first selects the universe it will look at, and that selection is a parameter you control. The choice of lens changes the output more than any confidence threshold does — and until now, we have not written about it.

This is part one of a three-part series on the scan lenses. It covers the default lens, oi (rank by open interest), and its companion parameter, minLiquidityUsd. It exists because a reader who does not know the universe is a choice cannot make a deliberate one.

The scanner sits on the same composite verdict engine as our per-asset endpoint, whose public record stands at 91.7% PFE win rate · 488,409+ verified calls · Merkle-anchored on Base L2. That engine does not change when the universe changes. What changes is what it is pointed at.

The problem: your agent is scanning the wrong universe

Here is the shape of the mistake I see most often. An agent builder wires up a scan-style tool, sees a ranked list of setups come back, and treats that list as the market. It is not. It is a ranked slice of some universe the tool chose for them — and in almost every scanner on the market, that universe is either turnover-weighted (24h volume) or fully undocumented.

Two things follow. First, the ranking silently biases toward whatever the tool's default sort surfaces — which, for most volume-ranked scanners, is whatever is being churned right now, not necessarily what is worth watching. Second, when the scanner returns a compelling setup on a thin book, the agent has no way of knowing the book is thin, because a per-call response does not carry a liquidity field. The agent trades a verdict it should never have been offered.

This is where the two parameters this post is about earn their existence. rankBy decides which perps are even in the running. minLiquidityUsd decides what floor of tradability they must clear to stay in. Neither touches the verdict engine. Both control the pond it fishes in.

If you separate universe-selection from scoring in your head, the rest of this post is common sense. If you do not, you will keep debugging the scoring layer for problems that live one layer up.

Open interest as the default lens (and why not volume)

scan_trade_calls defaults rankBy to oi — rank the universe by open interest on the venue you queried. This is a deliberate choice and worth explaining, because volume is the more common default in the wider tooling ecosystem and it is the wrong one for an agent's purposes.

Volume measures churn. Open interest measures commitment. A perp with high 24h volume and low open interest is telling you that a lot of paper has changed hands today; it is not telling you that anyone is holding conviction on the other side of the close. Open interest, by contrast, is capital sitting in positions right now. It is harder to fake — you cannot round-trip it with wash trades the way you can with volume — and it is a truer proxy for "this market has a real book behind it."

For an agent whose whole job is to decide whether a setup is worth entering, ranking by committed capital rather than churn is the more honest starting point. It biases the universe toward markets where the verdict, whatever it turns out to be, will be actionable.

That is why oi is the default. It is not the only sensible default one could pick — parts two and three of this series cover the activity and funding/volatility lenses, which are the right choice for different agent shapes — but if you have not thought about the question, oi is the answer you would arrive at if you had.

There is also a supporting parameter, oiBasis, which controls whether the ranking is done on notional open interest (contracts × mark price) or on contract count. Notional is what almost everyone means when they say "open interest," and it is the default. The contracts basis exists for one specific use: it is price-independent, so a sudden move in the underlying does not reshuffle the ranking. If you are running a scan on a fixed cadence and want a stable universe across price swings, contracts is worth knowing about. Most readers will never touch it.

Implementation walkthrough — one call, explained parameter by parameter

Here is the smallest useful scan_trade_calls invocation that makes the universe an explicit choice rather than a default. The floor is an example — pick your own; there is no recommended value.

import { Client } from "@modelcontextprotocol/sdk/client/index.js@^1.x";

const result = await client.callTool({
  name: "scan_trade_calls",
  arguments: {
    rankBy: "oi",
    oiBasis: "notional",
    minLiquidityUsd: 50_000_000,
    timeframe: "1h",
    limit: 10,
    confidence_threshold: 70,
  },
});

Reading that call, parameter by parameter: rankBy: "oi" names the lens — rank the universe by open interest. oiBasis: "notional" says use dollar-notional, not contract count. minLiquidityUsd: 50_000_000 is the floor — an example, chosen by you, that says do not include a perp in the universe unless its OI clears fifty million. timeframe: "1h" is the decision cadence: verdicts are computed on the timeframe you ask for, not on a fixed clock. limit and confidence_threshold cap and filter the result set after the verdict runs.

The response the verdict engine returns per asset is the shape you already know from get_trade_call:

{
  "call": "HOLD",
  "confidence": 8,
  "price": 64150.4,
  "indicators": {
    "funding_rate": 0.00004752,
    "funding_state": "NORMAL",
    "oi_change_pct": -2.56,
    "volume_24h": 8357528090.33,
    "trend_persistence": "MEDIUM"
  },
  "regime": "TRENDING_UP",
  "reasoning": "Regime is trending up on the moving-average cross → bullish. Funding at +0.0048% sits in BTC's normal 14-day band: no crowd pressure either way.",
  "coin": "BTC",
  "timeframe": "15m",
  "_algovault": { "version": "1.27.0", "tool": "get_trade_call", "exchange": "BINANCE" }
}

The scan wraps this shape in an array — one entry per asset that survived the universe selection and cleared confidence_threshold. Reading the result in an agent loop is the same one-liner you would use for a per-asset call, applied across the array:

# AlgoVault MCP example — coins=BTC confidence_threshold=70

[BTC] {
  "call": "HOLD",
  "confidence": 3,
  "price": 64150.4,
  "indicators": {
    "funding_rate": 0.00004752,
    "funding_state": "NORMAL",
    "oi_change_pct": -2.56,
    "volume_24h": 8357528090.33
  },
  ...
}

# DRYRUN_MODE=1 — example complete

Your agent iterates the array, reads call + confidence + regime on each entry, and routes execution accordingly. That is the whole ergonomic difference between a per-asset call and a scan: the scan handed you a universe of verdicts instead of one.

The liquidity floor, and why it has to live on the server

minLiquidityUsd is the parameter I most want readers to understand, because its design is honest in a way that is easy to miss.

The floor is applied server-side, and it has to be — this is not a stylistic choice. A per-call verdict response does not carry a liquidity field. It carries price, indicators, regime, reasoning, and receipts. Nowhere in that payload is there a number a client could inspect to say "this one is too thin, drop it." A client physically cannot post-filter for liquidity, because the client is never given the data it would need to.

That means one of two things is true of any tool that offers a liquidity filter. Either it is applied on the server, where the OI/volume data actually lives, or it is not being applied at all and the parameter is decorative. We chose the first. minLiquidityUsd is enforced inside the universe-selection stage: the ranking is computed, the floor is applied to it, and only the surviving assets are handed to the verdict engine. By the time the response reaches your agent, the floor is already a fait accompli.

That is why it is a real feature and not a client-side filter dressed up in server-side clothing. It is also why you should think of it as a universe parameter, not a quality parameter. It changes what the scanner is allowed to look at. It does not change how the scanner scores what it looks at.

Pitfalls — the proxy-venue caveat, and what the floor does not do

Two honest limits, both of which matter more than they look like they should.

The OI-proxy caveat. Not every venue exposes a bulk open-interest endpoint that would let us rank an entire perp universe by OI in one query. On the venues that do, the ranking is what you would expect: notional OI, sorted, floor applied. On the venues that do not, the tool falls back to 24h volume as the ranking basis — and labels that behaviour honestly in the response metadata rather than pretending the underlying number is OI. This is worth stating plainly because it is where most vendors would quietly conflate the two and hope nobody noticed. If you are building an agent that cares about the lens, read the metadata; the tool will tell you which basis was used. The named list of proxy-venues drifts as exchanges ship OI endpoints, which is why this post talks about the behaviour and not the roster.

The floor does not touch accuracy. This is the one that most surprises agent builders. minLiquidityUsd changes the universe. It does not change the verdict, it does not change the confidence, and it does not improve win rate on the assets that survive it. A reader who expects "higher floor = better calls" has been misled by the shape of the parameter. What a higher floor gets you is tradability — the surviving assets are ones your agent can actually enter and exit without moving the book. That is a real and useful property, and it is the only one the floor is claiming.

If you want higher-conviction calls, that is what confidence_threshold is for. If you want a tradable universe, that is what minLiquidityUsd is for. Do not use one for the other.

A third, smaller point: the floor is expressed in USD, which means on the contracts-basis ranking (oiBasis: "contracts") the tool still converts to notional internally to apply it. If you set the basis to contracts and set a dollar floor, you get the price-independent ranking you asked for, with the tradability guard you asked for, both. That is the sensible combination for cadence-driven scans.

Performance — what the data shows about the universe layer

Because the floor and the lens both sit above the verdict engine, they do not shift the engine's public record — that number is what it is, and it is what the receipts on every response point to. What the universe layer does shift is the composition of the calls counted in that record.

The visible effect, when you compare a scan run with the default oi lens and a modest floor against a scan run with no floor at all: fewer results, more of them on markets that carry real book depth, and a materially lower rate of HOLDs generated on markets whose thinness was already the reason they had no coherent regime. This is the shape you would predict. The verdict engine cannot resolve a regime on a market where nothing is committed to either side, so it returns HOLD honestly. The floor keeps those markets out of the universe in the first place. You do not get better verdicts; you get fewer wasted ones.

That is the case for using the floor deliberately even at modest values. It is not the case for treating the floor as a scoring parameter.

What's Next?

Parts two and three of this series cover the activity and funding/volatility lenses respectively — they are the right choice for agents with different shapes than the OI-default is built for. For now, go make one deliberate call and see the universe you actually asked for.

Verify the composite verdict engine's public record on the track record.
Read the full scan_trade_calls parameter surface in the docs.
Inspect the MCP server implementation on the GitHub repo.
Try the free tier with no signup on Telegram.
Read the companion piece on composite verdicts vs raw indicators.

— AlgoVault Labs

⭐ Star the repo to follow new exchanges and signals: https://github.com/AlgoVaultLabs/crypto-quant-signal-mcp