+ This step did not involve a model call — it is a state change the environment made on + its own. +
+ ) : ( ++ This step has no recorded reasoning. The run was captured with thinking disabled, so + there is nothing to show here — which is different from the model having thought + nothing. +
+ ) : ( ++ {full.slice(0, visible)} + {streaming ? ( + + ) : null} +
+ )} +| + Component + | ++ Score + | ++ Weight + | ++ Value + | +
|---|---|---|---|
| + + {row.component.label} + + + {role.label} + + + + {row.component.description} + + + {row.component.key} + + | ++ {row.score === null ? ( + + not scored + + ) : ( + formatNumber(row.score) + )} + | ++ + {formatNumber(row.weight, 2)} + + | ++ {row.value === null ? DASH : formatNumber(row.value)} + | +
|
+
+ Total reward
+ {edited ? |
+ + | + {total === null ? ( + not scored + ) : ( + formatOrDash(total) + )} + | +
+ + {counterweights.map((row) => row.component.label).join(' and ')} + {' '} + {counterweights.length > 1 ? 'are counterweights' : 'is the counterweight'}: without a + term pulling the other way, the cheapest way to maximise the objective is a behaviour + you would never ship, and the model will find it. +
+ ) : null} + + {spec.metrics && spec.metrics.length > 0 ? ( ++ + + Unverifiable in your browser.{' '} + {verdict.reason} + +
++ {matched ? ( + + ) : ( + + )} + + {matched ? ( + <> + Verified in your browser{' '} + + — re-ran every move through the TypeScript engine and rescored. + + + ) : ( + <> + + Mismatch on {verdict.guilty.join(', ')} + {' '} + + — the browser re-run disagrees with the recorded score. Trust the source, not + this page. + + + )} + +
++ Recomputed {formatOrDash(verdict.recomputedTotal)} · recorded{' '} + {formatOrDash(verdict.recordedTotal)} · Δ {formatDelta(verdict.maxDelta)} +
+| + Component + | ++ Recorded + | ++ Recomputed + | ++ Δ + | +
|---|---|---|---|
| + {row.label} + | ++ {row.recorded === null ? DASH : formatNumber(row.recorded, 6)} + | ++ {row.recomputed === null ? DASH : formatNumber(row.recomputed, 6)} + | ++ {Number.isFinite(row.delta) ? formatDelta(row.delta) : 'not comparable'} + | +
+ Tolerance {EPSILON.toExponential()}. The browser engine and the Python environment + can sum the same terms in a different order, and IEEE-754 addition is not + associative, so the comparison is made within a tolerance rather than demanding + bit-identical floats. +
++ {children} +
+ ); +} + +function DemosPanel({ live, spec }: { live: DemoMeta[]; spec: DemoMeta[] }) { + return ( +No interactive demos published yet.
+ )} +Nothing queued.
+ )} ++ Every demo replays a real rollout from a real environment. +
+No verticals in the lineup yet.
+ )} +Gallery
++ A live demo is playable in this tab. A spec is a written environment — task, action set, + grader, counterweight and the command that evaluates it — published in full, with no + interactive surface yet. There are no coming-soon cards here. +
+ + {filters.length > 2 ? ( ++ {shown.length === 1 ? '1 environment' : `${shown.length} environments`} + {active === ALL ? '' : ` in ${verticalLabel(active)}`} +
+ + {shown.length === 0 ? ( +Nothing here yet.
++ No environment is filed under this vertical. The proposal for it is still on the + verticals page, written out in full. +
+ +{demo.tagline}
+ ++ + {vertical.title} + {' '} + · {PROPOSAL_NOTICE} +
+ ) : null} ++ The lineup is a set of proposals, written to the same four-part shape as the live one. + Reading one takes a minute and tells you whether the idea survives contact with your own + numbers. +
+ + See the lineup + +Honesty
++ This site argues that a number you can check beats a claim you have to trust. That argument + only works if we hold our own numbers to it. So here is every claim on the site, sorted by + how much weight it can carry. +
+ + + + {/* ── Measured ───────────────────────────────────────────────────── */} ++ Everything in this section is reproducible from a clone of this repository, offline, with + no account and no key. If any of it does not reproduce, that is a bug and we want the + issue. +
+
+
+ {reproduce.clone}
+ {'\n'}
+ {reproduce.install}
+ {'\n'}
+ {reproduce.evaluate}
+
+
+ {wordList.rebuild} produces the same{' '}
+ {wordList.answers.toLocaleString('en-US')} answers and{' '}
+ {wordList.guesses.toLocaleString('en-US')} legal guesses on
+ any machine.
+ + Three claims on this site are not ours. They are linked so you can go and check them + instead of taking them from us. +
+ +
+ Published by Prime Intellect, measured on {trainingResult.evalDescription}, after{' '}
+ {trainingResult.method}. Both checkpoints are on Hugging Face, so you can run the eval
+ yourself:
+ We quote the win rate and nothing else. The same write-up gives average-reward figures + for those runs; we leave them out because the reward function has changed across + versions of that environment and the two figures were never re-measured together. A win + rate survives a reward change. An average reward does not. We have also not reproduced + this result: their environment and word list are not ours, and a number measured on a + different task list is not a number about this one. +
++ We say this because a demo picked to flatter itself is worth nothing. It appears in three + places in their stack: +
+
+ The famous optimum is
+ When you watch a model play here, you are watching a file. No model is called while you + read this page. That is a choice, and these are the reasons for it: +
++ The cost is real: you cannot make a model react to a word you chose. If that is what you + want, run the environment on your own machine against your own endpoint. It is three + commands and the code is above. +
++ Moving a weight changes how the recorded attempts are scored, and the page recomputes and + re-ranks them. That is the entire mechanism. Nothing is fine-tuned, no model is called, and + nothing learns while you drag a slider. +
++ What it is there to show is narrow and worth the space: two runs can swap places when you + change what you are paying for. That is a fact about your definition of good, not about the + models — and it is the reason the definition is worth an hour of your team’s attention + before the training run is worth a GPU. +
++ The other half — actually training against the reward you just wrote — takes GPUs and + hours, and it does not belong in a browser tab. That is what a trainer like prime-rl is + for, and the number at the top of the home page is what it produced. +
++ Eleven of the twelve entries in the lineup describe environments that do not exist. They + are labelled “{PROPOSAL_NOTICE}” on every + surface that shows them, and that label is the literal truth: we wrote them. +
++ Two of them carry a standing caveat on their own page — the{' '} + + legal redline + + , where grading the drafting half collapses into an LLM judge, and{' '} + + semiconductor timing closure + + , which has the best reward on the page and is the one thing here we are telling you we are + not going to build. +
+
+ We did not copy the original game’s word lists. Our answers are the intersection of two
+ permissively-licensed sources — every five-letter headword in{' '}
+
+ The list is built by a stated rule from sources anyone can fetch, rather than lifted from + somebody’s editorial selection. That is the point of it. It also means every comparison to + the original game is a comparison between two different games. +
++ Our answer pool comes from a dictionary rule, so it keeps the regular plurals and past + tenses that the original game’s editor removed by hand.{' '} + {wordList.endsInS} of our answers end + in a plain S and{' '} + {wordList.endsInEd} end in{' '} + -ED —{' '} + {wordList.endsInSorEd} in one or the + other. +
++ That is a large, exploitable regularity. A guess that tests a trailing{' '} + S splits our pool roughly one-third to two-thirds every + single game, and buys information that the same guess simply does not buy in a list where + plurals were deliberately stripped out. Nobody has to be clever to use it; a fixed opening + pair picks it up for free. +
++ One thing cuts the other way, and we would rather say it than be caught leaving it out: our + pool is roughly twice the size of the original’s, which is harder. We have not computed an + optimal average for our list, so we cannot give you a single number for the net effect. The + practical instruction is the same either way — do not compare a guess count from this site + to your own statistics from the original game. It is a different game with a different + shape. +
++ This is the list we would want if we were the ones being sold to. +
++ Every claim above is traceable to a file in the repository. If one of them does not hold, + open an issue with the page and the sentence and we will fix the sentence or the code. +
+404
+
+ Nothing is served at{' '}
+ {pathname}. Either the link is old or
+ we moved something. Here is everything this site has.
+
+ What is measured, what is cited from elsewhere, and what we have deliberately not measured + all live on one page. +
+
+ There is no proposal at /verticals/{slug}. The
+ twelve we have written are all on the home page.
+
Who it is for
+{vertical.persona}
++ ++{vertical.anxiety}
+ +
{vertical.task}
+{vertical.reward}
+{vertical.counterweight}
++ The counterweight is the part worth arguing about. A reward with nothing pulling against it + is a target, and a target is what a model learns to hit instead of doing the job. +
+ + {vertical.caveat ? ( +{vertical.caveat}
++ Nothing. There is no environment for this vertical, no recorded run, and no number. It + is a proposal, written to the same shape as the one that is built so you can judge it + on the same terms. +
+ {featuredDemo ? ( ++ The environment that does exist is{' '} + + {featuredDemo.title} + + . It is a word game, and it is deliberately not one of these twelve: it is there to + show the machinery, not to imply we have built yours. +
+ ) : null} +Something broke
+{body}
+ {detail ? ( +
+ {detail}
+
+ ) : null}
+ Loading…
+