Part Ⅷ · Competition field manual

Practical knowledge to win ARC-AGI-3.

This chapter covers the current ARC-AGI-3 competition: interactive games, a stateful API, hidden evaluation, and action efficiency rather than static input/output puzzles. It is a dated operating manual for the July 29, 2026 competition surface.

9 h

Whole Kaggle run

64²

Maximum frame

Cell values

1×N

Frames per action

Glance · the mission

You are shipping a scientific instrument.

A winning submission is more than a model. It is a bounded system that observes precisely, proposes a causal hypothesis, chooses an informative or goal-directed action, checks the prediction, remembers what it learned, and repeats across unfamiliar games without wasting the action budget.

01ObservePreserve every returned frame.

02HypothesizeName the object, control, rule, and goal.

03IntervenePrefer actions that separate competing rules.

04VerifyCompare predicted and actual deltas.

05PlanRoute through known states efficiently.

Glance

Submit a generated Python notebook. It runs offline for at most nine hours and plays every hidden environment through a gateway API.

Core

Games are normally started in parallel. Do not design a curriculum where “game 1 teaches game 2”; each agent needs a competent cold-start loop.

Deep

Win the systems contest. State hashing, exact replay, bounded inference, process-safe memory, timeouts, deterministic recovery, and GPU-aware scheduling are part of the solver.

Core · submission anatomy

The deliverable is an IPython notebook.

The official starter lets you work in ordinary Python files, then packages them into the notebook Kaggle requires. In the standard path you edit agent/my_agent.py, rehearse locally, run make notebook to generate notebooks/submission.ipynb, and use make submit for Kaggle’s first pass.

agent/my_agent.pyYour Agent subclass and support code

make notebookBuilds submission.ipynb

Save & Run AllKaggle commit validation

Competition rerunHidden games + submission.parquet

Kaggle notebook VM

Your Python process

Agent policy, graph, memory, and model
CPU or the selected CUDA accelerator
Packages and weights loaded from attached inputs
Writable scratch files under /kaggle/working

HTTP RESTgateway:8001

Competition sidecar

Hidden game gateway

Owns the hidden environments and state
Returns observations and legal actions
Records every action for scoring
Emits the real submission.parquet

Starter workflow

# Work in normal source files
$ make play-local
$ make notebook

# Generated artifact
notebooks/submission.ipynb

# Push the notebook commit
$ make submit

Offline paths during evaluation

/kaggle/input/...      # attached, read-only
/kaggle/working/...    # writable scratch

# Competition rerun signal
KAGGLE_IS_COMPETITION_RERUN=...

The supported Python agent ABI

from agents.agent import Agent
from arcengine import FrameData, GameAction

class MyAgent(Agent):
    def is_done(
        self,
        frames: list[FrameData],
        latest_frame: FrameData,
    ) -> bool: ...

    def choose_action(
        self,
        frames: list[FrameData],
        latest_frame: FrameData,
    ) -> GameAction: ...

A coordinate action carries its own data

action = GameAction.ACTION6
action.set_data({"x": 57, "y": 39})
action.reasoning = {
    "hypothesis": "blue region is clickable",
    "prediction": "region changes color",
}
return action

Glance · constraints

Constraints

Design against the whole evaluation envelope, not only model quality. ARC-AGI-3 combines hard competition rules, Kaggle platform ceilings, finite machine resources, and a stateful game protocol. The numbers below are a practical July 29, 2026 snapshot; recheck Kaggle before the final submission.

