subimpact WhatsApp us

Loaded Dice: The Unbeatable Game for AI

Loaded Dice is a game API for AI agents: each round publishes a SHA-256 commitment to a fair roll, declares a random deadline, and requires a move plus a stated confidence before that deadline. On reveal the nonce is published so anyone can verify the commitment, and the dataset records roll, move, confidence, correctness, on-time status and a verification flag. Rounds cost $0.02. Play through the Live View or the JSON API.

from $0.02 per dice round, $20.00 per 1,000 · Updated Nov 2026, version 0.1.9

Key facts

Price
from $0.02 per dice round, $20.00 per 1,000
Pricing model
Pay per event
Output
JSON, CSV, Excel, XML, RSS via Apify datasets
Access
Apify Console, REST API, Python and JS clients
Version
Updated Nov 2026, version 0.1.9
Usage
100.0% successful runs (30 days)
Actor
subimpact/loaded-dice

Who it is for

  • Agent builders measuring honesty and calibration under a hard deadline
  • Eval engineers building a Brier score benchmark across models
  • Researchers studying whether reasoning improves a fixed-odds guess
  • Teams running a lightweight public leaderboard from self-reported labels

Use cases

Run a calibration benchmark

Play rounds through the JSON API with a stated confidence each time, then compute the Brier score from confidence and correct. A player who reports the honest 0.167 prior lands near 5/36, and one that claims 0.9 on a one-in-six guess is punished by the same formula. The dataset keeps every round, so the score is reproducible.

Test commitment under a deadline

Set minDeadlineMs and maxDeadlineMs to bracket the deadline window, for example between 1000 and 5000 ms. Because the deadline is declared after the die is committed, a slow agent forfeits rather than reasons its way to an answer. onTime and responseTimeMs show whether latency or judgement failed.

Verify fairness yourself

Every round row carries the commitment hash, the nonce and a verified flag. Check that sha256(roll:nonce) equals the published commitment for each round, rather than trusting the actor's own flag. The die is committed before the question is asked, so no answer can influence it, and the check takes one line of code.

Prove the maths in auto mode

Set mode auto with rounds at 200 and strategy random, then again with cycling. Both converge near 1/6, which is the point: 1/6 is the ceiling for any strategy, human or machine. Auto mode is a cheap sanity check before you point an agent harness at the api mode.

Build a leaderboard from self-reported labels

POST /move accepts optional model and playerId values, which land in each row. The actor cannot see which model is playing, so labels are self-reported by design. Group rows by model to compare hit rate and Brier score, and call POST /stop at the end so the final summary is written before the run timeout.

Output fields

FieldTypeDescription
round any
model any
roll any
move any
confidence any
correct any
onTime any
responseTimeMs any
deadlineMs any
mode any

Sample output

From one of our own test runs on 20 Nov 2026, trimmed. Personal data is redacted.

2 rows, first 3 shown

[
  {
    "mode": "auto",
    "round": 1,
    "model": "auto:random",
    "playerId": null,
    "roll": 4,
    "move": 6,
    "confidence": 0.1667,
    "correct": false,
    "onTime": true,
    "responseTimeMs": 25,
    "deadlineMs": 3124,
    "commitmentHash": "8fbb27d055f4bf0220e254df9130aed3a032299bb5a5e24a17e12b4d77ef19d5",
    "nonce": "c7d881ccf5e58314f7b42ed7d7a801cb",
    "verified": true,
    "playedAt": "2026-11-20T02:42:42.990Z"
  },
  {
    "mode": "auto",
    "round": 2,
    "model": "auto:random",
    "playerId": null,
    "roll": 4,
    "move": 6,
    "confidence": 0.1667,
    "correct": false,
    "onTime": true,
    "responseTimeMs": 30,
    "deadlineMs": 1512,
    "commitmentHash": "aae799c08e9f49e86c044094bef8a09a9b3be588e62767cc1afe47c876ec3e52",
    "nonce": "b6aeee5aae5b35c37f512729b2e3889f",
    "verified": true,
    "playedAt": "2026-11-20T02:42:43.156Z"
  }
]

Input

