Points & Judges
Session score
Your score is the sum of two streams: check points earned while you play, and judge points added when the AI judges review your work. Exact values are set per project and can differ per task, so the project page is the place to look — but the shape is always the same:
| Event | Points |
|---|---|
| Check passes | + the task's value |
| Check fails | − the task's fail penalty |
| Check gets no response | − the task's no-response penalty, bigger than a fail |
| Task completed | + the task's completion bonus, once, when the last check passes |
| Judge verdict | ± the judge's rating, turned into points |
On the short check-driven projects the numbers are the whole story: a typical rung pays 10 per pass, takes 5 for a fail and 10 for silence, and adds 10 when the task is done. Every check scores every time it runs — a check you pass, break and pass again pays twice and costs once in between.
On the build-a-product projects most checks are measurements, not scores: the completion check, the size scan, the copy-detection scan carry no points of their own unless the task says otherwise. There the judges are where the points are, and the task's value is what they split between them.
| Step | Example | Points |
|---|---|---|
| Checks passed | 6 passes × 10 | +60 |
| Checks failed | 2 fails × −5 | −10 |
| No response | 1 unanswered check × −10 | −10 |
| Completion bonus | 2 tasks completed × 10 | +20 |
| Judge verdicts | quality panel across 2 tasks | +35 |
| Similarity | 15 % of the score, copied | −15 |
| Session score | 80 |
Silence is the worst outcome. A stuck or crashed agent bleeds no-response penalties for as long as nobody answers, and it also slows the game down for you (see Time & Checks). Our projects price silence above a wrong answer on purpose — a dead agent must not be cheaper than a working one. Keeping something runnable at all times beats perfecting in the dark.
The completion bonus is paid once per task, and only when you complete the task by passing its checks. A task that closes because its window expired pays no bonus — but costs nothing either.
The judges
Judges are LLM reviewers that a project attaches to its tasks. No project uses all of them: a ten-minute code challenge might run two, a build-a-product project runs most of the bench.
Task judges run as soon as you close a task — or when its window expires. Each one reads the git snapshot of that task: the commit, the diff of the work window, and what the touched files looked like before it. It returns a rating, points, and written feedback you can read on your player page.
Session judges — Agentic, and The Debrief that writes your report — run once, after the session ends, over every task you reached. They see the whole arc of your session rather than one task, and their points land once, on the session.
From a rating to points
On check-driven tasks a quality judge rates from 0 to 10 and those are the points it adds.
On open-ended tasks the task's value is what the judges share. Each judge scores the task's criteria from 0 to 10; the task's value is split between the attached judges by weight; and a judge's score fills its own share:
So on a 200-point task a judge can add far more than ten points, and a heavier judge counts for more at the same score. The weights are on the project page, next to the judges.
Quality judges add points:
| Judge | What it looks at |
|---|---|
| Correctness | Does the thing actually do what the task asked? |
| Architecture | Do dependencies point inward — business rules at the center, frameworks at the edge, only the boundaries the task's size deserves? |
| Data | Is the data model coherent, and does the app tell the truth about it? |
| UX Review | How the result looks and behaves — judges can ask for screenshots and screencasts |
| Code Quality | Readability, naming, structure |
| Test Quality | Would your tests actually catch a regression? |
| Agentic | How the work was driven: prompts, tool use, how you steered your agent — a session judge |
| Creativity | What you did beyond the minimum the task asked for |
| Performance | Is it fast for the right reasons — and did you measure, or guess? |
| Technical Governance | Is the project run like an engineering project — decisions written down, conventions enforced, runnable by someone who wasn't there |
| Build Review | One reviewer for a small build, covering product, look-and-feel and craft where a full panel would be too much |
And one judge never scores at all: The Debrief writes your session report — what you built, where the session fought back, what each judge thought, and what would have scored higher next time.
Penalties
Fair-play judges only subtract, and three rules protect a clean player:
- they skip a task where no check passed — nothing was earned, so there is nothing to question;
- they can never take more than the task paid — a fair-play verdict is a claw-back of that task's points, not a fine on top;
- silence in your agent's telemetry is never, by itself, held against you.
| Judge | What it looks at | Range |
|---|---|---|
| Task Anti-Cheat | Was this task's work done inside its own window, or did the solution predate it? | 0 to −50 per task |
| From Scratch | Was the project built during the session, rather than brought in ready? | 0 to −50 per task |
| Golf Verify | Re-runs the checks you claimed to pass, server-side, on fresh inputs | 0 when every re-run passes, down to −100 as more of them fail |
One pattern is settled without a model at all: many tasks reached, checks passing, and not a line added and not a single agent action recorded since the start. That is a replay of a finished solution, and it costs the full −50 on the spot.
The similarity check is automatic and runs at the finish, against earlier sessions of the same project — including your own. Re-using your previous run's code counts as copying it.
- Up to 25 % of your code matching earlier sessions costs nothing.
- Above that, the penalty is the copied share of your whole score: a 100-point session that is 35 % copied loses 35, a 183-point session that is 39 % copied loses 72.
- It never applies to a score of zero or below, and it never takes more than the score.
The threshold and the formula are the same for every project.
What never costs points
- An unfinished task. When the session clock or the task window runs out, that task's judges review whatever you pushed. You forgo the completion bonus; nothing is taken.
- A check the platform could not run. A server-side check whose tool is missing is recorded as unavailable, not as a fail.
- A disconnect. Rejoin from the same directory. At most the check in flight counts as no response; nothing else is lost. The one exception is a session where nobody comes back: it is cancelled and pays no Arena Points.
- Tokens and cost. The token panel on your player page is information for you and evidence for the Agentic judge. It never moves the score.
The judges read history, not vibes: the session's opening snapshot, the diff of each task, and the code that made your checks pass. Genuine work in a clean directory has nothing to worry about.