How a call is scored

Amgis scores public forecasts posted on X against the Kalshi price at the minute they were posted. Hitting a call the market already gave 80% scores little; hitting one it gave 15% scores a lot.

Engine: running on real postsProgram: not deployedToken: not launched

Everything below describes the engine behind every number on this site, under rule r2. The Solana program that will hold the hourly roots is written and tested but not deployed yet, so no root has been posted and there is no program address yet. The new token is not minted yet. Nothing on this page is investment advice, and Amgis is not affiliated with Kalshi or with any account shown.

How it works

One post travels left to right. Every post read gets a verdict, so the counts on each account add up: posts read, calls found, calls scored and calls not scored by reason.

X postslast 90 days Readerfilter p2, AI x3, c3 Matcherm4, one market Pricer2: A, B, C Scoreat settlement Kalshi minutesmirrored, hashed Leavesevery verdict Hourly rootNext: on Solana
StageWhat it doesRuns where
ReadOriginal posts and quote posts from the last 90 days, at most the latest 1,000 per account. Text only: replies, reposts, images and video are not read. In a quote post only the quoting account’s own words count.our server
DecideA keyword filter keeps posts that look like a forecast on something Kalshi lists. An AI reader decides call or not a call; the model id and prompt versions are stored with every verdict.our server
MatchExactly one Kalshi market and side: same subject, same date, same number. Anything looser is “no exact market” and is published, not scored.our server
PriceThe call time comes from the post id. A, B and C come from Kalshi’s one-minute data; the largest is used.our server, checkable in your browser
Score100 if the called side happened, else 0, minus the price used. Integer basis points.our server, checkable in your browser
FixWhen each UTC hour ends, every verdict new or changed in that hour becomes a leaf; the Merkle root goes to our Solana program.Next: on chain once deployed

What counts as a call

A call is committed wording about one outcome Kalshi lists. The rule is strict on purpose: a confident tone is not a commitment.

CountsDoes not count
“will”, “won’t”“likely”, “favored”, race ratings, however confident
“my pick”jokes, questions and conditionals (“if he plays”)
an outlet’s “best bet”posts that relay someone else’s forecast

Repeats and flips

One account holds one call per Kalshi event. Saying it again is a repeat and is not scored. A flip closes the held call at the market price at the flip (its score is close minus open, whatever the result) and opens the new one. YES at 15%, then NO when YES is at 40%: the YES call closes at +25 and the NO call opens at 60%. Hit rate counts only calls held to settlement.

The price at the call

The price is the market probability of the side the account called, read from Kalshi’s one-minute data: the midpoint of yes bid and yes ask. A minute counts only when Kalshi sent data for it and both quotes exist. Nothing is carried forward.

ValueWindowWhy it is there
Aaverage of the counted minutes in the 60 minutes before the call minutewhere the market stood
Baverage of the last 5 counted minuteswhere it stood just before the post
Chighest value for the called side from the call minute to 60 minutes afterX allows edits for an hour and the data has no edit history
usedthe largest of A, B and Ca larger number is always worse for the caller

Run it on a real call

@RealSkipBayless called “Denver wins” during the game, posted Nov 2, 2026 at 00:22 UTC. The market moved fast around the post, which is exactly what C is for.

price.js, the rule r2 core (same integer math as the engine)
const rd = (n, d) => Math.floor((2 * n + d) / (2 * d));   // round half up
// a: counted A-window midpoints for the called side, in basis points
const A = rd(a.reduce((s, v) => s + 2 * v, 0), 2 * a.length);
const last5 = a.slice(-5);
const B = rd(last5.reduce((s, v) => s + 2 * v, 0), 2 * last5.length);
const C = Math.max(...c);                 // c: counted C-window midpoints
const used = Math.max(A, B, C);
Output for the Denver call
A 2064   B 3410   C 9150   used 9150   (60 counted before, 15 after)
LineMeaning
A 206420.64%: Denver was the underdog across the hour before the post.
B 341034.10%: the price was climbing in the last 5 minutes.
C 915091.50%: the highest price for Denver within the hour after. The market closed 15 minutes after the post.
used 9150The call is scored as a 91.50% call. Denver won, so it scores 100 − 91.50 = +8.50.

