Sixty

An agent on chain 4663 that hears every token launch as it happens, scores it before the outcome exists, judges the story, and comes back two hours later to mark itself. This page says exactly what it does and how to check it.

What it is

Roughly six hundred to twelve hundred tokens launch on this chain every hour through the Pons V2 factory. Almost none of them attract anyone but their creator. The desk is a single long-running process that listens to the factory's TokenLaunched event, reads each new token's context from the chain within seconds, and writes down a probability that real outside demand will show up in the next two hours. Later it reads the curve again, records what actually happened, and recomputes its own hit rate from the two logs. It never signs a transaction and holds no wallet.

The desk you see at the root is the live face of that process: the queue of launches with their scores, the detail behind each score, the model's feature table, and the track record. Nothing on it is edited by hand.

What it predicts

One sentence, deliberately narrow: will buyers other than the creator put 10% of the curve's graduation target in within two hours of the launch block?

• Outside money excludes buys inside the launch transaction, buys from the deployer, and buys from any wallet the deployer declared exempt from the opening tax. Without those exclusions a creator buying a fifth of their own supply would look like a runaway success.
• The window is fixed at two hours from the launch block, measured once. A launch still inside its window has no outcome and is never counted as a miss.
• Not price. Price on a two-hour horizon can't be scored honestly without picking an exit rule, and every exit rule is a trading strategy pretending to be a measurement. Money arriving is observable and settles on its own. A high score is not advice to buy; a token can attract outside demand and still lose value.

How it scores

Seven signals, all readable the moment a launch appears. Nothing measured during the observation window is allowed in, because that is the window the outcome is measured in.

Each signal is bucketed. For every bucket the model knows how often outside money came for launches in that bucket, smoothed toward the base rate so a bucket with four observations can't dominate, and turns that into a log-odds weight relative to the base rate. The weights add; a sigmoid turns the sum into a probability; a Platt calibration fitted on live outcomes corrects the raw model's over-confidence. A signal that couldn't be read adds exactly zero. The desk shows this chain for every launch under How this score was made, and the full feature table under How it scores.

One strong signal is deliberately absent: whether the creator sold. The sell happens inside the same window the outcome is measured in, so at launch time it can't be known; including it would inflate every number here.

The story score

The on-chain score can't read. So each launch that carries a tweet or a description is also judged by a language model on the idea itself: is the linked tweet a genuine, fresh beat; does the ticker or name carry the joke; does the quote asset make it land; does it fit what actually runs on this chain; is it original or one of fifty copies. The judge returns a kind, four sub-scores, an overall 0 to 100, one plain sentence and a few tags.

The track record

Two append-only files: predictions.jsonl and resolutions.jsonl (plus narratives.jsonl for story judgments). Each prediction records the model version, the timestamp, the token, the deployer, the launch block, the probability and the feature values used. Each resolution records the observed outside-money share and whether the event occurred. Nothing is rewritten in place.

From those two files the desk recomputes, continuously:

• AUC: how well the ranking separates launches that got outside money from those that didn't. 0.5 is a coin; 1.0 is perfect.
• Brier score against the Brier of always guessing the base rate. Lower is better; beating the base rate means the probabilities carry information, not just the ranking.
• Calibration by band: what the model said versus what happened, so over-confidence is visible rather than hidden.
• Top-decile hit rate: how often the top tenth of launches by score actually got outside money, against the base rate.

The engine's own published record on this chain (the same model, its author's log) stood at AUC 0.726 on 21,017 resolved predictions when we forked it. This desk's numbers come from this desk's log only and start from the moment it was switched on.

Check it yourself

Every headline figure is recomputable from the raw logs, and the one claim that can't be reconstructed after the fact, that every outcome is timestamped after the prediction it scores, is enforced by the scoreboard code and covered by tests.

cd agent
npm test              # invariants the record depends on
curl localhost:4665/api/scoreboard   # the live figures, recomputed from the files

The logs live in agent/data/. Hand them to anyone with a copy of the scoreboard module and they get the same numbers.

API

Everything the desk shows comes from these endpoints on the agent, read-only, CORS open.

A launch row carries: token, curve, symbol, name, deployer, block, launch time, quote (ETH or the stock symbol), the seven signals, curve progress and phase, p, lift (p over base), the weighted parts of the score, flags, beat (the resolved tweet), narrative, and verdict once measured.

Run it

git clone … && cd beat-desk/agent
npm install
export ANTHROPIC_API_KEY=sk-ant-…    # optional: turns the story score on
npm start                            # http://127.0.0.1:4665
npm run watch                        # the same feed in a terminal

Node 20 or newer. Three dependencies: viem for the chain, @anthropic-ai/sdk and zod for the story score. Both RPC endpoints are public; no key is needed for the on-chain score. PORT, DATA_DIR, NARRATIVE_MODEL and NARRATIVE_PER_HOUR override the defaults. Behind a proxy, leave /api/feed unbuffered or the page loads and then silently stops updating.

The token

The record is public and stays public: every prediction, every outcome, every metric, recomputable by anyone. What the token buys is speed and depth.

How it works: the desk asks the wallet to sign a nonce. That proves you control the address and costs nothing; nothing is moved or approved. The agent reads the wallet's balance of the token on chain and, above the minimum, opens the live feed for that session. The gate is code in the agent today (agent/src/gate.mjs); it switches on when a token address is configured and is open to everyone until then.

Where the fees go: the token launches on Pons V2 like everything it scores, with the creator fee at or under 10% and the holder fee share on. The creator fee has one job, paying for the judge: the language-model bill for the story scores and the box the agent runs on. Costs are published on the record tab next to everything else. No other promise is attached to the token, and the desk will never trade, snipe, or tell anyone what to buy.

Rules

• Any number without a source reads no signal. Never a placeholder.
• Predictions are written before outcomes and never rewritten. A new model does not rescore old predictions to make the aggregate look better.
• The story score is a judgment and is labelled as one everywhere it appears.
• The desk does not trade, does not launch, and holds no key.

Engine and credits

The chain reads, the model, the scoreboard and the flags are GRAID, MIT, forked with one change (the token reader also returns the raw socials). The tweet resolver, the story score, the API and this desk are ours. GRAID's design note holds here too: what makes this worth anything is the discipline around the prediction, written before the outcome and scored in public with the misses included, not the sophistication of the estimator.