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.
| Stage | What it does | Runs where |
|---|---|---|
| Read | Original 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 |
| Decide | A 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 |
| Match | Exactly one Kalshi market and side: same subject, same date, same number. Anything looser is “no exact market” and is published, not scored. | our server |
| Price | The 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 |
| Score | 100 if the called side happened, else 0, minus the price used. Integer basis points. | our server, checkable in your browser |
| Fix | When 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.
| Counts | Does 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.
| Value | Window | Why it is there |
|---|---|---|
| A | average of the counted minutes in the 60 minutes before the call minute | where the market stood |
| B | average of the last 5 counted minutes | where it stood just before the post |
| C | highest value for the called side from the call minute to 60 minutes after | X allows edits for an hour and the data has no edit history |
| used | the largest of A, B and C | a 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.
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);
A 2064 B 3410 C 9150 used 9150 (60 counted before, 15 after)
| Line | Meaning |
|---|---|
| A 2064 | 20.64%: Denver was the underdog across the hour before the post. |
| B 3410 | 34.10%: the price was climbing in the last 5 minutes. |
| C 9150 | 91.50%: the highest price for Denver within the hour after. The market closed 15 minutes after the post. |
| used 9150 | The 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”.
| Part | Definition |
|---|---|
| Leaf hash | SHA-256(0x00 || canonical JSON of the leaf) |
| Node hash | SHA-256(0x01 || left || right); an odd node at the end of a level is carried up unchanged |
| Order | leaves sorted by leaf_id = post_id:claim_idx:seq |
| Canonical JSON | keys sorted, null fields left out, no spaces, integers only |
| Empty hour | root = 32 zero bytes |
| Text | a leaf holds a salted hash of the post text, never the text |
| Found | each 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
const X_EPOCH_MS = 1288834974657n;
const callMs = Number((BigInt("2117049658476532160") >> 22n) + X_EPOCH_MS);
new Date(callMs).toISOString();"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.
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 chain | Done by our server, checkable by anyone |
|---|---|
| Only the record key posts a root | Reading posts and deciding call or not |
| Only a finished UTC hour, by the chain clock | Matching one exact market and side |
| Each hour greater than the last posted; no overwrite | Mirroring Kalshi minutes, each response hashed into its leaf |
| Config changes wait out a timelock of 7 to 30 days | Computing A, B, C and the score, recomputable from the mirror or Kalshi |
| Only the lock owner deposits, requests a withdrawal and withdraws | Publishing every leaf file |
Keys and the worst case if one leaks
| Key | Can | Worst case if it leaks |
|---|---|---|
| Record key | post the next hour’s root | A 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 admin | propose config changes, set the token mint | A change that waits on chain, in view, for the timelock before it applies, and can be cancelled in that time. |
| Upgrade authority | co-sign initialize, upgrade the program | Replacing the program code. Who holds it is published with the program id. |
| Your wallet | deposit to and withdraw from your own lock | A 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.
| Path | Returns |
|---|---|
GET /api/health | Kalshi 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/board | accounts with at least 10 settled calls, with counts and backfilled share |
GET /api/accounts/:handle | one account’s record and every call |
GET /api/calls/:postId | one call’s receipt: market, side, minutes, A, B, C, score, leaf |
GET /api/hours | hour roots and their transactions |
GET /api/rules | the rule text and version history |
GET /api/scene | every account’s record and every priced call in one read (the first screen and the app use it) |
GET /data/leaves/<day>/<hour>.json | one finished hour’s leaves and root |
GET /data/mirror/<sha256>.json | the 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:
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 supply | Accounts watched | Lookups a day | Alerts within | Also |
|---|---|---|---|---|
| none (wallet sign-in) | 3 | – | – | |
| 0.01% | 10 | 10 | 15 min | |
| 0.05% | 50 | 30 | 5 min | |
| 0.2% | 200 | 100 | 5 min | read-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
| Version | Date | Change |
|---|---|---|
| r2 | 2026-11-20 | A, 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.