Second and third place in the first ARC-AGI-3 milestone both ran Gemma 4 31B, the same model this studio test stack keeps loaded, and both published their notebooks. Read side by side, the two entries share most of their code: the same constants, the same prompt, the same eight times upscaled frames, and the same 0.86 on the public leaderboard.
Here is what a Gemma 4 31B agent that placed actually does, from Reki’s notebook and the forge notebook, and what it costs.
What the Gemma 4 31B entries run on
Both notebooks serve gemma-4-31b-it from Kaggle’s model store through a locally started vLLM server on the OpenAI compatible API, unquantised, with the model path google/gemma-4/transformers/gemma-4-31b-it. The agent talks to http://127.0.0.1:8000/v1 like any other client. The forge profile pins the server to a 32,768 token model length, 94% of GPU memory, up to 20 sequences and at most four images per prompt.
The budget constants are the competition’s shape written down. Nine hours global with a twenty minute shutdown reserve, eight hours per game, a fourteen minute deadline for the first action, 400 seconds per model request, and at most 200 actions per game. ARC Prize’s milestone post describes Reki’s entry as one that “renders the recent frames as labeled images, feeds them to Gemma-4-31B locally, and asks for a single JSON object”, and the code matches that sentence exactly.
That 200 action ceiling is worth noticing against the human baselines, where the median public game takes a person 638 moves end to end. These agents are not built to finish games. They are built to clear early levels efficiently and stop.
How the agent sees four frames at eight times scale
Both agents send the model pictures, not grids. ACTION_CONTEXT_FRAMES = 4 and FRAME_IMAGE_SCALE = 8: the last four board states, each 64 by 64 cell rendered through a fixed palette at 512 by 512 pixels, attached to the request as base64 PNGs in chronological order. Red step labels are drawn onto the images so the model can tell them apart, and the prompt says so: “The images are chronological; the last is current. Red STEP labels are added chronology, not game UI.”
A three pixel border is ignored when judging progress, per FRAME_BORDER_IGNORE = 3, which is a small tell that the step counters some games draw at the edge were confusing the model. The prompt also carries a line that reads as hard won: “Trust numeric transitions over visual guesses.”
The choice lines up with what one measured pair on this stack showed, and with the Duck’s finding that a four times upscale suited Qwen’s encoder. Eight times for Gemma is the same decision at a different patch size, and the Duck’s authors reported that sending more frames or animations hurt a small model; these entries settled on four.
What one Gemma 4 31B call returns: a JSON plan of up to four actions
The model is asked for exactly one JSON object, with response_format set to json_object so the server enforces it. The prompt’s example object has fields for a board change assessment, a plan summary and an actions list, and the instruction is to “Include 1 to 4 actions; use one exploratory action if uncertain.” Action names are natural, up, down, left, right, spacebar, click, undo and reset, mapped in code to the engine’s ACTION1 through ACTION7.
The generation settings are specific: max_tokens 1,024 for an action call, temperature 0.6 with thinking enabled and 0.2 without, top_p 0.95, top_k 20, and a repetition penalty of 1.08, passed through vLLM’s chat template arguments. Thinking is a per call switch; the plan call runs lean, and the heavy thinking is spent elsewhere.
That elsewhere is a reflection. Every ten actions, REFLECTION_INTERVAL = 10, the agent makes a separate call with a 10,000 token budget and writes up to 1,800 characters of “Reflection memory (authoritative but revisable)” that is then included in every subsequent action prompt. The model gets one long think per ten moves and ten short ones, which is a budget split a per move agent on this stack never made and paid for.
How the click heuristics and the arbiter differ between the two
The shared skeleton diverges in two places.
Reki’s notebook adds what it calls “V25-fusion additions”: two “strictly-additive, default-ON click-path improvements” in pure numpy. GEMMA_SALIENT_CLICK makes fallback clicks pick “the most button-like (small + rare-colored) untested component instead of a uniformly random” cell. GEMMA_DEADSIG suppresses clicks on a structural class of component, defined by colour, size, rectangularity and twins, once clicking it has failed to change the frame twice. Both are answers to the click only games, where ACTION6 is a space of 4,096 cells and random coordinates are the worst possible policy.
The forge notebook adds a second prompt, “You are choosing among candidate action plans for the same ARC-AGI-3 state”, with ACTION_CANDIDATES = 3 and a 512 token arbiter call to pick between plans. Its published profile, though, runs with one candidate and the arbiter off, so the version that scored is close to the plain skeleton.
The notebooks do not say which came first, and this piece does not guess. What can be read is that the two Gemma 4 31B entries are one design with two sets of patches, and the design is: pictures in, a small JSON plan out, a long reflection every ten moves.
What 0.86 on the leaderboard means for a local Gemma 4 31B
Reki’s notebook shows a best score of 0.86, and forge’s title carries the same figure. Under the scoring that is a fraction of a per cent of the maximum, a few early levels cleared at some multiple of the human’s moves, across the games the agent reached in its budget. It was enough for second and third, behind the Duck’s 1.21%.
For anyone with Gemma 4 31B loaded at home, the two notebooks are the most concrete guide that exists to making it play. The parts that transfer to LM Studio unchanged are the representation and the cadence: four upscaled frames, a JSON plan with a hard cap of four moves, thinking off for the plan and on for a reflection every ten moves, and a per game action ceiling that stops the agent burning its budget on a level it has not understood. The parts that do not transfer are vLLM’s throughput and Kaggle’s 96 GB; on this machine the same model answers at eleven tokens a second, so the ten short calls and one long one per ten moves would take on the order of half an hour.
Half an hour per ten moves is slow. It is also the first design in this series that a 48 GB Mac could run end to end as published, and it placed.