Kadoa's AI sell-off dashboard compares live market drops to historical crashes spanning 1929 to 2022. The interface looks simple: a chart showing the S&P 500 down 5.7% after 23 trading days, overlaid with lines for the Great Depression (-86%), the 2008 crisis (-57%), and COVID (-34%). Behind that chart sits an agent workflow that must solve three hard problems: normalize heterogeneous crash data across a century of market structure changes, query live feeds without triggering false alarms on every 2% dip, and present context-aware signals that distinguish noise from the start of a genuine crash.

This is not a trading execution agent. It is a monitoring and alerting system that must balance speed, accuracy, and historical context. The plumbing matters because financial monitoring agents face different failure modes than execution agents: they cannot afford to cry wolf on every volatility spike, but they also cannot wait for confirmation that arrives too late to act.

The Normalization Problem

Comparing a 1929 crash to a 2026 sell-off requires agents to handle:

  • Trading hour conventions: 1929 markets closed at 3 PM; modern markets run until 4 PM with after-hours trading until 8 PM.
  • Market cap scales: The S&P 500 in 1929 represented ~$90B in today's dollars; in 2026 it represents ~$45T.
  • Liquidity regimes: Circuit breakers introduced after 1987 halt trading at 7%, 13%, and 20% drops; pre-1987 crashes had no such speed bumps.
  • Data granularity: Daily closes for historical data, but tick-level feeds for live monitoring.

Kadoa's dashboard uses "trading days since record" as the x-axis, not calendar time. This choice reveals the agent's normalization strategy: it anchors every crash to a record high (T=0) and measures decline in trading sessions, not wall-clock hours. This sidesteps the trading-hour problem but introduces a new one: how does the agent decide when a new "record high" starts a fresh monitoring window?

The likely pattern:

  1. State machine: The agent maintains a current_peak variable and a days_since_peak counter.
  2. Peak detection: On each market close, if close > current_peak, reset both variables. If close < current_peak, increment days_since_peak.
  3. Crash threshold: When (current_peak - close) / current_peak >= 0.06, the agent enters "crash monitoring mode" and begins historical comparison.

This avoids triggering on intraday noise but creates a latency problem: the agent cannot detect a crash until the market closes. For a dashboard updated daily, this is acceptable. For a real-time alert system, it is not.

Real-Time Query Orchestration

The dashboard claims "daily data updates," which suggests a hybrid architecture:

  • Historical data: Pre-computed and cached. The 1929-2022 crash trajectories are static; they do not change.
  • Live data: Queried from market APIs (likely Polygon, Alpha Vantage, or a Bloomberg terminal feed) at market close.
  • Comparison logic: Runs after the live query completes, matching the current decline against the cached historical trajectories.

The orchestration flow likely looks like this:

# Pseudo-code for Kadoa's crash monitoring agent  async def monitor_crash(symbol: str, current_peak: float): while True: # Wait for market close (4 PM ET)  await wait_for_market_close() # Query live close price  live_price = await fetch_live_close(symbol) # Calculate decline from peak  decline_pct = (current_peak - live_price) / current_peak days_since_peak = get_days_since_peak() if decline_pct < 0.06: # Not yet in crash territory  continue # Load historical crash trajectories  historical = load_cached_crashes() # Find matching trajectories at same day count  comparisons = [ crash for crash in historical if crash.days_elapsed == days_since_peak ] # Emit alert if current decline exceeds N% of historical crashes  if decline_pct > percentile(comparisons, 0.75): await emit_alert(symbol, decline_pct, comparisons)

The key decision: when does the agent query live APIs vs. cached snapshots? The answer depends on the data freshness boundary. For daily monitoring, querying at market close is sufficient. For intraday alerts, the agent would need to poll every 5-15 minutes, which introduces rate-limiting and cost constraints.

Kadoa's existing infrastructure (web scraping API, real-time data extraction) suggests they likely use a polling agent that queries live feeds at market close and caches the result for the next 24 hours. This keeps API costs low but sacrifices intraday responsiveness.

Anomaly Detection Without Overfitting