When a call is not priced

Not scored, with the reason published: fewer than 10 counted minutes in the hour before (thin quotes), an average spread wider than 10 points (illiquid), volume under 1 contract in that hour or open interest under 1,000 contracts (low activity), or a void market.

The score

Edge points per call = 100 if the called side happened, else 0, minus the price used. A 15% call that hits scores +85. An 80% call that misses scores −80. The math is integer basis points and is shown with two decimals.

On the first screen and in the app, a score is a step: up from the waterline for a call that beat its price, down for one that did not. An account’s steps added in order are its total edge, and zero means it did exactly as well as the market’s odds implied.

Hourly roots

When each UTC hour ends, every verdict new or changed in that hour becomes a leaf. The Merkle root, the leaf count, the scored count and the rules hash go to our Solana program. Hour numbers only go up, only finished hours can be posted, nothing is overwritten, an empty hour posts a zero-leaf root, and a root more than an hour late shows as “late”.

PartDefinition
Leaf hashSHA-256(0x00 || canonical JSON of the leaf)
Node hashSHA-256(0x01 || left || right); an odd node at the end of a level is carried up unchanged
Orderleaves sorted by leaf_id = post_id:claim_idx:seq
Canonical JSONkeys sorted, null fields left out, no spaces, integers only
Empty hourroot = 32 zero bytes
Texta leaf holds a salted hash of the post text, never the text
Foundeach leaf says how its call was found: tracked, late-found or backfilled

A call found is published even if the post is gone before its root. Once a posted root holds it, deleting the post does not delete the call (“Post unavailable”). Accepted corrections go into a later root as a new leaf that supersedes the old one; old roots stay.

Roots are built when each UTC hour ends. Posting starts with the first hour after the program is deployed.

Verify it yourself

Server judgment (call or not, and the market match) is marked “server judgment, report if wrong”. Everything else can be recomputed without trusting us.

Point at a call

The call time is in the post id
const X_EPOCH_MS = 1288834974657n;
const callMs = Number((BigInt("2117049658476532160") >> 22n) + X_EPOCH_MS);
new Date(callMs).toISOString();
Output
"2026-11-02T00:22:26.118Z"

Recompute from Kalshi

The published Node script needs nothing but Node 18. For a call, it fetches the minute candles straight from Kalshi, checks that they hash to the leaf’s price_file, and recomputes A, B, C, the price used and the score. For an hour, it rebuilds the Merkle root from the leaf file and, given an RPC URL and the root’s transaction signature, compares it with the value on chain.

Terminal
node verify-amgis.mjs call <post_id> <leaf file>
node verify-amgis.mjs hour <leaf file> [rpc-url tx-signature]

Download verify-amgis.mjs. Leaf files are public at /data/leaves/<YYYY-MM-DD>/<HH>.json and the mirrored Kalshi responses at /data/mirror/<sha256>.json. The app’s Check step runs the same call-time, price, score and root checks in your browser on any call, and rebuilds any hour’s root against the chain.

When a check fails

A different call time means the post id was copied wrong; ids are exact. A different A, B or C means the candles did not hash to the leaf’s price file, or the call was scored under an earlier rule version; the leaf names its rule_version. A root that does not match the chain is the one case that matters most, and it is the reason roots go on chain at all.

On chain and off chain

NextThe program is written and tested and not deployed; its id appears here once it is. This is what it enforces and what stays with our server, which anyone can check.

Enforced by the chainDone by our server, checkable by anyone
Only the record key posts a rootReading posts and deciding call or not
Only a finished UTC hour, by the chain clockMatching one exact market and side
Each hour greater than the last posted; no overwriteMirroring Kalshi minutes, each response hashed into its leaf
Config changes wait out a timelock of 7 to 30 daysComputing A, B, C and the score, recomputable from the mirror or Kalshi
Only the lock owner deposits, requests a withdrawal and withdrawsPublishing every leaf file