FieldTypeRequiredDescriptionDefault
mode string No auto: the actor plays itself (proves the math, cheap sanity check). api: starts a web server — AI agents play via JSON API, humans via Live View. auto
rounds integer No How many rounds to play in auto mode. Capped at 1000. 10
strategy string No Which built-in player the actor simulates. random and cycling both score ~1/6 — proof that no strategy beats a fair die. random
constantMove integer No The fixed move when strategy = constant. 3
agentLabel string No Label written into every row's model field, e.g. a model name or strategy label. Defaults to auto:.
confidence number No Override the confidence every round reports (0-1). Default is the honest prior (1/6 ≈ 0.167). Set 0.9 to simulate an overconfident player and watch the Brier score punish it. 0.1667
minDeadlineMs integer No Shortest possible random deadline. The deadline is declared after the die is committed, so the player can never pre-compute. 1000
maxDeadlineMs integer No Longest possible random deadline. 5000
sessionToken string No Optional bearer token to protect the game API. Leave empty for an open game (anyone with the run's Live View URL can play).

Example input

{
  "mode": "auto",
  "rounds": 10
}

Pricing

EventWhat it meansPriceLowest tier
dice-round One completed round of Loaded Dice — a committed fair roll, a random deadline, and a resolved move with full trace. $0.02 $0.02

$20.00 for 1,000 dice round units at the listed price.

Prices from the Apify Store on 20 November 2026. Apify shows the final price before each run.

How it compares with other Apify actors

No candidate on the Apify Store does the same job. The closest listings are job, social and market data scrapers or AI detectors, which share no source, no data shape and no unit with a committed dice round scored against an agent, so any comparison would mislead a buyer.

How to run it

  1. Run the actor in auto mode with rounds set to 20 and strategy random as a first check that rows land in the dataset.
  2. For a real session, set mode api, optionally set minDeadlineMs and maxDeadlineMs, and set sessionToken if the game page should be private.
  3. Open the run's Live View to play by hand, or call GET /state to start a round and read commitmentHash, deadlineMs and timeLeftMs.
  4. Submit POST /move with a move, a confidence and optional model and playerId before the deadline, then call GET /score for the hit rate.
  5. Call POST /stop when finished, then read the round rows and verification flags from the dataset or export them as JSON or CSV.

cURL

curl -X POST "https://api.apify.com/v2/acts/subimpact~loaded-dice/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"auto","rounds":10}'

Python

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("subimpact/loaded-dice").call(run_input={"mode":"auto","rounds":10})

for item in client.dataset(run["default_dataset_id"]).iterate_items():
    print(item)

JavaScript

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('subimpact/loaded-dice').call({"mode":"auto","rounds":10});
const { items } = await client.dataset(run.defaultDatasetId).listItems();

console.log(items);

n8n

Use the Apify node (Run an Actor).
Actor ID: subimpact/loaded-dice
Input JSON: paste the example input above.

Limits

  • Model and player labels are self-reported, because the actor cannot see which model is playing.
  • A session stops at 1,000 completed rounds per run.
  • Late moves are forfeits and produce no charged round row.
  • The server lives only for the run, so the session ends when the run times out.

Questions people ask

What does a round cost?

Each completed round costs $0.02, which is $2.00 per 100 rounds or $20.00 per 1,000, and one charge applies per round in either mode. A late move is a forfeit and is not charged. Compute use is minimal since the actor makes no external calls and needs no proxy.

Is the game rigged towards the house?

No. The roll is a fair die, and it is committed as a SHA-256 hash before the question is asked, with the nonce revealed after the answer. Anyone can check that the hash matches. The house does not need to cheat: with a fair six-sided die, 1/6 is the ceiling for every strategy.

How does an AI agent play it?

Through three JSON endpoints. GET /state starts a round and returns the commitment hash, deadline and time left. POST /move takes move, confidence and optional model and playerId. GET /score returns hit rate and round counts. A bearer token can protect the API through the sessionToken input.

What happens if the agent answers late?

The move is a forfeit. Late rounds are not charged, and onTime plus responseTimeMs in the dataset record what happened. Lower minDeadlineMs and maxDeadlineMs if you want to test response speed harder, or raise them to separate reasoning quality from latency.

What is the Brier score used for here?

It measures whether a stated confidence was honest. A player who reports 0.167 each round, which is the true prior, scores about 5/36. A player claiming 0.9 on a one-in-six guess scores much worse. That is why the game doubles as a calibration test rather than only a guessing game.

How many rounds can one session run?

auto mode is capped at 1,000 rounds. An api session also stops at 1,000 completed rounds as a bill-shock guard, after which the API answers HTTP 429 and the run ends. You can end a session earlier by calling POST /stop, which also writes the final summary.

Which fields land in the dataset?

One row per round with round number, model label, player ID, roll, move, confidence, correct, onTime, responseTimeMs, deadlineMs, mode, commitment hash, nonce and a verified flag. That trace is the product: it feeds an eval harness, a leaderboard or a paper without extra instrumentation.

Need a data source that is not here?

We build and run scrapers for sites that have no public API. Tell us the site, the fields and how often you need them.