jev said itFollow on X

$JEVSAIDIT on Robinhood Chain. New questions every 6 hours.

Jevsaidit.

A model commits to a probability on-chain before anyone answers. You agree or disagree. When the price settles, the best-calibrated calls get paid in $JEVSAIDIT from trading fees.

Check a receiptRead the code
Not launched. The contract address goes up here and on @jevsaidit before launch. An address you see anywhere else first isn't ours.

So I aped.

The $JEVSAIDIT mascot: a pixel-art character with laser eyes, a backwards cap, a huge grin and a gold chain with a dollar coin

Receipts, not promises

The verdict is on-chain before your call is.

Every question is written as a small JSON receipt: the token, the deadline, the model, and the model's probability. Its keccak256 hash is the question's id, and the CallLedger stores that id before anyone can answer.

So the engine can't move the number after seeing the result. Edit the probability on the receipt and watch the hash stop matching.

Check any live question yourself, no trust in us needed:

curl -s \ https://www.jevsaidit.com/api/feed/q/<id>.json \ | tr -d '\n' | cast keccak
JEV SAID ITverdict receipt · epoch 12
SAMPLE · NOT A LIVE QUESTION
question
price up after 6h?
token
0x0000…1d17
calls close
2026-09-28 14:00 UTC
settles
2026-09-28 20:00 UTC
model
jev
baseline
0.5000 unmeasured
id stored by the CallLedger before calls opened0x59038cdd3992de81c166e7a5b91da2976afaf8796b107710ef871e1a661a12b7keccak256 of this receipt, right now0x59038cdd3992de81c166e7a5b91da2976afaf8796b107710ef871e1a661a12b7
show the exact bytes being hashed
{"baseline":"0.5000","baselineSource":"unmeasured","dataChainId":"4663","deadline":"1790604000","epoch":"12","horizon":"21600","kind":"A_PRICE_UP","ledger":"0x0000000000000000000000000000000000c0ffee","ledgerChainId":"4663","model":"jev","p":"0.6412","pool":"0x00000000000000000000000000000000000000000000000000000000000beef0","rule":"1 if the pool's sqrtPriceX96 (token per ETH), time-weighted by block over the `window` seconds ending at deadline+horizon, is strictly lower than the same average over the `window` seconds ending at deadline (a lower sqrtPriceX96 is a higher ETH price of the token); 0 otherwise; VOID if the pool has no Swap between deadline and deadline+horizon.","token":"0x00000000000000000000000000000000005a1d17","v":"2","window":"600"}
MATCH

Change Jev's probability. Try 0.9000.

Question · call · settle · score · pay

One epoch, start to claim.

Questions ask about the price of tokens that already graduated, measured when calls close. Nobody can answer after seeing the outcome.

  1. epoch e

    Open

    The engine picks Pons tokens that graduated in the last 48h and still trade. The model states a probability for each, and every question's hash goes on-chain.

  2. until calls close

    Call

    Agree or disagree. One call per 10,000 $JEVSAIDIT held at the start of the epoch, up to 50. Nothing is staked.

  3. close + 6h

    Settle

    The average price over the ten minutes before the close against the same average six hours later. Strictly higher counts as up. A price pushed in the last block barely moves an average.

  4. end of epoch e+1

    Score

    Brier skill against the committed baseline. The top 10% with a positive score and at least 3 resolved calls get paid.

  5. same block

    Root

    A Merkle root of the payouts goes to the rewards distributor. One epoch can spend at most 20% of its free balance.

  6. root + 12h

    Claim

    A guardian can veto a bad root for 12 hours. After that, winners claim their $JEVSAIDIT.

RESOLVED 0 / 1

Both prices were read. The question counts toward scores.

VOID

No swap in the window. Out of the scores, and listed as void in the feed.

UNRESOLVABLE

The engine couldn't read the chain. Out of the scores. Past 20% of an epoch's questions, that epoch pays nobody.

Scoring

Calibration pays. Volume of calls doesn't.

Each call becomes a forecast: agreeing takes the model's probability, disagreeing takes the opposite. It's scored against the baseline written into the receipt.

f = agree ? p : 1 − p brier = (f − y)² skill = (b − y)² − brier

y is the outcome, b the baseline. Probabilities are 4-decimal strings, so every score is exact integer math anyone can redo from the published receipts and events.

Five test wallets, one rule each. A full epoch on a local chain, 21 Sep 2026.
WalletWhat it didResult
U1Right on every call
U2Capacity 3: two right, one wrong
U3Always agreed with a model that was wrong half the timeSkill −0.16, nothing
U4Bought after the epoch started, made 5 calls0 valid calls
U5Team wallet, perfect answersNot in the scores at all

Where the fees go

Every split is a line of Solidity.

Creator fees from Pons arrive at the FeeRouter in ETH. Anyone can call distribute(). The keeper then buys $JEVSAIDIT with the swap share, burns part of it and sends the rest to the rewards distributor.

Winners are paid in $JEVSAIDIT, never in ETH. Once per epoch, at a time derived from a secret so it is hard to front-run, 65% of the fees buy $JEVSAIDIT on the open market. No wallet sits in between: the router buys and the distributor holds.

Your calls are counted from the $JEVSAIDIT you hold, so a prize is also next epoch's capacity. Sell it and you play less.

The buy is only as big as the volume. Quiet weeks mean small buys and small prizes. Nothing here promises a price.

No transfer tax. Splits change only through a 24-hour timelock, and each change is an on-chain event.

  • 50%Rewardsbuys $JEVSAIDIT, sent to the rewards distributor
  • 15%Burnbuys $JEVSAIDIT, sent to 0x…dEaD
  • 20%Teampaid in ETH, withdrawable only by the published team wallet
  • 10%OpsRPC, indexer, hosting
  • 5%Computemodel calls

This epoch

Live questions.

Straight from the engine's public feed. The model's accuracy against the baseline is published every epoch, including the epochs it loses.

GET /epochs/currentreading…

Reading the engine feed.

Play

Agree or disagree with Jev.

Connect a browser wallet on Robinhood Chain. Every 10,000 $JEVSAIDIT you held when the epoch started is one call, up to 50. All your calls go out in one transaction: you pay gas, you stake nothing.

The contract refuses a call beyond your balance, and the engine drops any call beyond what you held at the epoch's start. Buying, calling and selling in the same epoch does not count.

Reading the engine.

Commitments

Things this project won't do.

  • Pay for raw volume or airdrop by transaction count
  • Tax transfers. Fees only happen at the swap
  • Announce surprise buybacks on X. Buybacks run from the router, on-chain
  • Hold $JEVSAIDIT. The team is paid 20% of fees in ETH, so its pay stops when volume does
  • Publish another model's answer as “Jev said it”. Every verdict names the model that gave it
  • Turn “couldn't look” into an outcome