Consolidated ARC-AGI-3 submission and evaluation constraints
Surface	Constraint	Practical consequence
Submission format	Kaggle Notebook	The competition accepts notebook submissions. Generate and inspect the final `submission.ipynb`; ordinary source files are development inputs, not the submitted artifact.
Notebook source	About 1 MB	Kaggle commonly enforces a kernel-source ceiling of less than 1 MB. This applies to notebook source—not attached model weights. Strip saved outputs, embedded images, and unnecessary generated text.
Models and data	Attach offline inputs	Put weights, wheels, tokenizers, and supporting data in Kaggle Models or Datasets and mount them under `/kaggle/input`. Do not embed large weights in the notebook.
Dataset hosting	200 GB default per dataset	Kaggle staff document a default 200 GB per-dataset quota, with account-level quotas and a request path for exceptional public datasets. It is not permission to attach arbitrarily many datasets to evade limits.
10 TB uploads	Not a normal submission	A 10-terabyte agent is outside ordinary Kaggle quotas and cannot be treated as a practical ARC-AGI-3 notebook input. It would require a special arrangement, and still must fit the evaluation machine and finish on time.
Writable storage	Approximately 20 GB working	Community guidance reports roughly 20 GB under `/kaggle/working` and about 60 GB of temporary space. Treat those as platform observations, not an ARC guarantee; inspect the live VM and avoid unpacking huge models.
Filesystem	Inputs are read-only	Read attachments from `/kaggle/input`; send caches, compiled kernels, traces, and the generated `submission.parquet` to writable space.
Wall clock	CPU and GPU ≤ 9 hours	The limit covers the complete hidden rerun—not each game. Boot, model loading, play, failure recovery, scorecard closure, and output generation all share one clock.
Network	No internet during evaluation	No hosted LLMs, remote APIs, package downloads, telemetry, license checks, or late weight fetches. Public external data and pretrained models must already be attached and able to boot offline.
Compute	Finite RAM, VRAM, CPU, and accelerator time	Uploaded size is not usable size. The model must load on the selected machine, coexist with game workers and traces, and serve every game inside the global deadline.
Competition mode	One scorecard; one `make` per environment	Retain each environment wrapper and `guid`. A crash or bad design cannot be repaired by silently creating unlimited replacement instances.
Coverage	Every hidden environment counts	Ignored or failed games still affect evaluation. Provide a bounded fallback for every worker instead of abandoning difficult environments.
Orchestration	Games start in parallel	Assume independent cold starts. Cross-game shared state must be generic, bounded, synchronized, and never required for one agent to begin solving.
Feedback	No live score oracle	Competition scores remain hidden while the run is in flight. Detect progress from returned frames, state, levels, and local invariants.
Actions	Legal actions and action efficiency are stateful	Re-read `available_actions` after every response, count actions locally, preserve animation frames, and avoid loops. Evaluation can terminate a level at five times its calibrated human action baseline.
Submissions	Five official reruns per day	Use local play and notebook validation for routine debugging; reserve competition reruns for artifacts that already boot and terminate cleanly.

Core · orchestration rules

Assume cold starts in parallel.

The official agents Swarm opens one scorecard, creates one agent per game, starts one thread for each, and only then joins them. Therefore the clean design assumption is: game B cannot wait for lessons from game A. Every game solver must discover its own mechanics from first contact.

One scorecardAll hidden games

Thread AAgent AGame α · cold memory

Thread BAgent BGame β · cold memory

Thread CAgent CGame γ · cold memory

Create each environment once

Competition mode permits one make call per environment. Hold the wrapper and its guid; do not “restart clean” by creating another instance.

One scorecard

All games belong to the same scoring session. Open it once, retain card_id, and close it after every worker has finished or failed safely.

All environments count

Skipping a hard game is not neutral. It still occupies the evaluation set, so make the fallback cheap, bounded, and capable of earning partial level completion.

No internet

No hosted LLM, package download, telemetry service, remote vector store, or late model fetch. Attach every wheel, weight, font, lookup table, and tokenizer in advance.

No live score oracle

Competition mode disables in-flight scorecard inspection. Your controller must judge progress from returned state and level fields, not leaderboard feedback.

Only level resets

A reset cannot be treated as an unlimited full-game do-over. Preserve already learned mechanics and make reset semantics explicit in the policy.

Core · API contract

A small REST surface. A stateful protocol.

Whether you use the Python toolkit or speak HTTP directly, the lifecycle is the same: discover games, open one scorecard, create/reset an instance, submit actions against its guid, then close the scorecard. Keep one HTTP session so the server’s load-balancer cookies follow every call.

GET /api/gamesDiscover IDs

→

POST /api/scorecard/openKeep card_id

→

