A multi-agent system that maps the global electronics supply chain as a knowledge graph. When an upstream node breaks — a fab offline, a line halted, a strait closed — Cascadr traverses downstream, scores who is exposed and how badly, and shorts the affected stock perpetuals on Bitget before the contagion is priced in.
Red nodes are downstream names the traversal flagged. Drag to explore.
A retail bot reads “Apple misses earnings” and shorts AAPL. So does everyone else with the same wire, and the edge is gone in seconds. The link between a Taiwanese fab and a US chip designer is not on the wire — it is buried in filings, and it takes a graph to walk it.
The retail loop
Headline names the ticker. Bot shorts the ticker. Thousands of bots short the same ticker off the same feed within the same second.
Apple misses earnings → short AAPL
Edge: decays in seconds · crowded
The Cascadr loop
Headline names an entity nobody trades. The graph says who depends on it, by how much, and through which component — so the trade lands on a ticker the headline never mentioned.
Quake halts TSMC Fab 18 → 92% of NVIDIA GPU dies are fabbed there → short NVDA perp
Edge: minutes to hours · uncrowded
Each stage hands a narrower, more decision-ready object to the next: filings become a graph, headlines become entities, entities become scored exposure, exposure becomes an order.
Ingests 10-K filings, supplier disclosures and customs data. An extraction chain resolves entity aliases — “Hon Hai”, “Foxconn” and “鴻海” are one node — and writes typed, weighted relationships:
(TSMC)-[:FABRICATES {component:'3nm', dependency:0.92}]->(NVDA)Subscribes to the wire. Named-entity recognition maps each headline onto graph nodes, then a classifier assigns a shock magnitude from severity, expected duration and scope. Below the confidence floor nothing propagates — the graph stays quiet on noise.
shock = f(severity, duration, scope) → 0.00 … 1.00
Breadth-first walk of the downstream cone to a depth of three. Each hop multiplies by that edge's dependency weight and decays, so a fab outage hits its direct customers hard and their customers faintly. The strongest path per target survives and becomes the rationale a human can read.
score = shock × ∏ dependency × decay^hops
Anything above the trade threshold is sized from its exposure and submitted as an isolated-margin market short on the tokenized equity. A deterministic clientOid keeps retries idempotent, and a risk gate blocks incremental orders in a name already at target weight.
POST /api/v2/mix/order · marginMode: isolated · side: sell
This is the scenario the terminal ships with — and the numbers below are what the engine actually computes, not illustrations.
The arithmetic
Resulting order
{
"symbol": "NVDAUSDT",
"productType": "USDT-FUTURES",
"marginMode": "isolated",
"side": "sell",
"orderType": "market",
"size": "175.37",
"clientOid": "cascadr-evt-001-nvda"
}No modals, no drill-downs. The wire feed, the graph, the ranked exposure and the order book sit side by side, so you can watch a headline become a position without losing the thread.
Raw wire in, resolved graph entities out, with confidence on every match.
Force-directed canvas. Nodes coloured by tier until they are hit, then by severity. Critical nodes pulse.
Every flagged name ranked by score, with the implied drawdown the model attaches to it.
The full reasoning trace — expand any EXEC line to read the exact Bitget request body.
Press RUN SCENARIO in the terminal to play the cascade live — roughly 25 seconds end to end.
This build is the frontend and the contagion engine, running on a curated graph. The backend services are scaffolded but not connected — stated plainly here rather than implied away.
| Layer | Technology | Status |
|---|---|---|
| Dashboard | Next.js 14 · React 18 · Tailwind | BUILT |
| Graph visualisation | react-force-graph-2d (canvas) | BUILT |
| News oracle (LLM) | OpenAI-compatible gateway · 0G Compute | BUILT |
| Contagion engine | TypeScript + Python, parity-tested | BUILT |
| Portfolio risk | cluster caps, per-symbol, drawdown halt | BUILT |
| Backend API | Python · FastAPI (graph, scoring, SSE) | BUILT |
| Market data | Bitget public v2 — live marks & contracts | LIVE |
| Filing ingestion | SEC EDGAR 10-K concentration extraction | BUILT |
| Order execution | Bitget stock perps — paper-gated | PAPER |
| Knowledge graph store | Neo4j repository + schema (unpopulated) | PLANNED |
Narrow mock boundary
The engine now runs server-side in Python, scored identically to the browser build and pinned by parity tests. What remains is data: point the Neo4j repository at a populated instance and replace the scripted wire with a live news socket. Execution is already a signed request — it is held back by a safety gate, not by missing code.
Honest disclosure
Marks and contract specs are live from Bitget's public API. Orders are built against real stock-perp symbols but never sent: paper trading is on by default and the backend refuses to disarm it without an explicit environment flag, credentials, and a notional cap. Neo4j is scaffolded but unpopulated. Supply-side dependency weights remain curated estimates — only filing-sourced edges are marked DISCLOSED. Nothing here is a trading signal.