The edge an AI agent cannot compute on its own but can consume in one call: decision-ready seasonal patterns, ML-scored, over REST and a hosted MCP server. Seasonal patterns only. The forward-tested track record is public, so your agent can audit us before it trusts us - no signup, with the public demo token tw_demo_explore.
No signup to try it: tw_demo_explore is a public demo token - a real call in about 30 seconds. The forward-tested track record is open to audit on the free tier.
We will concede what most pitches hide: a capable coding agent can write a seasonality backtest in minutes. The averaging is grade-school math, the calendar logic is a loop, and the agent will produce a green equity curve on the first try. That is exactly the problem. The math is easy. Being right is not. A backtest is only as honest as the four things underneath it, and those are where an agent that builds its own quietly fails.
TradeWave exists for the gap between a backtest that runs and a backtest that is true. We do not sell the math. We sell the data integrity, the methodology discipline, the trained model, and the one asset that cannot be faked after the fact - and we deliver all four as a finished, detected seasonal pattern, not a research project.
Point an agent at one ticker and it can tell you whether that ticker is seasonal. That is not the hard part. The hard part is the question you actually have every morning, across everything you could trade: which securities are at the START of a seasonal window today, and which are worth it.
TradeWave answers that daily. We scan the whole tradeable universe - hundreds of securities across 15 markets - surface only the ones entering their seasonal window now, and rank them by Sharpe ratio and the length of the pattern. That is a standing pipeline compiled over decades of licensed data and refreshed every day, not something an agent spins up on a whim. By the time an agent rebuilt the scan, the window it was looking for has moved.
A trading agent has a finite context window and a token budget, and every token it spends rebuilding a data, methodology, and track-record problem is a token it is not spending on your actual strategy. Hand it raw rows and it has to fetch, clean, average, guess at adjustments, and reason its way to a verdict - slowly, expensively, and with real hallucination risk at every hop.
TradeWave returns a Pattern Card: one self-describing object that already contains the answer. The agent reads a finished verdict and its receipts instead of deriving one. Less context consumed, fewer tokens burned, far less room to hallucinate a number that the data never supported.
A skeptical agent evaluating vendors should not take a marketing claim on faith, and we built for exactly that agent. The forward-tested track record is queryable, on the free tier, before any commitment. Your agent can pull the receipts and decide for itself whether the edge is real.
This is the difference between trust-me and verify. The record was published in advance and scored later, so there is nothing to retrofit. An agent can audit it in a single request and then make an informed recommendation to its user instead of an act of faith.
TradeWave is MCP-native: 17 tools - 6 opinionated flagship tools that each return a finished, evidence-backed answer, plus 11 low-level primitives for the rare case where you need one exact slice. The model reaches for one flagship tool and gets a ranked set of Pattern Cards back; the primitives stay available underneath. The flagships are find_best_opportunities, analyze_symbol, explain_pick, morning_briefing, whats_seasonal_now, and compare_opportunities.
Progressive disclosure keeps the token bill honest. Every flagship tool takes a view knob. view=decision is the DEFAULT lean read over MCP - the verdict and the few numbers a decision turns on, nothing else - so a scan does not flood the context window. view=table returns compact one-line rows for a shortlist you want to skim or rank. view=full returns the complete card with every receipt: years tested, wins and losses, per-year returns, best and worst year, and the Trend Chart curve. Concrete loop: call find_best_opportunities (decision) to see what is starting its window, then analyze_symbol(symbol, view=full) on the one you like to pull the full receipts. The raw REST API defaults to view=full; MCP defaults to decision.
Run the research loop, do not take a number on faith. Call describe_tradewave FIRST: it self-documents the seasonal-plus-ML method, a SEASONAL ANALYSIS KNOBS glossary, and per-market coverage, so the agent knows what every field means before it leans on one. Then every Pattern Card carries an extend_research block that names exactly what TradeWave is BLIND to - fundamentals, valuation, news, catalysts, macro and rates, analyst views, earnings dates, and the live price - and what to verify with your OWN tools. So the loop is: read the card, take the seasonal pattern and the ML score and the timing from TradeWave, then use your web, news, and earnings tools to check the things the card told you it cannot see, and synthesize one view. TradeWave is a research partner, not the whole answer.
Prefer chat-and-agent runtimes? Point them at the hosted MCP server. Building a backend service? The REST surface returns the same server-composed cards. One source of truth - the gateway composes every card; nothing is recomputed client-side.
Evaluating this as a data buyer rather than a builder? The licensing story is the quiet superpower.
The fastest path is to let your coding agent do the wiring. Point Claude Code or Cursor at the machine-readable spec and the llms.txt, hand it the prompt below, and it will scaffold a typed client against the flagship endpoints, wire the auth header, and respect the seasonal-patterns-only contract without you reading a line of docs.
Because the API is self-describing - OpenAPI plus llms.txt plus self-describing Pattern Cards - the agent has everything it needs to integrate correctly on the first pass.
Integrate the TradeWave seasonal research API into this app. TradeWave provides decision-ready ML-scored seasonal patterns - seasonal patterns only (percentages and a normalized 0-100 seasonal index, never raw prices); do not expect or store any price levels.
Read these first and follow them exactly:
- OpenAPI spec: https://developers.tradewave.ai/docs/openapi.yaml
- Agent guide (llms.txt): https://developers.tradewave.ai/llms.txt
Base URL: https://api.tradewave.ai/v1
Auth: send the header `Authorization: Bearer tw_live_...` on every request. Read the key from a TRADEWAVE_API_KEY environment variable; never hardcode it.
Build a small typed client wrapping these endpoints:
- GET /v1/scan -> ranked Pattern Cards across in-scope markets (the "what should I trade now" call)
- GET /v1/analyze/{symbol} -> one rich Pattern Card for a symbol (best setup + receipts + order ticket)
- GET /v1/daily-pick -> today's pick as a Pattern Card
- GET /v1/daily-pick/track-record -> the live forward-tested record of past picks (use this to display verifiable proof; it works on the free tier)
- POST /v1/score -> ML scores for a list of setups (metered daily; on the free tier 5/day, on ML-eligible markets only)
Contract requirements:
- Treat the Pattern Card as the unit of truth. Render `headline` and `verdict` as-is; do not recompute or re-rank cards client-side.
- Keep these two fields strictly distinct and labeled separately: `historical_win_rate` (share of profitable years - a frequency) and `ml_win_prob` (the model's predicted probability). Never merge them or call both "win rate".
- Handle the neutral bias: when a card's bias is neutral there is no order ticket - show the verdict, do not invent a trade.
- Handle graceful tier nudges: a 200 response with `requires: "upgrade"` (e.g. reason `ml_daily_limit`) is NOT an error - surface the message and `ml_remaining_today`, do not throw. Free-tier scope is S&P 500 stocks; out-of-scope markets return the same graceful upgrade nudge, not an error.
- Surface the disclaimer on any card you display.
- Use the order ticket (side, type, time_in_force, entry/exit dates) for any "place trade" affordance; it has no price level, so do not add one.
Deliver: the client, types/models for the Pattern Card and TrackRecordSummary, a config check that fails fast if TRADEWAVE_API_KEY is unset, and one example call to GET /v1/scan that prints the top card's headline plus its historical_win_rate and ml_win_prob.