POST /cmd/RESETReceive guid

⇄

POST /cmd/ACTIONnObserve + decide

→

POST /api/scorecard/closeFinalize

Request · click cell (57, 39)

POST /api/cmd/ACTION6
Content-Type: application/json

{
  "game_id": "ft09-0d8bbf25",
  "guid": "2fa5332c-…",
  "x": 57,
  "y": 39
}

Response · abbreviated, schema-faithful

{
  "game_id": "ft09-0d8bbf25",
  "guid": "2fa5332c-…",
  "frame": [
    [[9, 9, …], …],
    [[8, 8, …], …]
  ],
  "state": "NOT_FINISHED",
  "levels_completed": 0,
  "win_levels": 7,
  "action_input": {
    "id": 6,
    "data": {"x": 57, "y": 39}
  },
  "available_actions": [5, 6, 7]
}

The identifiers and changed crop come from a previously captured API trace. Arrays are abbreviated because one observation can contain several complete 64×64 grids.

Action vocabulary—always intersect it with `available_actions`
Action	Payload	Practical reading
`RESET`	game_id; optional guid	Start a game, reset, or advance after a win. Competition mode limits reset semantics to the current level.
`ACTION1–4`	game_id + guid	Usually directional controls, but treat the live action list and the game itself as authoritative.
`ACTION5`	game_id + guid	A game-specific button such as select, interact, or fire.
`ACTION6`	game_id + guid + x + y	Click one zero-based cell: x and y are each 0…63.
`ACTION7`	game_id + guid	Undo, only when the environment reports it as available.

A robust HTTP loop—shape, not a pasted SDK

session = requests.Session()  # keeps cookies
card_id = open_scorecard(session)
obs = reset(session, game_id, card_id)

while obs["state"] == "NOT_FINISHED":
    action = agent.choose(obs)
    assert action.id in obs["available_actions"]
    obs = step(session, obs["guid"], game_id, action)

close_scorecard(session, card_id)

Coordinates and state

frame[animation_frame][y][x]

x = 0 .. 63   # left → right
y = 0 .. 63   # top  → bottom
cell = 0 .. 15

NOT_STARTED
NOT_FINISHED
WIN
GAME_OVER

Deep · observation anatomy

One action can return a tiny movie.

frame is not a PNG, a base64 string, or a delta. It is an array of one or more complete integer grids. The agent does not act between them. Earlier elements show the animation; frame[-1] is normally the settled state used for the next decision—but discarding the earlier frames can erase causal evidence.

Figure · one response, three full frames

The same response in motion, pixels, and text

This 8×8 pedagogical crop illustrates the wire shape; competition observations can be 64×64. The red object moves toward green during a single submitted action.

One API action · three observations

Frame 0

The submitted action has started.

Frame 1

A transient animation frame.

Frame 2

The final, settled observation.

frame[0] · The submitted action has started.

5 5 5 5 5 5 5 5
5 1 1 1 1 1 1 5
5 1 9 9 9 1 14 5
5 1 9 8 9 1 14 5
5 1 9 9 9 1 14 5
5 1 1 1 1 1 1 5
5 11 11 11 11 11 11 5
5 5 5 5 5 5 5 5

frame[1] · A transient animation frame.

5 5 5 5 5 5 5 5
5 1 1 1 1 1 1 5
5 1 9 10 9 1 14 5
5 1 9 9 8 10 14 5
5 1 9 10 9 1 14 5
5 1 1 1 1 1 1 5
5 11 11 11 11 11 11 5
5 5 5 5 5 5 5 5

frame[2] · The final, settled observation.

5 5 5 5 5 5 5 5
5 1 1 1 1 1 1 5
5 1 9 9 9 1 14 5
5 1 9 9 9 1 8 5
5 1 9 9 9 1 14 5
5 1 1 1 1 1 1 5
5 11 11 11 11 11 11 5
5 5 5 5 5 5 5 5

Schematic crop authored for this chapter from the official frame[animation_frame][y][x] schema; it is not a hidden competition game.

Observed trace · ACTION6 at (57, 39)

A real crop changed blue → red