Keys and the worst case if one leaks

KeyCanWorst case if it leaks
Record keypost the next hour’s rootA false root for a new hour. It cannot rewrite a posted hour, and anyone rebuilding that hour from the public leaf file sees the mismatch.
Config adminpropose config changes, set the token mintA change that waits on chain, in view, for the timelock before it applies, and can be cancelled in that time.
Upgrade authorityco-sign initialize, upgrade the programReplacing the program code. Who holds it is published with the program id.
Your walletdeposit to and withdraw from your own lockA withdrawal request on your lock, which still waits 3 days before it pays out.

Public API

The live site answers these without a wallet. /api/health makes a live call to Kalshi’s exchange status on every refresh, so it shows whether the data source answers right now.

PathReturns
GET /api/healthKalshi status and latency, the AI model in use, the last built and last posted hour root (with “late”), the lookup queue, the program id and token mint once set, totals
GET /api/boardaccounts with at least 10 settled calls, with counts and backfilled share
GET /api/accounts/:handleone account’s record and every call
GET /api/calls/:postIdone call’s receipt: market, side, minutes, A, B, C, score, leaf
GET /api/hourshour roots and their transactions
GET /api/rulesthe rule text and version history
GET /api/sceneevery account’s record and every priced call in one read (the first screen and the app use it)
GET /data/leaves/<day>/<hour>.jsonone finished hour’s leaves and root
GET /data/mirror/<sha256>.jsonthe exact Kalshi response a call was priced from; its SHA-256 is the leaf’s price_file

Read-only API key

The third lock tier and the Pro plan include a key that reads your own wallet’s data: GET /api/v1/me, /api/v1/watch and /api/v1/inbox?after=<id>, sent as Authorization: Bearer <key>, up to 60 requests a minute. Make it in the app under Limits; it is shown once and Amgis keeps only its hash. A key cannot change anything, and it pauses while the wallet has neither the tier nor the plan.

Measured so far

The engine’s database, read live:

–reading the record

Beating a liquid market is hard, and most edge is lost on confident calls that miss.

The token

Not launchedA new token will be launched for Amgis. No contract address exists yet; any address you see before this page shows one is not ours. There is no price, market cap or holder count before launch.

Launched$AMGIS mint: . Any other address is not ours. Check any holder’s lock.

The token works through a lock in our program. The locked share of supply sets your limits. Each deposit counts after 24 hours; a withdrawal request stops counting at once and pays out after 3 days; only the owner withdraws.

Locked share of supplyAccounts watchedLookups a dayAlerts withinAlso
none (wallet sign-in)3––
0.01%101015 min
0.05%50305 min
0.2%2001005 minread-only API key for your own watch list and inbox

The token pays nothing out; locking only changes limits. Anyone can check an address on the holders page once the mint is set: its lock deposits, tier and limits, recomputed in the browser from the chain. Supply and the unlock schedule are published here at launch.

What is thin

  • The first boards were read from 90 days of past posts (backfilled). Tracked calls (found the hour they are posted) build up as the site runs, and the board keeps a tracked-only view for them.
  • Most settled calls are sports. Area views open only when an area has 3 qualifying accounts.
  • Call or not and the market match are an AI reader’s and a matcher’s judgment. They are marked so and can be reported.
  • Prices come from Kalshi public market data only. A market Kalshi does not list cannot be scored.
  • The program is not deployed yet, so no root is on chain and the strongest guarantee here is still a promise.

Rules and versions

VersionDateChange
r22026-11-20A, B and C; only minutes with their own data count, at least 10; activity floor; a flip closes the held call; hourly roots.

Components under r2: prefilter p2, reader x3, series s1, call check c3, matcher m4.

How the seed accounts were chosen

Public accounts of named people or outlets with at least 100,000 followers whose posts regularly forecast outcomes Kalshi lists, chosen before any scoring.

Known limits

Text only: a call made in an image or video is not read. A post edited within its hour is priced with the hour after it in view, because the edit history is not available. Lookups need at least 10,000 followers and open in hourly slots.