Regime-aware trading with one composite verdict for AI agents

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