The hardest problem: how does the agent avoid false positives on routine volatility while still catching the start of a genuine crash?

The dashboard shows 56 historical declines of 6% or more since 1928. Of those, 44 never reached -20%. This means a naive "alert on 6% drop" rule would have a 78% false positive rate.

The agent needs a context-aware threshold that considers:

  • Velocity: How fast is the decline happening? A 6% drop in 2 days is more alarming than 6% over 20 days.
  • Volatility regime: Is the VIX elevated? Are other indices (Nasdaq, Russell 2000) declining in parallel?
  • Sector concentration: Is the decline driven by one sector (e.g., chips down 36%) or broad-based?

Kadoa's dashboard tracks chip stocks separately, which suggests the agent uses sector-level decomposition. The likely pattern:

Component Weight Threshold Action
S&P 500 decline 0.4 -6% Monitor
Nasdaq decline 0.3 -10% Alert
Chip stock decline 0.2 -20% Escalate
VIX spike 0.1 >30 Context flag

The agent computes a weighted score and compares it to historical crash trajectories at the same days_since_peak offset. If the score exceeds the 75th percentile of historical crashes at that point, it triggers an alert.

This approach reduces false positives but introduces a new failure mode: regime shift blindness. If the current crash follows a pattern not seen in the historical data (e.g., a flash crash driven by algorithmic trading), the agent will underestimate the severity until it is too late.

Failure Modes

Financial monitoring agents fail in predictable ways:

  1. Stale data: If the live API feed lags by 15 minutes (common for free-tier APIs), the agent's "real-time" signal is already outdated.
  2. Survivorship bias: The historical crash dataset only includes crashes that eventually recovered. A true market collapse (e.g., a currency crisis) might not follow the same trajectory.
  3. Threshold drift: As market volatility increases over time, a fixed 6% threshold becomes less meaningful. The agent needs to recalibrate thresholds based on rolling volatility windows.
  4. Sector skew: If the S&P 500 is heavily weighted toward tech (as it is in 2026), a chip stock crash will disproportionately affect the index. The agent must normalize for sector concentration.

The most subtle failure mode: alert fatigue. If the agent triggers too many "crash detected" alerts that resolve within days, users will ignore future alerts. The optimal strategy is to delay alerts until the decline persists for N days, but this introduces latency that defeats the purpose of real-time monitoring.

Architecture Sketch

A production-grade crash monitoring agent would likely use:

  • State store: Redis or DynamoDB to track current_peak, days_since_peak, and alert history.
  • Time-series DB: InfluxDB or TimescaleDB to store historical crash trajectories and live price feeds.
  • Orchestrator: Temporal or Prefect to schedule daily market-close queries and retry failed API calls.
  • Alert sink: Webhook to Slack, PagerDuty, or email for human-in-the-loop review.

The data flow:

Market API → Polling Agent → State Store → Comparison Agent → Alert Sink ↓ ↑ Time-Series DB ← Historical Loader

The comparison agent runs as a scheduled workflow that triggers at 4:05 PM ET every trading day. It queries the state store for the current peak, fetches the latest close from the time-series DB, computes the decline percentage, and compares it to cached historical trajectories. If the decline exceeds the threshold, it emits an alert and updates the state store.

Technical Verdict

Use this pattern when:

  • You need to monitor financial time-series data for anomalies without triggering on routine volatility.
  • You have access to reliable historical data and can normalize it across different market regimes.
  • Your users tolerate daily update latency (market-close monitoring, not intraday alerts).

Avoid this pattern when:

  • You need sub-minute alert latency (use a streaming architecture with Kafka or Flink instead).
  • Your historical dataset is sparse or biased (e.g., only includes US equities, ignoring international markets).
  • You cannot afford false positives (use a human-in-the-loop review step before emitting alerts).

The core insight: financial monitoring agents must trade off speed, accuracy, and context. Kadoa's dashboard optimizes for context (historical comparison) at the cost of speed (daily updates). For a public-facing tool, this is the right trade-off. For a hedge fund's internal alert system, it is not.

Source Links