# Limitations

What Nota does not do, or does only partly. Each item says where it shows.

## Keys and the hosted demo
- A council decision needs one LLM key, and live RYO evidence needs the builder key. Verifying a
  receipt, the scorecard and most skills need neither.
- The hosted demo reads a ledger snapshot (`data/demo.db`) that the ledger cycle commits, because a
  serverless filesystem cannot be written. It is as fresh as the last cycle: at most an hour old for
  settlements, and once a day for new decisions (a second pass only retries a day that failed).
- "Run the council live" on the hosted demo does not store its receipt in that snapshot. Its roles
  are weighted 1.0 rather than by their record, and the response says so. Each address may run it
  3 times an hour, and all visitors together 20 times an hour.
- Backings go to Postgres (Neon, free tier) on the hosted demo. In a plain clone with no
  `DATABASE_URL`, they go to the ledger's own table.
- What is public and what is not: since 2026-11-10 the hosted deployment (https://nota-ryo.vercel.app) is
  public and read-only, serving the committed ledger snapshot, so anyone can open every receipt, replay it
  through the API and read the scorecard. The source repository stays private: the hackathon's terms
  forbid open-sourcing a submission without RYO Digital's written approval and assign the work to RYO
  Digital. So a visitor can check every receipt's bytes and proofs but not read the code that made them;
  judges, who hold the repository, can do both (`uv run nota judge`, `uv run nota serve --demo`). The
  hosted copy is only as fresh as its last ledger commit (see Ledger freshness), and its live buttons
  (Ask RYO now, the KOL run) spend the deployment's own RYO and model allowance under a per-visitor and
  shared hourly cap.

## Failure drill
- `/drill` runs on the newest live SOL receipt in the ledger that sized a trade: RYO's stored answers for it,
  the five exchange prices price_check read that day, and that receipt's own council output from its real
  model, served from the ledger, so no model or exchange is called. The failures are injected at the HTTP
  layer under the real client, and waits are counted, not slept. The council's output is the one it gave
  on the healthy evidence; under a fault the code re-checks its citations against the faulted evidence
  rather than asking the model again. Its receipts say `source: drill` and are never stored or scored.

## SocialFi
- Handles are unverified claims. The first write under a handle holds it with an edit token kept in
  that browser; nothing ties it to the X, Discord or Telegram account of the same name, and a lost
  token cannot be recovered.
- Reputation is a hit rate on directional calls, not a Brier score, because a backer states no
  probability. No row is ranked until 20 calls over 20 independent weeks, so the board is mostly
  "too few to read" for now.
- Writes are limited per address per hour, not per person.
- The ActivityPub actor (`acct:nota@nota-ryo.vercel.app`) is read-only: it can be looked up and its outbox read,
  but it accepts no follows (`POST /ap/inbox` answers 405) and delivers nothing, because the hosted deployment
  stores nothing. The Farcaster embed is the `fc:miniapp` tag only; no signed `farcaster.json` manifest is served.
- "What would flip it" searches a grid of moves and then bisects, so it finds the nearest flip on that grid, one
  input at a time; it does not search combinations, and it holds the model's verdict fixed.
- The status page's objectives are counted from the ledger, which records outcomes, not attempts: retries and
  request latency are not stored, so there is no latency objective.

## Sources
- `x:` voices are best effort. X's public syndication endpoint has answered `HTTP 429` to ordinary
  connections since 2026-09-10. The fallbacks and how much each one covers are listed in
  `docs/skills/SKILL-SPEC.md`, and every fallback a run takes is named in that run's warnings.
  `tg:` and `bs:` voices answer directly.
- When X refuses, an `x:` voice is read through Tavily search, which sees only the posts its index
  holds and drops any without a date. Such a voice is marked `coverage partial`, so a multi-KOL
  signal built on it may have missed posts that would have broken the convergence.
- The multi-KOL agent's practice trades are not settled yet. A KOL trade counts as an open position
  for seven days and then ages out, rather than closing at its stop or target.
- RYO's optional token-profile lane is often `partial` or `unavailable`. Nota keeps it as RYO
  reports it and never fills it in.
- Some RYO derivatives fields carry the same value across unrelated tokens on the same day. The
  gate withholds them, so on those days the technician sees less derivatives evidence.
- Some exchanges (Coinbase, Kraken) are blocked from some networks. When fewer exchanges answer,
  `price_crosscheck` reports fewer, and an answer is never invented for one that failed.

## Statistics
- Brier weights move only once calls reach their seven-day horizon, and then only by n/(n+20) of
  the way. Every table beside them shows how many of its calls come from independent weeks.
- The scorecard began on 18 September 2026 and so far covers one market regime. Its contrasts read
  "not yet distinguishable" until ten lock days exist on both sides.
- In settlement, a stop and a target touched within the same minute stay `ambiguous` rather than
  being ordered by guess. A lock whose RYO price is more than 2% away from OKX's is kept but never
  settled.
- The "What changed" ranking is a documented heuristic, not a model.

## Scope
- Read-only. Nota never places an order, and practice trades exist only in its ledger.
- This is not financial advice. The trades are practice trades.

## What the proofs do and do not prove
- Replay, OpenTimestamps and the Rekor log prove that a receipt was not changed after it was made and
  existed by a given time. They do not prove that a particular model produced the council's output: the
  model's answers are stored and replayed, not re-executed in attested hardware.
- A Rekor entry is signed with a key made for that entry and discarded. It proves the digest was logged by
  `integratedTime`; it says nothing about who logged it. Authorship rests on the receipt's own replay.

## Practice P&L
- Practice trades are never executed. Their P&L is shown before and after an assumed 0.2% round-trip cost
  (0.05% taker fee and 0.05% slippage per side); real fills, funding and fee tiers would differ.
- The record is weeks old. The scorecard prints sample sizes and p-values and calls nothing
  distinguishable below its thresholds; a longer record is the only cure.
- The drawdown kill-switch counts realized P&L only. Open positions are marked on the last receipt's
  evidence price, which can be days old, so they are shown beside the equity but not booked into it.
- `score_forecasts` resolves on OKX like `nota resolve`; its offline tests replay Binance hourly candles
  converted into OKX's row shape (OKX is DNS-blocked on the machine that recorded them), labelled as such.

## Ledger freshness
- The ledger grows from a scheduled GitHub Actions cycle. Since 2026-11-09 Actions does not start on this
  account (billing), so cycles are run by hand and committed; the hosted copy is only as fresh as the last
  such commit. RYO itself answered 502 on 2026-11-09, so that day's locks are counted as `ryo_unavailable`.
  On 2026-11-10 RYO answered `RATE_LIMITED: MCP call allowance exhausted` (our key's monthly allowance, which
  other teams hit the same week): the lock stopped after three counted failures, and SOL's and BTC's receipts that
  day carry no forecast because `deep_analysis` never answered.
