Curiosity is the starting point.
Six AI agents run a trading desk the way scientists run a lab. They read the market, argue it out, size every position under hard limits, and log every decision where anyone can see it. The desk is open right now. Watch it work.
The target architecture is 33 NVIDIA DGX Spark units, stacked as three columns of eleven. Each unit hosts six specialist agent roles, 198 in total. This is the phase-two build target; the engine that will run on it is live today.
Next The build order is deliberate: benchmark the real workload on one or two units first, then scale to 33 against measured demand. NVIDIA documents pairing two units over ConnectX-7; we design for 33 independent workers on a shared job queue, which scales one machine at a time.
Six agent roles does not mean six separate models. Role separation is a matter of prompts, tools and permissions, not silicon. That is what lets the same engine run on one machine today and thirty-three later.
One model asked to "trade well" produces confident mush. Six roles with separate inputs, separate outputs and separate scorecards produce an argument you can inspect, and one of them is allowed to end it.
Reads news, macro releases and asset-level events. Every claim carries a source and a date, or it does not count.
Market structure, trend and levels, and above all the exact price at which the thesis is simply wrong.
The trade tape and the book: delta, volume by price, depth, liquidity, and candidate absorption where aggressive orders meet a wall.
Takes approved orders and gets them filled: entries, exits, spread, fees, slippage. It reports the cost of being right.
Journals every decision, including the decision to do nothing, and grades them after costs. Flags strategy decay before the equity curve does.
Exposure, position size, loss limits. VETO does not offer an opinion. It returns approve or reject, and reject is final. Its limits are arithmetic in code, not instructions in a prompt, so no model can talk its way past them. An agent that wants a bigger position can want it indefinitely.
Two rules sit above all six. "Do not trade" is a valid, recorded outcome. Most cycles end there, and that is the system working. And agreement between agents is never treated as evidence: six models trained on overlapping data agreeing is a correlation, not a confirmation. Only the after-cost result counts.
One cycle per bar. Analysis is free, risk is enforced, everything is written down.
Candles, trade tape and buy/sell split land in a shared context. The same snapshot for every agent.
ATLAS, EUCLID and FLUX each file an independent report: stance, confidence, findings, invalidation.
A proposal forms only when structure and flow agree and fundamentals do not strongly object. Otherwise: no trade.
VETO sizes the position from the distance to invalidation, or rejects it. Code, not judgement.
HERMES fills it with fees and slippage charged. LEDGER journals the cycle, trade or not, and scores it after costs.
Most AI trading demos fail in the same place: the model is asked to respect a risk limit, and eventually it doesn't. We removed the possibility.
The risk engine is ordinary code with no model in it. It receives a proposal and returns a decision. There is no prompt to jailbreak, no confidence score to inflate, no persuasive argument that changes the arithmetic.
# risk.py: the veto is arithmetic, not judgement def review(self, p: TradeProposal, bar) -> RiskDecision: if self.halted: return RiskDecision(False, ["VETO: daily loss limit"]) if bar < self.cooldown_until_bar: return RiskDecision(False, ["VETO: loss-streak cooldown"]) if p.confidence < MIN_CONFIDENCE: return RiskDecision(False, ["VETO: below confidence floor"]) stop_dist = abs(p.price - p.invalidation) if stop_dist < p.price * MIN_STOP_DISTANCE_PCT: return RiskDecision(False, ["VETO: stop inside noise"]) # size is DERIVED, never proposed by an agent qty = (equity * MAX_RISK_PER_TRADE) / stop_dist return RiskDecision(True, reasons, qty=qty, stop=p.invalidation)
Position size is derived from the distance to invalidation. No agent proposes a size, so no agent can inflate one.
Six agents on the floor, one market, one rule: every call gets logged. This is the desk as it stands right now, refreshed every cycle. Paper execution for now; real capital is the next phase.
What the numbers prove: the machine holds. Every limit enforced, zero breaches, hundreds of cycles where the desk correctly stood aside. That discipline is the product. The P&L is what it compounds on, and every run gets published, the good ones and the rough ones, because that is how a desk gets sharper.
Connect a Solana wallet to follow the build from the inside. It is read-only by design. Here is exactly what that means.
Three things, and only three: it shows your public address, shows your SOL balance, and, if you choose, asks your wallet to sign a message you can read in full, proving you control the address. That is all it can ever do.
Thirty-three consecutive sessions. One public report per day: the hypothesis, what the agents said, what the risk engine did, and the result after costs: win, loss, or nothing at all.
The challenge is a commitment to publication, not to profit. Losing days are published at the same size and on the same schedule as winning ones. If the strategy degrades, the audit agent's flag goes in the report. If a day ends with no trade taken, that is the report. The only failure condition is silence.
Paper The challenge runs on paper with real market data. Any move to live capital happens with a published decision, never a quiet switch.
Every piece of GENIUS, and its current state. Updated as things go live.
| Component | Status | Notes |
|---|---|---|
| Six-agent research pipeline | Live | Runs locally, deterministic, reproducible |
| Risk engine & veto | Live | Pure code, enforced on every cycle |
| Paper broker (fees + slippage) | Live | All P&L reported after costs |
| Decision journal & audit metrics | Live | JSONL, one entry per cycle |
| Lab console & this site | Live | Static, no backend required |
| Market data | Live | Live BTC-USD candles, trade tape and level-2 depth from a public exchange API; synthetic fallback if unreachable |
| Fundamental news inputs | Live | Live headlines, scored and time-gated so no bar sees its future |
| LLM reasoning layer | Next | Next up. Models will read and interpret; every number and limit stays in code |
| Order-book depth / DOM | Live | Level-2 snapshot each run, recorded to disk; continuous streaming is planned |
| Daily automated run | Live | GitHub Actions: tests, live run, commit, redeploy. No servers, no keys |
| Wallet connect (Solana) | Live | Read-only: public address, balance, message-signature ownership proof. Never requests a transaction signature, enforced by a build test |
| Footprint & replay tooling | Next | Studied against public references; nothing proprietary copied |
| Futures order-flow data | Later | Phase three, once the edge is demonstrated on the current market |
| 33× DGX Spark cluster | Later | Phase two. Benchmark on one or two units, then scale to 33 |
| Live execution | Later | After validation: out-of-sample edge across two market regimes first |