Tracing the Thoughts of a Coding Agent Playing ARC-AGI-3: Lessons for Continual Learning

Chen Wu; Josh Passenger; Yin Song

cs.AIOct 8, 2026

Tracing the Thoughts of a Coding Agent Playing ARC-AGI-3: Lessons for Continual Learning

Authors: Chen Wu, Josh Passenger, Yin Song

Organizations: AWS

Abstract

We study how a coding agent learns across a sequence of abstract reasoning tasks. The agent runs on a frozen foundation model inside a fixed harness and acts by writing and running Python and shell scripts. It retains no state across turns other than its written artifacts, so every thought it forms, carries, corrects or abandons leaves a trace, where a thought is any belief, rule or plan committed to a file. We let the agent play ARC-AGI-3, a set of interactive reasoning games that provide no instructions. Each game is a sequence of levels, and a strategy that clears one level can fail on the next, so every new level is in effect a new task. The agent records what it learns as Python scripts and text notes, while the harness keeps a complete log of every action and observation. Our contribution is a measurement protocol that traces each thought through these files, from the task where it forms to the task where it is corrected or abandoned, applied to seven evaluation runs with three backbones from two model families. Scripts written for one task are almost never called again in a later task (33 of 630 references cross a task boundary), because most scripts embed the state of the current level. Instead, the agent rewrites its knowledge into new scripts, keeping the general rules and dropping the level-specific details, and abandons 74% of the scripts it wrote before a boundary. The notes, which only the model reads, are never revised: the agent appends without removing earlier claims, and the contradictions that accumulate are settled against the log. Because the log preserves everything, the agent forgets selectively, not catastrophically. The most costly error is a hard-coded value carried into a task where it no longer holds. These findings come from the files the agent wrote, without access to the model, and constitute a white-box analysis of how a coding agent continually learns.

Figures & tables

Figure 1: The loop, taken unmodified from PRO-LONG ( Fox et al., 2026 ) , with runs differing only in backbone, prompt and operating mode (Table 1 ). The analyzer, the only component that makes a decision, reads logs.txt and writes its intended actions to actions.json . The runner issues one action at a time, appends each action and the returned board to logs.txt , and invokes the analyzer again once its queue empties, discarding any queued plan when the score changes.

Run	Backbone and condition	RHAE	Levels	Boundaries	Scripts	Notes
Anthropic backbones
R1	Opus 4.7, action cap 20	46.82%	116	107	898	225 kB
R2	Opus 5, online mode	98.33%	181	158	675	1,375 kB
R3	Opus 5, competition mode	96.87%	179	156	680	1,313 kB
R4	Opus 5, prompt priors removed	99.95%	183	158	734	1,357 kB
Local Qwen3.8-27B-FP8 on 8 H100s, offline, action cap 50

Table 1: The seven runs. They differ in backbone, prompt, action cap and operating mode, and are not repetitions of one experiment, so we do not rank them, attribute no difference to a single factor, and report counts without confidence intervals. The spread lets us ask which behaviors hold across conditions. RHAE is Relative Human Action Efficiency as defined by ARC Prize ( ARC Prize Foundation, 2026a ) , which rewards clearing a level in fewer actions than the upper-median first-time human. For reference, PRO-LONG ( Fox et al., 2026 ) reports 97.4% best@2 RHAE with Fable 5 under a 2,000-action limit, a figure not comparable to R4, which differs in backbone, action cap, run selection and scoring mode. Boundaries counts the within-game level transitions observed, the unit of Section 4 . Scripts excludes the log-reading library supplied to the Qwen runs.

Outcome	Counted as	What it means	Reported in
reused by reference	a script written after the boundary imports or exec s it	the script is still imported in the next task	Section 4.2
reused by copying	a different script written after the boundary contains one of its functions with an identical body	a function of the script is carried into the next task, the script is not	Section 4.2
rewritten	a new version of the script is written after the boundary	the script is replaced by a new version in the next task	Section 4.1
abandoned	none of the above, no later script rewrites, imports or copies it	the script is not carried into the next task	Section 4.2

Table 2: The four outcomes for a script at a task boundary, how each is counted from the files, and where each is reported. The first two are the forms of transfer, the third is revision, the fourth is disposal. The outcomes apply to scripts. The notes are written for the model rather than for the scripts, and a correction is appended to them rather than applied, so their only outcome is to grow (Section 4.3 ).

Figure 2: The reuse graph for one game, sk48 in run R4. Each box is a script, each gray outline groups the scripts of one level, written left to right. A solid arrow is reuse by reference, a dashed arrow reuse by copying (Section 3.4 ). All 19 solid arrows stay inside one level. All 15 dashed arrows cross between levels. Reuse also starts late: levels 1 to 6 hold 13 scripts and one arrow, levels 7 and 8 hold 31 scripts and the other 18.

Run	Index	Notes	Level	Action or turn	Under a level	Level-named
		(kB)	headings	headings	heading	files
R1	one file per level	225	89	57	59%	227
R2	level sections, one file	1,375	552	806	93%	47
R3	level sections, one file	1,313	414	754	93%	68
R4	level sections, one file	1,357	397	824	98%	104
R5	its own turn	719	88	292	55%	184