In the inspected ft09-0d8bbf25 trace, 38 cells changed overall. This 6×6 region at x=52…57, y=36…41 accounts for 36 of them.

Before · text

9 9 9 9 9 9
9 9 9 9 9 9
9 9 9 9 9 9
9 9 9 9 9 9
9 9 9 9 9 9
9 9 9 9 9 9

click(57,39)

After · text

8 8 8 8 8 8
8 8 8 8 8 8
8 8 8 8 8 8
8 8 8 8 8 8
8 8 8 8 8 8
8 8 8 8 8 8

0white

1light gray

2gray

3dark gray

4charcoal

5black

6magenta

7pink

8red

9blue

10light blue

11yellow

12orange

13maroon

14green

15purple

Core · time and action budgets

There is a runtime budget. It is global.

Kaggle allows the submitted CPU or GPU notebook to run for at most nine hours. That is the wall-clock budget for the whole hidden evaluation—not nine hours per task or per game. Because workers run together, a single hang, deadlock, runaway model call, or memory leak can strand the entire submission.

Platform wall clock≤ 9 hours

Whole Kaggle notebook rerun. This is the hard practical answer to “how long can a task run?” Individual game deadlines are your controller’s responsibility.

Evaluation action cutoff5× human

The technical report describes ARC Foundation evaluation terminating a level after five times its calibrated human action baseline. This is per level and action-count based, not a nine-hour timer.

Reference harness guard80 actions

The open agents repository currently includes an editable MAX_ACTIONS=80 safety guard. It is harness code, not the official competition’s universal action allowance.

Submission allowance5 / day

The official starter warns that each click into the competition rerun spends one of five daily official submissions. Local play and Phase A notebook validation should absorb routine mistakes.

Bootimports, weights, gateway

Playparallel games with local deadlines

Drainclose, flush, recover

The 8/82/10 split is an engineering recommendation, not an official rule. Reserve a shutdown margin and enforce monotonic per-worker deadlines so a final retry cannot overrun the notebook.

Bound every expensive call

Use timeouts for model inference, subprocesses, locks, and gateway requests. A timeout must yield a legal fallback action or a clean worker exit—not an unhandled exception.

Count actions locally

Track total actions, actions in this level, no-op streak, reset count, and repeated state-action edges. Stop speculative probing before the environment stops you.

Watch memory growth

Full 64×64 animation sequences multiply quickly across games. Content-address settled frames, compress full responses, and cap model context independently of the audit log.

Schedule shared compute

Parallel game threads can serialize on one GPU. Use a bounded inference queue, batch compatible requests, and give each game fairness so one hard environment cannot monopolize the model.

Core · Kaggle compute

Choose hardware for the agent you can finish.

The official starter exposes CPU, dual T4, single P100, and RTX 6000 settings; T4 ×2 is its default. The live competition says CPU and GPU runs share the same nine-hour ceiling. Kaggle also added g4-standard-48 RTX 6000 machines exclusively for ARC-AGI-3.

Hardware choices surfaced by the official starter
Starter value	Accelerator	Good fit	Watch out for
`cpu`	No GPU	Graph search, rules, compact learned models, deterministic rehearsal	Large multimodal inference will dominate wall clock.
`t4`	NVIDIA T4 ×2	Small models, batching, mature CUDA compatibility	Two devices help only if your code deliberately uses both.
`p100`	NVIDIA P100 ×1	Single-device workloads that fit the available image	Older architecture; test every compiled dependency offline.
`rtx6000`	RTX 6000 / `g4-standard-48`	Heavier local vision-language or world-model inference	Scarce competition resource; a larger model can still lose on latency and actions.

g4-standard-4848 vCPU

System memory180 GB

GPU1× RTX PRO 6000 Blackwell

GPU memory96 GB GDDR7

Kaggle names the machine type; the numeric machine shape above comes from Google Cloud’s current G4 documentation. Treat live notebook introspection as the final authority because hosted inventory can change.

Fail fast on the actual runtime

import os, platform, torch

print(platform.python_version())
print(torch.cuda.is_available())
print(torch.cuda.device_count())
if torch.cuda.is_available():
    print(torch.cuda.get_device_name(0))
