zot arcade sessions

Every conversation behind every game in the zot arcade - a software factory where an agent takes the same standing order every half hour, reads the catalogue of what already exists, and designs, writes, playtests and ships one brand-new browser game.

Each row is one shift: the full agent trajectory from the order to the finished game (or to where the shift was cut short), in the chat shape the rest of the ecosystem reads, plus what the arcade knows about the result.

The rows are appended by the arcade's own workflow as shifts happen. Nobody reviews them; they are the record as it was written.

Layout

trajectories/<session-id>/<session-id>.jsonl   one row
trajectories/<session-id>/images/<digest>.png  the screenshots the model was shown

Row schema

field
id	the zot session the row was exported from
chain	the sessions behind it, oldest first - a shift cut short is continued by the next, and exports as one row
task	the order as the model received it
model, provider, driver	what ran it
started, ended	wall clock, UTC
outcome	how the run ended: reason (success, failed, error, ...), iterations, calls, ... - absent when the run was cut short
complete	whether an outcome was recorded
messages	the conversation as it stood at the end - see below
snapshots	earlier states of the conversation that compaction or a resume superseded, oldest first
images	the image files this row refers to, relative to the row's directory
events	counts by kind: iterations, nudges, retries
arcade	the arcade's side: game (the catalogue entry: slug, name, genre, mechanic, theme, tagline, controls, created), files (the game's index.html, game.css, game.js), outcome (the shift's verdict: settled / failed / error), catalogue_check, committed, commit, run

Messages

OpenAI chat convention, with additive fields:

{"role": "user",      "type": "user",        "content": "Begin working on your task..."}
{"role": "assistant", "type": "bot",         "content": "", "reasoning": "...", "tool_calls": [{"id": "call_1", "type": "function", "function": {"name": "read", "arguments": "{\"path\":\"site/games.json\"}"}}]}
{"role": "tool",      "type": "activity",    "tool_call_id": "call_1", "name": "read", "content": "[...]"}
{"role": "user",      "type": "attachment",  "content": [{"type": "text", "text": "screenshot of the game"}, {"type": "image", "image": "images/3f2a....png"}]}
{"role": "system",    "type": "checkpoint",  "content": "summary of the conversation so far"}

• type is zot's own message type: user, bot, activity, attachment, checkpoint (a compaction summary), instructions.
• reasoning is the model's scratchpad for the turn, when the provider surfaced it.
• Tool arguments are the JSON string the model sent, verbatim.
• The system prompt is not recorded; task is the brief.

messages is what a resume of the run would replay. After compaction that is a checkpoint plus the recent turns - snapshots holds the earlier states, so every turn that happened is in the row, at the price of the recent ones being repeated.

Filtering

• Finished games: complete and arcade.outcome == "settled" and arcade.catalogue_check == "success".
• A shift that was cut short ships as a partial row; the shift that continued it ships the whole chain under its own id, with the earlier id in chain. Drop rows whose id appears in another row's chain to keep only tips.

Provenance

• Factory: https://github.com/openzot/arcade - the standing order is orders/new-game.yaml, the conventions the agent reads are AGENTS.md.
• Harness: zot; rows are produced by zot sessions export and shipped by scripts/ship.py after each shift.
• Model: whatever the workflow names at the time; each row says which.

The games are model output, published as-is under the arcade's license. Check the terms of the model named in a row before training on its reasoning.