Nota, for judges

Nota enters all three tracks. Each section below stands on its own: what to open, what it proves, and the rubric line it answers. Every link goes to live data, never to a mock-up.

Do this, you should see

Do thisYou should seeRubric
uv run nota judgesix PASS lines: every receipt identical, every citation read back, every Bitcoin proof and Sigstore Rekor entry verifiedrepeatability
Dashboard: Verify in this browserverified here: your browser hashed the evidence, re-derived the receipt id and read every citation backT1 repeatability
Same receipt: What did this decision rest on?each input the rules read, removed in turn, and which ones block or resize the tradeT1 cause and effect
Same receipt: Change it and check (tamper)refused: the edited evidence no longer hashes to the receiptcoping with failure
Drill: RYO downfailed sections kept as failed, values null, no tradecoping with failure
ScorecardRYO's own plans settled on OKX candles, every miss countedcombining sources, T2
Same receipt: Find the edgethe smallest move in each number (and in the judge's probability) that turns the trade into no trade, each row checkable with the what-ifT1 cause and effect
uv run nota reproduce <id>seven PASS lines for a receipt fetched from this public site: evidence hash, id, citations, anchor, sizing, Bitcoin proof, Rekor entryrepeatability
Statussix objectives with error budgets counted from the ledger (two are spent while RYO's allowance is out, and say so), a spoken briefing, and how each token's belief movedcoping with failure, works for everyone
Model cardintended use, out of scope, factors and metrics, every number computed from the ledgerreal thinking
uv run nota verify-cardthe Agent Card's Ed25519 signature: validT3 follows spec

replay badge, computed live Bitcoin anchors badge, computed live Brier badge, computed live SLO badge, computed live

This site is public and read-only; the source repository is private to the judges. uv run nota serve --demo serves every page here from the shipped ledger.

One minute, three clicks

  1. Open the dashboard. The newest receipt is already open: read its five-line summary, then press Verify replay to re-run the call from its stored evidence.
  2. Open the scorecard: its first paragraph says whether RYO's own verdict predicts how its trade plans end.
  3. Open the failure drill and press RYO down: the pipeline keeps missing values empty and refuses to trade.

Or check every claim on your own machine, with no key: uv sync, then uv run nota judge. It replays every receipt, reads every citation back from its evidence, checks every Bitcoin proof against the stored bytes, checks every receipt came from RYO, checks every receipt's Sigstore Rekor entry offline, and scans the git history for credentials: six PASS/FAIL lines in about 20 s. uv run nota serve --demo serves this site from the shipped ledger.

The honest result so far

The council is not yet better than a coin flip. Over the 82 scored calls where the council met (as of 2026-11-10), the judge's Brier score is 0.243 (0.25 is always saying 50%; lower is better). That is why the code, not the model, pools the agents by their measured calibration, caps the model's confidence at the pooled council's, and checks every number in its prose against the evidence; live figures at /api/scores. Against always-0.5, persistence, RYO's verdict, the base rate and each single LLM on the same questions (Brier Index, head-to-head log scores with t intervals, leave-one-agent-out, the calls where Nota and RYO disagreed, cost): /scorecard and /api/benchmarks.

Found, measured, not yet adopted. A walk-forward recalibration, each call re-predicted by a fit on the calls resolved before it, scores 0.233 against the raw 0.251 on 51 calls out of sample (it lost on the first 39). Its slope of 1.77 says the council is underconfident, and its intercept that prices fell more often than it said. The decision rules adopt nothing from it until the scores are readable: 20 independent weeks, 15 so far (/api/scores → recalibration).

What we say before you find it. On the 32 scored calls where both took a direction, the council agreed with RYO's own call every time (both 63% right; /api/scores → vs_ryo): so far it has added checks and sizing discipline to RYO's view, not a different view. The falsifier tally's "held" means "not proven wrong": of 36 practice trades graded, 1 reached its target, 5 hit their stop and 30 touched neither (falsifiers.trade_exits). And Murphy's decomposition puts the council's weakness in calibration: prices rose in a third of those weeks while its stated chances sat near a half.

Tested, not only scored (/api/scores: paired_tests, reliability.bins[].consistency_90; /api/scorecard: multiple_testing). A Diebold-Mariano test, flipping the sign of whole token-weeks, of the judge against the base rate, 82 calls in 15 token-weeks: Brier difference +0.0046 (p = 0.9011), log score +0.0088 nats (p = 0.9087): no difference the data can tell from chance; against the prediction market, 69 calls in 12 token-weeks: Brier difference -0.0119 (p = 0.5908), log score -0.0244 nats (p = 0.5962): no difference the data can tell from chance. Broecker-Smith consistency bands: 3 of 3 reliability bins sit outside the 90% band a calibrated judge would land in (stated 0.35, happened 0.0, band 0.091-0.636; stated 0.502, happened 0.244, band 0.366-0.634; stated 0.651, happened 0.433, band 0.5-0.8). On the scorecard at 72 h, 0 of 10 tests (each contrast on two measures) are distinguishable one by one and 0 after a Benjamini-Hochberg false-discovery correction.

Every track (common 40)

RubricOpen thisWhat it shows
Combining sources · 20receipt 0d9469f115d1, Evidence provenance Five RYO tools plus the independent checks (exchange prices, recomputed RSI/ATR, OKX positioning, DefiLlama liquidity, prediction markets, narrative voices, news) in one evidence pack, argued over by three agents and a judge. Code then holds the judge to the evidence: RYO's price must agree with the exchange median within 2%, and RYO's call limits the size (see a receipt's "Checked in code" card).
Coping with failure · 202ae531ec2c9b (RYO answered 401) and c60acf3ba3b1 (RYO deep_analysis down for three days) The run still completes, records which section failed and why, and refuses to trade. A missing value stays null; nothing is filled in. Settlement kept running through both; every lock attempted during the deep_analysis outage is counted as a ryo_unavailable line, none of them as a plan. Or break it yourself: the failure drill injects twelve failures (RYO down, 401, deep_analysis missing, rate limits, exchanges down, model down, partial answers, a prompt injection, edited evidence, a forged receipt, a restart mid-run, the practice book past its drawdown limit) into the real pipeline, offline, beside a healthy run.

How the pipeline coped, from the ledger (/api/resilience):

  • Scorecard: 69 lock attempts RYO refused and 23 cycles aborted (80× HTTP 400, 8× HTTP 429, 4× HTTP 502); 506 symbols skipped, none turned into a plan. 380 RYO answers came back partial; 380 locks recorded as no plan.
  • Receipts: 96 of 159 sealed on degraded evidence; RYO sections 201 error, 103 partial, 61 unavailable, 20 of them rate-limited. 67 trades blocked for missing evidence, 62 receipts with no forecast.
  • Exchanges: 13 of 772 price quotes missing, left out of the median.
  • Retries are not stored, so not counted.
SocialFi (sponsor theme)/feed, /api/reputation Public reasoning feed with each agent's stance and the dissent, X share links and receipt cards; backers and the council's agents ranked on one hit-rate scale (unranked until 20 calls over 20 independent token-weeks); a public watchlist and a profile per handle (/u/<handle>). Handles are unverified claims.

Track 1 · Autonomous Agents

  1. Run it yourself. In the dashboard, "Run the council live" gathers fresh RYO evidence and convenes the council on any symbol (one to two minutes, capped per visitor).
  2. Agent vs agent. The feed marks every call where the agents split, names who dissented and quotes why; the reputation board scores those agents beside the humans who backed them.
  3. Proven wrong, or not. Every long or short states, before the fact, the price that would prove it wrong (the trade's own stop, or the decision price at seven days), and is graded against it; the tally is at /api/scores under falsifiers, with how the held trades actually ended.
  4. Verify in this browser. On any receipt, the evidence bytes are hashed by your own browser (Web Crypto), the receipt id is re-derived from that hash, and every citation is read back from the same bytes: every shipped receipt and every one of its citations pass, and nothing the server says about itself is trusted.
  5. Ask RYO again now. Any stored decision can be re-run on evidence gathered live, with every input and cited value shown then and now; the verdict stays fixed and no model is called.
  6. Challenge a call. On any receipt, change an evidence value the rules read or a rule itself (ATR multiples, minimum edge, risk) and see whether the decision holds; the model's verdict stays fixed.
  7. Chaos switch. "Run the council live" can force any one RYO tool to fail, as a 429 or an outage, while every other call is real.
  8. Real thinking (25). Open any receipt: each agent cites dotted paths into RYO's answer, and the value shown is read back out of the evidence, not retyped by the model. Citations to paths that do not exist are dropped in code, and since 2026-11-06 every number written in the agents' prose is looked up in the evidence too: one with no match is shown in red on the receipt.
  9. Cause and effect (20). The "Checked in code" card pools the agents' probabilities by their Brier weights, applies a stated rule, and says when the judge deviated; the trade's edge is the smaller of the two, so the model can lower the council's confidence but not raise it. "What changed" ranks every evidence move since the previous receipt by impact; the derivatives gate withholds RYO fields that are not about the token. "What did this decision rest on?" on every receipt removes each input the rules read, one at a time, and shows which ones block, unblock or resize the trade.
  10. Repeatability (10). Press Verify replay: the decision is rebuilt from the stored evidence and prints identical: true. Offline: uv run nota replay <id>. Each receipt is also anchored in Bitcoin (OpenTimestamps).
  11. Advanced (5). Practice trades sized from ATR, and closed at whichever of their own stop and target OKX's hourly candles touched first; a twice-daily ledger cycle in CI; every agent scored by Brier against the token's own base rate.
  12. The spotlight idea, built. The multi-KOL agent reads up to 20 voices (X, Telegram, Bluesky), finds the tokens they name with sentiment, conviction and urgency, and opens a practice position only when the voices converge and every user rule passes. Each rule is shown with the value it read and its threshold; the stop comes from RYO's ATR, and with no RYO evidence there is no trade. Stored runs replay offline: uv run nota kol-replay <id>. X voices fall back to Tavily search when X refuses, marked "coverage partial".

Track 2 · Dashboards & Interfaces

  1. Easy to read (25). Open the dashboard: each receipt starts with a five-line summary (now, biggest change, position, what RYO said, next step).
  2. Sorted by importance (25). "Needs attention" sits on top; "What changed" is sorted by impact; the scorecard puts the next settlements first.
  3. Works for everyone (10). Keyboard only: j/k, Enter, p, /, ?. Skip links, checked contrast, reduced motion, light and dark, and a Japanese overview.
  4. The organiser's "Tech Indicator Interface" idea. /indicator: write a rule, get a live validation message pointing at the character at fault, pick an example, preview where it held over the window (chart and bar-by-bar table), then let the tab re-check it every minute or more and log each flip. The monitor is labelled as what it is: a timer in that browser tab, with no notification sent anywhere.

Track 3 · New Skills

  1. Fills a gap (25). positioning_check: RYO reports open interest and funding, but some of those fields carry the same value across unrelated tokens. The skill checks RYO's derivatives against OKX for the token and withholds what is not token-specific.
  2. Follows the spec (15). Every skill returns RYO's envelope (status, data_mode, availability, warnings) at RYO's own path shape: GET /api/skills/, POST /api/skills/{name}/invoke. Try one in the dashboard's "Run a skill".
  3. Fills a gap, the organiser's own idea. wallet_risk is the "Scam Wallet Detection" build idea: GoPlus flags, the OFAC sanctions list, ScamSniffer's blacklist and Blockscout's record for one address, side by side, with the sources that disagree named. Try it in "Run a skill" with 0x098B716B8Aaf21512996dC57EB0615e2383E2f96 (the Ronin bridge exploiter: sanctioned, while the explorer still says "ok").
  4. The organiser's "Tech Indicator" idea. indicator_check runs a user-defined condition such as rsi(14) < 30 and close > sma(200) or crosses_above(ema(12), ema(26)) on live closed 1h, 4h or 1d candles (OKX, else Binance) and returns whether it holds, every value it used and where it held over the last bars. The rule is parsed by a hand-written tokenizer and recursive-descent parser, never evaluated as code; a bad rule is a 422 naming the character at fault (nota/skills/indicator_check.py, tests/test_indicator_check.py).
  5. How RYO adopts a skill. Two skills are packaged to lift out in one step: contrib/positioning_check/ and contrib/move_base_rate/. Copy the folder, then app.include_router(router) from its fastapi_router.py; check it with uv run pytest -q contrib/positioning_check contrib/move_base_rate, which runs offline on recorded answers (the suite refuses the internet). That every skill answers in RYO's envelope is itself tested: tests/test_mcp_server.py::test_the_output_schema_is_the_envelope_every_recorded_ryo_answer_fits and tests/test_sources_price.py::test_every_skill_speaks_ryos_availability_vocabulary.
  6. Could we use it (20). contrib/positioning_check/ in the repository is a drop-in: no Nota imports, a FastAPI router RYO can include, and its own tests. The same skills are an MCP server at /mcp and an A2A agent, including verify_receipt, so another agent can check a Nota receipt without a key.

Original here, and common ground

Common ground. Hash-linked receipts, replaying a decision from stored evidence, timestamping it, and scoring forecasts by Brier are established techniques; other entries in this field use them too, and Nota does not claim them as new.

Original here, each with where to check it:

WhatCheck it
It keeps RYO's score. Every day Nota asks RYO about 25 majors and locks every verdict and trade plan it gives, each lock timestamped in Bitcoin so none can be backdated, then settles them on OKX candles at 24 and 72 hours, every miss counted. Since 2 Oct that is six plans a day: for the other 19, deep_analysis answers partial with no indicators and so no plan, and each is counted. A call RYO does not answer is counted as ryo_unavailable, not skipped. /scorecard, /api/scorecard.csv, nota/scorecard.py
Two public witnesses, checked offline. Bitcoin (OpenTimestamps) and Sigstore's Rekor log; the Rekor signature, inclusion proof and signed timestamp are verified against a pinned key, with no call to Rekor. uv run nota judge (anchors, rekor), nota/rekor.py, tests/test_rekor.py
The proof runs in your browser. Web Crypto hashes the evidence, re-derives the receipt id and reads every citation back; the server's word is not needed. Dashboard: Verify in this browser; tests/test_landing_numbers.py
Seventeen skills in RYO's own envelope, on RYO's /api/skills paths, as an MCP server and over A2A with an Ed25519-signed Agent Card (price, technicals, positioning, base rates, liquidity, prediction-market odds, wallet risk, Chainlink and DEX order flow, and more), two of them packaged for RYO to lift out (Track 3). /api/skills/, /mcp, Agent Card, contrib/

Also here:

Limits are listed plainly in LIMITATIONS.md, served here as written in the repository.