print(os.statvfs("/kaggle/working"))

Load everything offline

# Read-only attached model/dataset
MODEL = "/kaggle/input/my-model/weights"

# Writable cache, traces, checkpoints
WORK = "/kaggle/working/agent"

# Never rely on:
# pip install from the internet
# hosted model APIs
# writes under /kaggle/input

Deep · practical playbook

Spend actions to buy information.

The strongest public systems disagree on architecture but converge on operational habits: preserve state, avoid retesting known failures, separate perception from action selection, verify an internal model against exact transitions, and keep the context presented to a model smaller than the complete trace.

Parse before you reason

Segment connected components, bounding boxes, repeated tiles, motion, counters, borders, and changed cells. Maintain both the raw grid and an object/delta view; neither representation wins every game.

Turn exploration into a graph

Hash settled observations; store tested (state, action, data) → next state edges; mark no-ops and terminal outcomes; route by shortest known paths to an untested frontier instead of random walking.

Predict whether an action matters

Rank legal actions by expected state change, information gain, and goal progress. StochasticGoose’s preview lesson was not “RL solves ARC”; it was that predicting action effects can make exploration much cheaper.

Build an executable world model

Write a compact transition program, replay known actions through it, compare predicted grids exactly, and revise the smallest violated rule. Executable models expose contradictions that prose hypotheses can conceal.

Separate four memories

Keep immutable event history, a state graph, current game hypotheses, and short policy context. Evict from the model prompt without deleting the scientific record.

Switch from explore to exploit

Once mechanics and goal are stable, stop probing. Plan a low-action route, verify after every action, and reopen exploration only when reality falsifies the model.

Deep · edge cases

The surprising failures happen outside the policy.

A Kaggle host’s review of 500 failed submissions found invisible hangs and logic errors to be the largest category, followed by accelerators that were never enabled. A competitive submission must first boot, find the gateway, use only attached dependencies, terminate every worker, and write only where Kaggle permits.

State

Lost cookie affinity

Creating a fresh HTTP client per action may route a stateful session incorrectly. Keep one session/cookie jar with the guid.

Symptom: valid IDs, impossible state.

State

Using only `frame[-1]`

The policy works until a mechanism is visible only during animation. Preserve all frames, then derive a settled view.

Symptom: unexplained transitions.

Action

Stale legal-action cache

Available actions can change after every step and terminal state. Read the returned list again before choosing.

Symptom: repeated HTTP 400.

Action

x/y transposition

Arrays index [y][x]; click payloads name x then y. Keep coordinate helpers explicit.

Symptom: clicks miss mirrored targets.

Identity

Version-blind game logic

The stable name identifies a game family; the suffix identifies a version that can change. Cache observations by full ID and make heuristics tolerant.

Symptom: yesterday’s rule almost works.

Control

Reset loop

A recovery policy resets into the same state and repeats forever. Hash post-reset state, cap resets, and advance the fallback mode.

Symptom: zero progress, high action count.

Parallel

Thread joins forever

A worker blocks on a model, lock, or request while the coordinator waits without a deadline. Use bounded queues and timed joins.

Symptom: silent nine-hour timeout.

GPU

Accelerator selected, unused

Kaggle can provide a GPU while the model remains on CPU—or only device 0 is used on a dual-T4 VM. Assert placement at boot.

Symptom: GPU idle, run too slow.

Offline

Hidden network dependency

A tokenizer, model config, package extra, license check, or font tries to download at first use. Rehearse with outbound traffic disabled.

Symptom: boot succeeds locally, rerun fails.

Filesystem

Writing to `/kaggle/input`

Inputs are attached read-only. Redirect caches, compiled kernels, traces, and temporary files to /kaggle/working.

Symptom: permission error after import.

Memory

Replay balloon

Multiple 64×64 frames per action across parallel games can grow to tens of gigabytes. Deduplicate, compress, and rotate debug artifacts.

Symptom: late OOM, lost scorecard close.

Evidence

Public overfitting

A handcrafted harness can look brilliant on a seen environment and fail harness-free or private evaluation. Keep game-specific adapters out of the general core.

