How it works
Lock your rules, then the chain draws 3 past trading days and we replay them on Chainlink prices. Return ≥ +%, drawdown ≤ %, at least trades, no day below −% = pass. Pass and the firm funds, by hand while seats last, a USDG account your agent trades for trading days, % of the profit is yours.
Practice is instant and needs no wallet: the front page replays your rules on the last full session (—). The real exam locks your rules on Robinhood Chain first, so nobody can pick the days after seeing them. Accounts are small on purpose.
The rules (DSL)
One screen of JSON. Agents can send it directly; the English box on the site converts a sentence into it (see Parser).
universe1– symbols from .entry.when"drop": buy when the price is at leastpct% below the session open (the first Chainlink round at or after UTC)."rise": at leastpct% above it.pctis – in steps of .exittakeProfitPctandstopPct, both required, same range.sizePct–% of equity at entry. Long only. One entry per symbol per session.
Canonical form: keys sorted, no spaces, numbers without trailing zeros (1.0 becomes 1). rulesHash = keccak256(utf8(canonical JSON)). The hash of the example above is . Compute yours with node engine.mjs hash rules.json.
The replay
- Equity starts at 100 and carries across the 3 sessions.
- Per session, all rounds of your symbols are merged and sorted by time, then symbol.
- For each round: first the open position of that symbol is checked (take profit, then stop); then, if the symbol has no position and was not entered this session, the entry test runs against the session open.
- Fills happen at the price of the round that triggered them. A round can jump past your threshold; the fill is the round's price. There is no interpolation, no fee and no slippage in the exam.
- A position still open on the symbol's last round of the session closes there ("closed at session end"). Nothing is entered on a symbol's last round.
- A symbol with fewer than 2 Chainlink rounds in a session has no data that session: no trades, not a failure.
The engine is one file, engine.mjs, with no dependencies. The site, the grader and the runner all import it.
How dense is the data
Chainlink feeds for tokenized stocks on Robinhood Chain publish a round only when the price moves ≥ 0.5% (or after 24 hours). So the exam is event-driven per round, not per minute. Checked on-chain on 24 Oct 2026:
| Feed | Rounds in total | Rounds in Fri 23 Oct session | Thu 22 Oct |
|---|---|---|---|
| NVDA | 1,345 | 9 | 11 |
| TSLA | 1,730 | 17 | 20+ |
| AAPL | 805 | 3 | 6 |
| SPY (not in the exam) | 182 | 1 | 1 |
That is why the minimum pct is 0.5, why sparse symbols can show "no Chainlink rounds this session", and why a rule that finds fewer than trades in 3 sessions fails the trade-count check. Live round counts per symbol are printed with every practice run.
Feeds:
Pass conditions
| Return over the 3 sessions | ≥ +% |
| Max drawdown (peak to trough, at every round) | ≤ % |
| Trades | ≥ |
| Any single session | ≥ −% |
The score is the return in basis points (100 bps = 1%). The result is a pure function of your rules, the seed and the Chainlink rounds, so everyone gets the same number.
Why a replay
US markets are closed until Monday 13:30 UTC, and pool prices for tokenized stocks are thin at the weekend and can be moved by anyone. Chainlink rounds are public, fixed and carry a round id. Locking the rules first and drawing the days afterwards works at any hour and finishes in about a minute. It is a replay exam on real Chainlink prices, with days drawn after you lock your rules. It is not a forward test.
The draw
The pool is the last trading days before the day you commit (Mon–Fri, no NYSE holidays; the commit day itself is excluded). commit() stores drawBlock = block.number + . Anyone can call draw() once that block has passed; the seed is keccak256(blockhash(drawBlock), id). Session k is uint256(keccak256(seed ‖ k)) % , counting k up until 3 different days are found. The draw uses the chain's blockhash two blocks after your commit.
Honest limit: nobody who commits can influence that blockhash, but Robinhood Chain's sequencer (the chain operator) could in theory. The seed is public once drawn, and anyone can re-derive the sessions with vettorix-grade.mjs.
What the contract guarantees vs what the team does
Guaranteed by the contract
- Your rules are locked before the draw; the seed comes from the blockhash.
- A passed agent can only trade through its vault's writ.
- The desk can only move account money through
settle, which pays the payee its % of the USDG profit. - If a payee cannot receive USDG, the share waits in the desk and
claim()pays it. - When a token is set,
fundchecks the payee holds ≥ tokens.
A promise by the team
- Honest grading: you can re-run it, and the result hash is on-chain.
- Accounts are funded by hand from the firm's treasury while treasury and seats allow. Nothing is promised.
- The treasury is filled from the team's own money and creator fees, by public transactions, with no amount promised.
quashis for emergencies only (a misused agent key) and is always followed bysettle.
Contracts
- Desk: — (source verified on Sourcify, exact match)
- WritVault factory: . Accounts run on Writbound's WritVault factory, live on Robinhood Chain since 20 Oct.
- USDG:
Exam status (exams(id).status): 1 committed · 2 drawn · 3 failed · 4 passed · 5 funded · 6 settled. Statuses only move forward.
Functions: commit(rulesHash, agent, payee) anyone · draw(id) anyone · grade(id, scoreBps, pass, resultHash) grader key · fund(id) firm · settle(id) anyone after expiry · claim() payee · quash(id) firm (emergency) · sweep, setGrader, setAllow, setToken firm. Events: Committed, Rearmed, Drawn, Graded, Funded, Settled, Quashed, Claimed, Swept, GraderSet, AllowSet, TokenSet.
Team addresses: firm · grader · relay . Rounds are read from the Chainlink feeds, the draw from the chain; the grader key only posts the score you can re-compute.
Funded accounts
| Stake per account | USDG |
| Active accounts at once | max |
| Term | trading days (7 calendar days) |
| Per trade / per day | / USDG |
| Trading hours | – UTC |
| Slippage guard | % |
| Profit split | % payee / % desk |
The numbers above are read from rules.js and match the writ the desk passes to the factory (writOf()). The agent can only swap an allowed stock token against USDG through the pinned Uniswap v3 pool. When a trade breaks the writ the vault does not revert: it logs a Refused(seq, code) event in a successful transaction. Check the return code: execute returns (code, amountOut), 0 = filed.
| Code | Meaning |
|---|---|
| 1 | Quashed by the firm |
| 2 | Account expired |
| 3 | Outside trading hours |
| 4 | Token not allowed (a buy of a stock not on the list; sells are always allowed) |
| 5 | Over the per-trade limit |
| 6 | Over the daily limit |
| 7 | Not a USDG / stock pair |
| 8 | Slippage beyond the guard |
Profit counts in USDG only. Unsold stock at settlement is swept to the desk and not counted. Close your positions into USDG before the account ends. If the issuer pauses a stock token, it can stay in the vault, up to the size of the account (2 USDG).
Run an agent
The reference runner vettorix-runner.mjs (viem, about 150 lines) polls the Chainlink feeds of your universe every 20 seconds during the session, feeds each new round to the same engine, asks the vault for its TWAP quote, skips if the TWAP window is under 300 s or the spot price is more than 5% from the TWAP, and calls execute. It sells everything 15 minutes before the close. The vault, not the runner, enforces the limits: run anything you like with the agent key.
The English parser
The English box makes one call to through OpenRouter with a strict JSON schema, then validates the result with the same validate() as the engine. If the idea needs something the rules cannot say (shorting, indicators, time of day) it picks the closest rules and lists what it dropped. When the parser is down or its daily budget is used up, paste the JSON instead.
Rate limits
relay exams a day per person; practice a minute. Commit from your own wallet to skip the relay: the exam is the same.
Token
Practice is free. The real exam and a funded account need tokens in the payee wallet — checked by the desk contract when it funds. Creator fees pay for the server, the parser model, relay gas and the desk treasury — by hand, nothing promised. Before the token launches, no balance is needed.
Token address: at launch.
FAQ
Is the exam a backtest?
It is a replay on real Chainlink prices, of days drawn after you lock your rules. It tells you how the rules would have done on 3 past sessions. It says nothing about the future.
Can I choose the days?
No. The chain draws them from a blockhash after your rules hash is on-chain.
Do I need a wallet?
Not to practice, and not to sit the exam through the relay. You need a wallet to settle an account or to claim a payout that could not be sent.
What if I pass but nothing happens?
The firm funds passed exams by hand while treasury and seats allow. If all seats are taken or the treasury is below 2 USDG, it waits for a free seat. Nothing is promised.
Who gets the profit?
The payee address you gave, % of the USDG profit at settlement. The rest stays with the desk.
Can the team take the account's money?
Only through settle, which pays the payee first. There is no other function that moves an active account's USDG. You can read the source on Blockscout.
Disclaimer
Not affiliated with Robinhood Markets. Tokenized stocks, Uniswap pools and Chainlink feeds are public contracts on Robinhood Chain. Nothing here is investment advice, and a pass is not a promise of anything.