Table 3: How the notes of each run accommodate a task change. Notes totals every file matching notes*.md , which matters for R1 because it writes 101 of them. Under a level heading is the share of notes text beneath an explicit level heading. Level-named files counts scripts whose filename names a level. Index is the key under which the notes of each run are organized, and the three backbones use three different ones.

Figure 3: The four subsections of Section 4 , one task change seen four ways. A thought is rewritten into the next version with its rules kept and its details retyped (Section 4.1 ), reused by reference within the task and by copying across it (Section 4.2 ), appended to notes that only grow (Section 4.3 ), or carried across stale until the new task exposes it (Section 4.4 ). Solid arrows are actions on live scripts and the dashed arrow is content copied into a different script, as in Figure 2 .

Explore similar work

May 6, 2026cs.AI

Executable World Models for ARC-AGI-3 in the Era of Coding Agents

We evaluate an initial coding-agent system for ARC-AGI-3 in which the agent maintains an executable Python world model, verifies it against previous observations, refactors it toward simpler abstractions as a practical proxy for an MDL-like simplicity bias, and plans through the model before acting. The system is intentionally direct: it uses a scripted controller, predefined world-model interfaces, verifier programs, and a plan executor, but no hand-coded game-specific logic. The agent-facing prompts, workspace, and controller contain no game-specific code, game-specific prompts, hand-coded heuristics, hidden solutions, or other game-specific information; the same agent and prompts are used across games. Because the coding agent has broad system access, we audit unintended information channels, describe earlier vulnerable harnesses, and explain how the current harness closes observed leakage channels while reducing benchmark-specific information exposure. We report results on the 25 public ARC-AGI-3 games. Each playthrough starts from a fresh agent instance and clean workspace, with no access to files or conversation state from earlier playthroughs. With GPT-5.5 high reasoning effort, the agent fully solved 15 games and achieved a mean per-game RHAE of 58.12%. With GPT-5.4 high reasoning effort, it fully solved 8 games and achieved a mean per-game RHAE of 41.29%. Performance on the private validation set, which is not yet available to us, remains to be tested. Overall, the results provide preliminary evidence that verifier-driven executable world models are a promising approach for ARC-AGI-3 agents. Full run artifacts are released with the code at https://github.com/astroseger/arc-3-agents-baseline1.

Sergey Rodionov

SingularityNET

World Models Coding Agents AI Agent Evaluation ARC-AGI LLM Agent Planning

Ask PDF

Jul 6, 2026cs.LG

Latent Programming Horizons in Coding Agents

A coding agent solving a software-engineering task spends dozens of steps reasoning, editing code, and running tests, yet little is known about what the underlying language model internally represents about the program it is working on. We show that the residual streams of language models under coding agents linearly encode properties of the evolving program: a logistic-regression probe on hidden states is able to decode whether the current code parses, passes its test suite, reduces the number of failing tests, and introduces regressions, reaching AUC up to 0.83 for correctness across two models and two benchmarks. Our second finding is more surprising: these representations run ahead of the agent's own edits. Probes trained to predict the outcome of future edits (before they are materialized and written on disk) achieve performance above chance up to roughly 25 steps in advance. We call this the agent's latent programming horizon. As a proof of external validity, we show that the probes transfer across benchmarks without retraining. Our positive results open calls for more research in mechanistic interpretability of coding agents.

André Silva, Han Tu, Martin Monperrus

KTH Royal Institute of Technology Stockholm, Sweden

LLM Interpretability Coding Agents Language Model Probing

Ask PDF

Jun 11, 2026cs.LG

Getting Better at Working With You: Compiling User Corrections into Runtime Enforcement for Coding Agents

Interactive LLM agents are becoming part of daily work, but they do not reliably become easier to work with over time: a correction remembered in one session may still be violated in the next. We study this gap between preference access and preference compliance. In tasks derived from anonymized real-user friction cases, Mem0 memory still leaves 57.5% of applicable preference checks violated. We introduce Test-time Rule Acquisition and Compiled Enforcement (TRACE), a drop-in skill-layer pipeline for coding-agent runtimes that mines user corrections, rewrites them as atomic rules, and compiles them into runtime checks that must pass before an agent completes future tasks. Unlike runtime checks written ahead of time by developers, TRACE skills come from the user's own chat corrections. We evaluate TRACE with simulated user-in-the-loop experiments on ClawArena coding-agent tasks and MemoryArena-derived memory-intensive tasks. On ClawArena, TRACE reduces held-out preference violation from 100.0% to 37.6% on in-distribution tasks and from 100.0% to 2.0% on out-of-distribution tasks. On MemoryArena-derived tasks, TRACE reduces in-distribution violation from 100.0% to 60.5% while matching or exceeding the strongest memory baseline on task pass. These results suggest that compiling corrections into runtime enforcement can address a repeated-friction failure mode that memory alone does not reliably solve, reducing the need for users to restate the same correction across future sessions. Experiment code is available at https://github.com/YujunZhou/TRACE_exp, and the deployable skill is available at https://github.com/YujunZhou/tellonce.

Yujun Zhou, Kehan Guo, Haomin Zhuang +8

University of Notre Dame · Tencent AI Lab · IBM Research

Coding Agents LLM Agent Memory LLM Agent Skill Learning Runtime Enforcement for AI Agents

Ask PDF