Symptom: public saturation, no transfer.

Before spending a real submission

Build the notebook from a clean copy of the starter and inspect every embedded path.
Run offline with the exact attached datasets and weights; fail if any network call is attempted.
Exercise two or more games concurrently; inject slow requests, HTTP errors, malformed responses, and worker exceptions.
Confirm action payloads against available_actions, x/y orientation, cookie retention, and complete animation storage.
Measure boot time, per-turn latency, GPU utilization, peak RAM/VRAM, trace growth, and shutdown margin.
Prove every worker reaches a timed terminal path and the scorecard closes even when another worker crashes.
Open the generated submission.ipynb, not only the source file you hoped it contained.

References · retrieved July 29, 2026

The operating source ledger.

Competition rules and hosted hardware can change. Official documentation governs the contract; practitioner reports are evidence about tactics and failure modes, not new rules. Recheck the live Kaggle overview and starter commit before a serious submission.

Competition and Kaggle platform

Kaggle competition overview
The live submission constraints: CPU or GPU notebooks run for at most nine hours, internet is disabled, and the submission file is generated during the run.
Kaggle dataset quota request program
Kaggle staff's published 200 GB default per-dataset quota, account quota guidance, and exceptional public-dataset quota request path.
Kaggle kernel source limit report
The platform error enforcing notebook kernel source below one megabyte and the practical need to remove embedded output and images.
Kaggle notebook storage discussion
Community-reported working and temporary disk observations; these are operational guidance rather than ARC competition guarantees.
Competition mode
All environments count, one scorecard and one make per environment are allowed, scores remain hidden in flight, and Kaggle forces competition mode.
ARC-AGI toolkit repository
The Arcade and EnvironmentWrapper interfaces, supported local/online/offline/competition modes, and render modes.
Kaggle starter repository
The Python 3.12 starter, agent/my_agent.py entry point, generated submission.ipynb, offline wheel installation, gateway rerun, and hardware settings.
ARC-AGI-3 agents repository
The reference agent harness and its one-thread-per-game Swarm orchestration.
Google Cloud g4 machine types
The published shape of g4-standard-48: 48 vCPUs, 180 GB system memory, and one 96 GB RTX PRO 6000 Blackwell GPU.

Official game and REST contract

Actions
Action IDs, coordinate bounds, available-actions behavior, and HTTP 400 versus 500 semantics.
Games
64×64 maximum grids, 16-color cells, full animation-frame sequences, versioned game IDs, coordinates, and game states.
Scorecards
Scorecard lifecycle and the hosted API's auto-close behavior.
List available games
GET /api/games and response shape.
Open a scorecard
POST /api/scorecard/open and the card_id contract.
Start or reset a game
POST /api/cmd/RESET, guid creation and reuse, card_id, and reset behavior.
Execute a coordinate action
POST /api/cmd/ACTION6 with x/y and the complete response schema.
Submit an action with reasoning
The toolkit step contract and its optional structured reasoning record.
Close a scorecard
POST /api/scorecard/close and final scorecard state.
ARC-AGI-3 Technical Report
Turn-based benchmark design, RHAE, full observations, the five-times-human per-level evaluation cutoff, and public/private protocol boundaries.

Practitioner reports and open research

ARC-AGI-3 Preview: 30-day learnings
StochasticGoose's action-effect prediction, Blind Squirrel's graph search, no-op pruning, and the practical cost of large replay stores.
Graph-based exploration
Hashing observations, recording tested state-action edges, shortest paths to a frontier, and reset-loop failure modes.
The Duck harness
A short-context multimodal agent with a Python REPL and the importance of the harness/model split.
Executable World Models
Learning Python simulators, verifying them against exact replay, and simplifying the model when observations disagree.
World-model verification ablations
Evidence that verification helps most while consuming meaningful compute, plus the warning that public-game gains may not transfer.
Kaggle host discussion: 500 failed submissions
Community-reported failure patterns: hangs, disabled accelerators, missing offline dependencies, OOM, wrong endpoints, and writes under read-only /kaggle/input.