A The ARC Atlas

Part Ⅸ · Results, without category errors

The winners, their methods, and one unfinished search.

The ARC lineage from Icecuber's 2020 program search to The Duck's 2026 coding agent—how each system sees, proposes, tests, remembers, and wins under its own protocol. ARC-AGI-3 is still running, so its latest names are milestone winners, not final champions.

3
Benchmark generations
19
Podium / score awards listed
16
Paper awards listed
2026
Still in progress

Read the labels first

“Winning” names four different things.

ARC reports are unusually careful about protocol. This chapter keeps that care: a private Kaggle award, a paper prize, an in-season milestone, and a closed-model benchmark record answer different questions.

1

Competition award

A final placement and cash award under that season's private evaluation, compute, openness, and eligibility rules.

2

Paper award

A research prize for explanation or method quality. It is not a leaderboard placement, even when the paper describes a high-scoring system.

3

Milestone award

A paid mid-competition checkpoint. ARC-AGI-3 has milestone winners while its 2026 final result is still open.

4

Benchmark record

A verified or reported score that moved the frontier but was not a prize win, often because the split, openness, or efficiency rules differed.

The story beneath the leaderboard

The search did not disappear. It changed address.

Every strong ARC system closes the same loop: choose a way to see the problem, propose a change, test it against reality, keep what worked, and spend the next unit of compute or action more intelligently.

The core model

The history is not symbolic methods being replaced by neural methods and then by agents. It is a sequence of relocations. Search moves from hand-written programs into latent spaces, model weights, populations of candidate programs, prompt context, persistent memories, and finally actions inside an unknown world. Each era keeps the useful machinery of the previous one while moving the bottleneck.

In static ARC, the demonstration pairs are an unusually strong oracle: a candidate transformation can be replayed exactly and rejected immediately. Icecuber exploited that oracle with a hand-built language. The 2024 systems kept exact verification but learned better proposal distributions and adapted them to each task.

ARC-AGI-2 made the rules more compositional, so a single proposal was rarely enough. The characteristic 2025 move was refinement: generate, execute, diagnose the mismatch, and feed the failure back into the next proposal. Search stopped being a one-shot ranking problem and became a conversation with a verifier.

ARC-AGI-3 removes even the demonstration oracle. The agent must create evidence by acting, decide which observation is worth buying, infer what state changes mean, and remember discoveries without drowning in history. The problem has therefore moved from solving a supplied specification to learning the specification itself.

2020–2023

Make the grid searchable

Icecuber and the symbolic lineage

Replace an open-ended visual puzzle with a finite language of objects, transforms, and compositions.

Kept: Exact replay against demonstrations.

New bottleneck: The hand-written grammar decides what can ever be discovered.

2024

Make the solver task-local

the ARChitects, MIT TTT, MindsAI

Adapt a learned model to the current task instead of asking one frozen model to solve every task.

Kept: Augmentation, candidate verification, and ensembling.

New bottleneck: A few demonstrations can support several plausible rules; local fitting can choose the wrong one.

2025

Make failure productive

NVARC and refinement-loop systems

Turn a failed candidate into information for the next candidate rather than simply discarding it.

Kept: Task-time adaptation and exact execution feedback.

New bottleneck: More refinement can still polish the wrong abstraction, and cost rises with every loop.

2025 preview

Make exploration deliberate

StochasticGoose, Blind Squirrel, Just-Explore

Choose actions for information value, record visited states, and avoid spending the action budget on repeats.

Kept: Search, but now the search tree is generated by interaction.

New bottleneck: Novelty detection is not yet a transferable model of dynamics or a theory of the goal.

2026 milestone

Make the agent a tool-using investigator

The Duck, Reki, forge

Let a multimodal model inspect several representations, write code or structured actions, reflect, and manage its own working memory.

Kept: Explicit state, verification, repair, and iterative search.

New bottleneck: The harness is competent at local play; robust transfer to unseen dynamics and goals remains unproved.

Conceptual figure · the common machine

Six verbs hiding inside almost every winning system

The implementation changes radically; the epistemic loop does not. Static solvers receive evidence as demonstration pairs. Interactive agents must manufacture evidence through action.

  1. 1

    See

    What is the state made of?

    Static ARCObjects, colors, regions, symmetries, or learned features.

    Interactive ARCRendered frames, raw grids, segments, events, and action history.

  2. 2

    Hypothesize

    What rule might explain it?

    Static ARCA DSL program, Python transform, latent program, or task-tuned prediction.

    Interactive ARCA claim about controls, dynamics, hazards, progress, or the hidden goal.

  3. 3

    Choose

    Which candidate or action is worth trying?

    Static ARCEnumerate, sample, mutate, ensemble, or rank.

    Interactive ARCPrefer information-gaining, legal, non-repeating, goal-directed actions.

  4. 4

    Test

    What did reality say?

    Static ARCReplay every demonstration pair and measure exact mismatch.

    Interactive ARCObserve the next frame, reward, death, novelty, or lack of change.

  5. 5

    Retain

    What should survive the attempt?

    Static ARCA surviving program, tuned weights, a population archive, or a vote.

    Interactive ARCA state graph, reflection note, compact rule, reusable tool, or revised plan.

  6. 6

    Transfer

    What can be reused without overfitting?

    Static ARCPrimitives, augmentations, proposal models, and refinement operators.

    Interactive ARCA general way to learn dynamics and infer goals—not a script for one seen game.

Atlas synthesis from the official competition reports and the ARC-AGI-3 Technical Report. This is a comparative model, not an organizer-defined taxonomy.

ARC-AGI-1 · 2020–2024

From symbolic search to test-time adaptation.

The first benchmark has a longer competition history than ARC Prize itself. Kaggle's 2020 podium established program search; Lab42 kept the private-test contest alive in 2022 and 2023; the 2024 ARC Prize season finally produced a step change.

2020

Kaggle Abstraction and Reasoning Challenge

The original private set: 100 tasks. The podium established symbolic program search as the early ARC template.

ARC Prize solution library
1st
Icecuber 20 / 100 private tasks

A hand-built DSL of grid operations, composed by program search and checked against every demonstration pair.

hand-built DSLprogram DAGexact verifier
  1. Recode grids as objects and primitive operations
  2. Compose primitives into candidate programs
  3. Execute every candidate on every demonstration pair

Why it won its laneIt made the open-ended puzzle finite. Once the correct transformation was expressible inside the DSL, exact replay could eliminate wrong programs with no learned judge.

Where the path stopsIts intelligence is bounded by its author-provided vocabulary. A missing primitive is not merely hard to find; it is impossible for the search to invent.

2nd
Alejandro de Miquel 2nd place

A rule-based ARC solver documented in the official competition write-up library.

Evidence boundaryThe official resource library establishes the placement and links the entrant's write-up; this Atlas does not infer a more specific architecture than the public record supports.

3rd
Ilia Larchenko 3rd place

A symbolic solution whose public sample is preserved in the official competition write-up library.

Evidence boundaryOnly a sample of the third-place solution is indexed publicly, so the conceptual comparison treats it as part of the symbolic-search lineage without inventing a complete system design.

2022

Lab42 ARCathon

The final board was low-scoring—6%, 3%, 3%—though Michael Hodel later raised the ARC record above 30% after the event.

Lab42 final standings
1st
Michael Hodel 6%

Team pablo; the event winner and the solver later associated with the post-event 30%+ record.

Evidence boundaryLab42's page provides the standings and later record context, not a full technical decomposition of the submitted solver.

2nd
Mirus Software AG · Jozef Kopanicak 3%

Team Mirus on the 100 secret-task evaluation.

3rd
Simon Strandgaard 3%

Team notXORdinary on the 100 secret-task evaluation.

2023

Lab42 ARCathon

Two teams tied the private-set world record. The official standings therefore have two first places and no second.

Lab42 final standings
Joint 1st
Team SM · Somayyeh Gholami & Mehran Kazeminia 30%

A private-test joint winner; the team's open ARC solver work continued the explicit rule-based lineage.

Evidence boundaryThe organizer record supports the tie, score, and team identity. The broader rule-based lineage is used only as context, not as a reconstruction of every component submitted.

Joint 1st
MindsAI · Jack Cole & Mohamed Osman 30%

A private-test joint winner and early deep-learning-centered ARC research program.

Evidence boundaryThe organizer record supports the joint win; later public MindsAI work establishes the neural research direction, but not a complete public blueprint of this exact entry.

3rd
Team armo · Motoki Saitama 29%

One point behind the tied leaders on the private test set.

Official awards

ARC Prize 2024 high-score awards

Private evaluation, open-source eligibility, and offline competition constraints. The 85% grand prize remained unclaimed.

Official 2024 winners report
1st · $25k
the ARChitects 53.5%

Task-local fine-tuning of an open 8B model, synthetic transformations, and a product-of-experts vote over task symmetries.

test-time trainingaugmentationproduct of experts
  1. Turn the demonstrations into many symmetry-preserving views
  2. Adapt the model to the current task
  3. Keep answers that remain plausible across every transformed view

Why it won its laneIt replaced blind enumeration with a task-shaped proposal model, then recovered rigor through symmetry agreement. The neural component proposed; the ensemble acted like a consistency filter.

Where the path stopsThe adapted model can still fit the demonstrations for the wrong reason, and ARC-AGI-2 showed how quickly this recipe degrades when multiple novel rules must be composed.

2nd · $10k
Guillermo Barbadillo 40%

Omni-ARC combined explicit transformations, augmentation, and learned selection.

hybrid searchaugmentationlearned selection

Why it won its laneIt treated symbolic transforms and learned judgment as complementary rather than rival camps: explicit operators generated interpretable possibilities while learned components helped choose among them.

Where the path stopsA hybrid inherits both bottlenecks—the symbolic library can omit the right operation, and the learned selector can prefer a plausible but wrong composition.

3rd · $5k
alijs 40%

An open competition submission tied on private score and ranked third under the contest ordering.

4th · $5k
William Wu 37%

An open private-evaluation submission recognized among the five progress-prize recipients.

5th · $5k
PoohAI 37%

An open private-evaluation submission tied on score and ranked fifth under the contest ordering.

Research track

ARC Prize 2024 paper awards

These are research awards, not high-score placements.

Official 2024 paper awards
1st · $50kpaper award

Combining Induction and Transduction for Abstract Reasoning

Li et al.

What it contributedHybridize a learned task-local transducer with an explicit program-synthesis solver.

2nd · $20kpaper award

The Surprising Effectiveness of Test-Time Training for Abstract Reasoning

Akyürek et al.

What it contributedFit a fresh model adapter to each task's demonstrations and augmentations at inference time.

3rd · $5kpaper award

Searching Latent Program Spaces

Bonnet & Macfarlane

What it contributedSearch for solution programs in a learned continuous representation rather than a fixed symbolic DSL.

Show every runner-up and recognition
  • Franzen et al. · The LLM ARChitect
  • Guillermo Barbadillo · Omni-ARC
  • Paul Fletcher-Hill · Mini-ARC
  • Ouellette · Efficient Neurally-Guided Program Induction
  • Jean-François Puget · A 2D nGPT Model for ARC Prize

For the benchmark mechanics and the full solver space, continue to ARC-AGI-1's solution chapter. For the method diagrams, see Methods & Techniques.

ARC-AGI-2 · 2025

A 24% winner—and 61 points left open.

ARC-AGI-2 deliberately broke the 2024 methods. The top open, offline system stopped at 24.03%, while more expensive verified refinement systems reached higher under a different lane. The gap is the result, not an embarrassment to hide.

Official awards

ARC Prize 2025 high-score awards

ARC-AGI-2 private evaluation. About 1,455 teams filed 15,154 entries; the 85% grand prize remained unclaimed.

Official 2025 results and analysis
1st · $25k
NVARC 24.03%

Test-time training on millions of synthetic task variants, then augmentation-aware ensembling, at roughly $0.20 per task.

synthetic curriculumcompact modeltest-time training
  1. Generate a large curriculum of ARC-like transformations
  2. Fit a compact model and adapt it again to the current task
  3. Ensemble across augmentations while respecting the contest cost lane

Why it won its laneIt made useful priors cheap. Instead of buying thousands of frontier-model samples per task, it invested in a synthetic training engine and a compact task-adaptable model.

Where the path stopsThe synthetic generator is itself a prior over possible rules. ARC-AGI-2's remaining 76 points measure the concepts and compositions that curriculum still failed to anticipate.

2nd · $10k
the ARChitects 16.53%

The 2024 product-of-experts and task-adaptation lineage rebuilt for ARC-AGI-2.

task adaptationensemble consistencymethod transfer

Why it won its laneThe architecture retained a strong general recipe—adapt locally and demand agreement—while surviving a benchmark explicitly designed to break its 2024 assumptions.

Where the path stopsThe score drop from the ARC-AGI-1 era is evidence that consistency across views cannot manufacture a missing compositional abstraction.

3rd · $5k
MindsAI 12.64%

A deep-learning-centered entry developed from the team's long-running ARC research program.

4th · $5k
Lonnie 6.67%

An open private-evaluation entry recognized in the contest's progress prizes.

5th · $5k
G. Barbadillo 6.53%

A search-and-learning hybrid that continued the Omni-ARC research line.

Research track

ARC Prize 2025 paper awards

These are research awards, not high-score placements.

Official 2025 paper awards
1st · $50kpaper award

Less is More: Recursive Reasoning with Tiny Networks

A. Jolicoeur-Martineau

What it contributedA roughly seven-million-parameter recursive model trained from scratch; strong ARC-AGI-1 performance, but a large ARC-AGI-2 drop that exposes limited transfer.

2nd · $20kpaper award

Self-Improving Language Models for Evolutionary Program Synthesis

J. Pourcel, C. Colas & P. Oudeyer

What it contributedEvolve programs, extract feedback from verification failures, and use the resulting archive to improve later proposals.

3rd · $5kpaper award

ARC-AGI Without Pretraining

I. Liao & A. Gu

What it contributedCompressARC optimizes description length with a tiny from-scratch system and no external pretraining.

Show every runner-up and recognition
  • I. Joffe & C. Eliasmith · Vector Symbolic Algebras for ARC
  • J. Berman · Evolutionary Test-Time Compute
  • E. Pang · Efficient Evolutionary Program Synthesis
  • E. Guichard et al. · ARC-NCA
  • M. Ho et al. · ArcMemo
  • Honorable mention · K. Hu et al. · ARC-AGI Is a Vision Problem!
  • Honorable mention · D. Franzen, J. Disselhoff & D. Hartmann · Product of Experts with LLMs
  • Honorable mention · G. Barbadillo · Combining Search and Learning for ARC25
  • Honorable mention · A. Das et al. · Neuro-Symbolic Compositional Reasoning
  • Honorable mention · R. McGovern · Test-Time Adaptation of Tiny Recursive Models
  • Honorable mention · P. Acuaviva et al. · Video Pretraining
  • Honorable mention · J. Cole & M. Osman · Deep Learning for ARC
  • Honorable mention · I. Sorokin & J.-F. Puget · NVARC

In their own words

How the 2025 teams built the loop

Six first-party deep dives connect the scoreboard to the representations, training pipelines, and search machinery. Play them here; transcript-derived summaries and evidence notes stay in Appendix H · Resources.

2025 paper award · 3rd place · 37:51

ARC Prize 2025 Paper Award 3rd Place: ARC without Pretraining

CompressARC

Verified records beside—not above—the winners

Poetiq refinement harness · 54% · ~$30/task
Verified refinement record, not the contest winner. A Gemini 3 Pro refinement loop reached a much higher reported score than NVARC by spending roughly 150 times more per task and running under a different evaluation lane.

Opus 4.5 Thinking · 37.6% · ~$2.20/task
Verified commercial-model record. A frontier-model benchmark result from the 2025 report, separate from the offline open Kaggle awards.

The deeper explanation of synthetic task generation, the refinement loop, tiny recursive networks, and the cost frontier lives in ARC-AGI-2.

ARC-AGI-3 · 2025–2026

Preview winners, milestone winners—no final winner yet.

ARC-AGI-3 changed both the task and the calendar. Its 2025 preview identified the first useful exploration agents. The 2026 competition now pays open-source milestone prizes before a final December result.

Official awards

ARC-AGI-3 Preview Challenge

A 30-day 2025 preview on an early interactive benchmark. These percentages are not the later harness-free launch scores or the 2026 milestone ranking.

Official preview learnings
1st
StochasticGoose · Tufa Labs 12.58%

A CNN+RL action-effect predictor guides informed search toward moves likely to change the frame.

action-effect modelinformation-seekinglearned policy
  1. Estimate which legal actions will alter the current frame
  2. Prefer actions with higher expected information
  3. Update the search from the observed transition

Why it won its laneIt attacked the most immediate scarcity: actions. A move predicted to reveal a state change is usually a better experiment than a blind move that leaves the screen untouched.

Where the path stopsVisual change is only a proxy. An action can create novelty without revealing the causal rule, advancing the level, or clarifying the hidden goal.

2nd
Blind Squirrel 6.71%

A directed graph of observed states supports systematic exploration and prevents repeated wandering.

state graphnovelty frontieranti-repetition
  1. Hash observations into explicit states
  2. Record actions as directed edges
  3. Expand unexplored edges instead of revisiting known loops

Why it won its laneIt gave the agent an external memory with topology. The system could know where it had been, which action led where, and which frontier remained untried.

Where the path stopsA graph records experience but does not explain it. Similar-looking states may differ, and a complete local map still does not identify the objective.

3rd
Just-Explore 3rd place

A training-free salience-and-state-graph explorer spends the full interaction budget without a per-step model call.

training-freesaliencebudget discipline

Why it won its laneIt showed that systematic exploration itself is a competitive capability. By avoiding an expensive model call at every step, it could devote the interaction budget to coverage.

Where the path stopsCoverage without semantic modeling can find transitions yet fail to recognize which transitions constitute progress.

After the preview

When curiosity stopped being enough

Tufa Labs revisits StochasticGoose, the preview-winning action-effect prior, and what broke when unseen games and action efficiency changed the objective.

ARC-AGI-3 preview · StochasticGoose · 1:24:35

ARC-AGI-3 winning team: Millennia of minds, compressed into words

Tufa Labs

Official awards

ARC Prize 2026 · ARC-AGI-3 Milestone Prize #1

$37.5k mid-competition award through June 30. This is not the final 2026 podium.

Official Milestone #1 report
1st
The Duck · Tufa Labs Milestone winner

Qwen 3.6 27B FP8 writes and runs Python in a live REPL, switching among rendered images, raw grids, and segmentation views while evicting old context.

representation switchinglive Pythoncontext eviction
  1. Inspect the world through the representation best suited to the current question
  2. Write and execute Python to measure, transform, or track it
  3. Keep compact conclusions and evict obsolete working context

Why it won its laneIt turns the model from a narrator into an investigator. Code provides exact scratch work, multiple views expose different regularities, and context eviction protects the active hypothesis from stale history.

Where the path stopsA powerful workbench can still encode local trial-and-error rather than a transferable dynamics model. Milestone success is evidence of useful agency, not yet of general interactive intelligence.

2nd
Reki Milestone runner-up

Gemma-4-31B acts as a vision policy with JSON actions, short action queues, reflection memory, legal-action guards, and rare-color click heuristics.

vision policyreflection memoryaction guards
  1. Describe the recent frames and retrieve compact reflections
  2. Return a constrained action or short queue
  3. Repair invalid moves and revise memory after progress or death

Why it won its laneIt reduces execution entropy. Structured actions, guards, short queues, and reflections keep a general vision model inside the legal and locally useful part of the action space.

Where the path stopsRare-color and repeated-death heuristics are effective local biases, but they may not survive worlds whose important variables are not visually rare or whose failures are subtle.

3rd
forge · Md Boktiar Mahbub Murad Milestone third

A configurable Gemma-4-31B vision-policy framework with structured actions, reflection memory, repair, and optional generation/arbiter machinery.

configurable policyrepairoptional arbiter
  1. Generate a structured policy action from the current observation and memory
  2. Validate and repair the action before execution
  3. Optionally compare proposals through generation and arbitration machinery

Why it won its laneIt treats the harness as an experimental platform: the policy, memory, validation, generation, and arbitration layers can be separated and tested rather than fused into one opaque prompt.

Where the path stopsThe submitted winning profile left much of the optional machinery disabled, so the milestone validates the disciplined core more strongly than the full framework's hypothetical combinations.

The ARC-AGI-3 chapter explains why a state graph, a rare-color click heuristic, reflection memory, or a Python REPL can improve exploration without yet delivering transferable world modeling and goal inference.

Five paths through the solution space

Separate the schools. Then watch them merge.

These families disagree about the best representation and where adaptation should live. Yet every later family quietly imports machinery from an earlier one: explicit execution, learned proposals, verifier feedback, compressed state, or deliberate exploration.

Path 1

Explicit program search

A puzzle is a small program hiding behind pixels. Define the right vocabulary and search compositions until one exactly replays the examples.

  1. Parse the grid into objects and relations
  2. Compose hand-written transformations
  3. Execute candidates on every demonstration
  4. Keep exact matches and vote or rank
Wins when

The required rule lies inside the grammar and the demonstrations eliminate most false programs.

Breaks when

The right concept is absent from the DSL, compositions explode, or several programs fit the examples but diverge on the test.

ExamplesIcecuber; later Python and evolutionary program-synthesis systems

Merge pointNeural proposal models and learned ranking can steer the same exact verifier.

Path 2

Task-time neural adaptation

The demonstrations are a tiny temporary dataset. Fit the model to this task, manufacture more views with augmentation, and combine predictions that remain consistent.

  1. Augment the task under valid symmetries
  2. Adapt weights or a small task-local module
  3. Predict under several transformed views
  4. Combine the views with an ensemble or product of experts
Wins when

The model contains useful visual priors and task-local fitting can reorganize them around the new rule.

Breaks when

The task demands a composition outside the learned prior or the adapter overfits the handful of examples.

Examplesthe ARChitects; MIT test-time training; MindsAI; NVARC

Merge pointProgram search supplies candidates and verification; synthetic generators widen the temporary dataset.

Path 3

Evolution and refinement

A wrong answer is not waste. Execute it, inspect the failure, preserve useful fragments, and make the next proposal conditional on what went wrong.

  1. Generate a candidate program or explanation
  2. Run it against the demonstrations
  3. Turn the mismatch into critique or fitness
  4. Mutate, repair, recombine, and repeat
Wins when

Feedback is exact, candidates are executable, and each iteration narrows the hypothesis space.

Breaks when

The feedback rewards surface fit, the proposal language cannot express the rule, or the compute budget buys many variations of the same mistake.

ExamplesEvolutionary program synthesis; self-improving LMs; Poetiq-style refinement

Merge pointLLMs provide proposals, symbolic execution supplies truth, and archives provide memory.

Path 4

Small-model compression

Reasoning may be the search for the shortest reusable explanation. Use a tiny recursive system or description-length objective to resist memorizing accidental detail.

  1. Represent a candidate explanation compactly
  2. Apply it repeatedly or recursively
  3. Measure fit plus complexity
  4. Prefer the smallest explanation that survives
Wins when

The task has a clean low-description-length structure that repeated computation can expose.

Breaks when

Novel compositions require missing primitives or the compact model's strong bias excludes the right solution.

ExamplesTiny Recursive Model; CompressARC

Merge pointSearch can propose compact structures; verification and minimum-description-length ranking select among them.

Path 5

Interactive agents with memory and tools

The specification is not given. The agent must earn it by acting, convert observations into a world model, infer the goal, and plan under an action budget.

  1. Inspect several representations of the current frame
  2. Choose an action for information or progress
  3. Record state changes, deaths, and repeated paths
  4. Reflect, repair, write a tool, or revise the plan
Wins when

Exploration is selective, memory stays compact, and the system turns observations into causal predictions that guide efficient action.

Breaks when

It confuses visual novelty with progress, bloats its context, hard-codes a seen environment, or never infers what winning means.

ExamplesStochasticGoose; Blind Squirrel; Just-Explore; The Duck; Reki; forge

Merge pointState graphs supply explicit memory, learned policies prioritize actions, and executable code externalizes reasoning.

Same loop, different machinery

Nine systems, compared by where thinking lives.

Scores cannot be placed on one honest axis across different datasets and protocols. Mechanisms can. This matrix compares the state representation, proposal engine, feedback channel, memory, and failure boundary of the most informative systems.

Comparison matrix

The anatomy of a solution loop

Read across a row to see one architecture. Read down a column to watch the same cognitive job migrate from programs to weights, archives, graphs, memories, and tools.

Comparison of representative ARC winning and milestone systems by mechanism
System Representation Proposal engine Feedback Adaptation lives in Memory Winning edge Blind spot
Icecuber2020 Hand-written grid DSL and object primitives Enumerate compositions in a program DAG Exact replay on demonstrations Search state Intermediate programs and surviving matches Reliable, interpretable execution Cannot discover outside its grammar
the ARChitects2024 Task-augmented grids inside an open 8B model Task-tuned neural predictions across symmetries Demonstration loss plus product-of-experts agreement Model weights and ensemble Task-local parameters Learns a proposal distribution instead of enumerating blindly Task-local fit can choose the wrong abstraction
NVARC2025 Compact model trained on synthetic ARC-like tasks Test-time-trained predictions and augmentation ensemble Synthetic supervision and demonstration consistency Data generator plus task-local weights Pretraining corpus and adapted parameters Efficient score under the competition cost lane Still stops at 24.03% on compositional novelty
Evolutionary refinement2024–2025 Executable Python programs or program descriptions LLM generation, mutation, repair, and recombination Execution mismatch becomes critique or fitness Population and feedback history Archive of candidates and useful fragments Makes failure directly productive Can spend heavily refining a false framing
Tiny / compressed reasoning2025 Small recursive network or compact description Repeated computation under a strong simplicity bias Task fit balanced against model or description complexity Tiny weights or compact program Compressed parameters Challenges the assumption that scale or pretraining is necessary Strong bias collapses on unfamiliar compositions
StochasticGoose2025 preview Frames plus learned action-effect predictions Prefer actions likely to change the screen Observed visual change Exploration policy Recent interaction evidence Spends actions on potentially informative moves Change is not the same as causal understanding or progress
Blind Squirrel / Just-Explore2025 preview Explicit graph of observed states and actions Visit novel states and avoid repeated edges Graph expansion, repetition, and dead ends Exploration frontier Persistent state graph Systematic coverage without constant model calls A map of visits does not explain dynamics or goals
The Duck2026 milestone Rendered images, raw grids, segments, and executable scratch code A local multimodal model writes analysis and Python Environment response plus program output Context, code, and tool state Managed context with deliberate eviction Externalizes reasoning and switches representation when stuck Local competence has not yet proved transferable modeling
Reki / forge2026 milestone Images, structured observations, legal actions, and reflection notes Vision-policy JSON actions, queues, heuristics, and optional arbitration Next frame, invalid-action repair, deaths, and progress cues Prompt state, reflections, and configurable policy machinery Persistent compact reflections Disciplined execution and robust action formatting Heuristics and reflections can remain environment-specific

Mechanism synthesis from the public solution descriptions and reports linked in the source trail below. Entries describe representative architecture, not a controlled score comparison.

Icecuber ↔ the ARChitects

Shared structureBoth create many candidates and keep only candidates consistent with the demonstrations.

The splitIcecuber hand-defines the proposal language; the ARChitects adapt a learned model and demand agreement across transformed views.

What the split teachesNeural adaptation did not remove program-search logic. It learned where to search and how to combine evidence.

the ARChitects ↔ NVARC

Shared structureBoth treat each task as a temporary learning problem and rely on augmentation-aware ensembling.

The splitNVARC pushes more structure into synthetic data generation and a compact model rebuilt for ARC-AGI-2's cost and composition regime.

What the split teachesA winning method is a method plus a protocol: the benchmark changed, so the data engine and cost profile had to change too.

Test-time training ↔ evolutionary refinement

Shared structureBoth adapt after seeing the task and use demonstrations as feedback.

The splitTest-time training stores the change in weights; evolution stores it in a population, archive, and sequence of executable repairs.

What the split teachesThe central design choice is not learning versus search. It is where the hypothesis and its revision history live.

NVARC ↔ tiny recursive systems

Shared structureBoth challenge brute-force frontier-model inference and prize compact, task-shaped computation.

The splitNVARC wins through a large synthetic curriculum and task adaptation; tiny systems win explanatory value through recursion or compression with minimal pretraining.

What the split teachesEfficiency has at least two forms: cheap execution at scale and a small hypothesis class that refuses irrelevant complexity.

StochasticGoose ↔ Blind Squirrel

Shared structureBoth attack ARC-AGI-3 first as an exploration problem rather than pretending the goal is already known.

The splitStochasticGoose learns which actions alter the frame; Blind Squirrel explicitly maps visited states and transitions.

What the split teachesOne compresses experience into a policy, the other into a graph. The missing merge is a causal model that can predict and explain.

The Duck ↔ Reki / forge

Shared structureAll use local multimodal models, structured interaction, memory management, repair, and small open harnesses.

The splitThe Duck leans into executable Python and representation switching; Reki and forge emphasize constrained vision-policy actions, queues, reflections, and guards.

What the split teachesThe frontier is splitting between agents that think by building tools and agents that think by maintaining disciplined policy state. A final winner may need both.

Frontier milestones · not prize winners

The records that changed the benchmark.

These results belong in the history, but not in a winners table. Keeping them in their own lane makes the story more accurate, not less dramatic.

2024
MindsAI ARC-AGI-1 55.5% private

Ineligible for the 2024 high-score prize because the submission was not open sourced.

2024
Jeremy Berman ARC-AGI-1 53.6% ARC-AGI-Pub

First on the separate public leaderboard, which carried no 2024 prize.

2024
MARA(BARC) + MIT ARC-AGI-1 47.5% ARC-AGI-Pub · 62.8% public eval

A test-time-training milestone on a separate evaluation surface, not the Kaggle private-award board.

2024
OpenAI o3 ARC-AGI-1 75.7% efficient · 87.5% high compute

A proprietary ARC-AGI-Pub benchmark record that did not satisfy the open-source and efficiency conditions of the grand prize.

2025
Poetiq ARC-AGI-2 54% · ~$30/task

A verified refinement record on a different cost/evaluation lane; NVARC won the offline competition at 24.03% and ~$0.20/task.

2026
Launch-era frontier models ARC-AGI-3 0.10–0.50% harness-free

Official baseline measurements from the technical report, not competition entries or awards.

What the winners teach

One repeated move: adapt, verify, retain.

Across four eras, successful systems build a representation, test it against available evidence, and retain what works. The evidence changes—from demonstration pairs to interaction—but the loop remains.

ARC-AGI-3's milestone agents improve observation, memory, action selection, and tool use. They have not yet demonstrated that a compact dynamics model and inferred goal can transfer to the next hidden environment. The mechanism-by-mechanism account lives in Methods & Techniques.

A plausible path to the final ARC-AGI-3 podium

The winner may be a careful merger.

A plausible final ARC-AGI-3 winner is not one current agent made larger. It is a merger: explicit state, learned action value, executable tools, compact memory, causal modeling, goal inference, and transfer-aware planning under RHAE.

  1. 1

    Borrow from · The Duck

    Build several views of the same world

    Move among pixels, raw cells, segments, objects, event traces, and code-generated measurements.

    Why the merge mattersA single rendering can hide the variable that matters; representation switching makes the agent less hostage to one visual prior.

  2. 2

    Borrow from · Program search and refinement

    Maintain competing hypotheses

    Keep several explicit claims about controls, transitions, hazards, progress, and possible goals.

    Why the merge mattersCommitting early to one story creates elegant but useless plans. Competing hypotheses turn ambiguity into something testable.

  3. 3

    Borrow from · StochasticGoose and state-graph explorers

    Price actions by information and progress

    Choose actions that discriminate between hypotheses or advance a likely plan while avoiding repeated or illegal moves.

    Why the merge mattersRHAE punishes wandering. Exploration must buy either knowledge or progress.

  4. 4

    Borrow from · The missing capability

    Learn a causal world model

    Predict what will change, what will remain invariant, and how hidden variables respond across more than one local trajectory.

    Why the merge mattersA novelty detector says that something happened. A world model says why—and what will happen next.

  5. 5

    Borrow from · The missing capability

    Infer and revise the goal

    Treat progress indicators, level transitions, rewards, deaths, and reversible experiments as evidence about what counts as winning.

    Why the merge mattersPlanning is impossible if the objective is merely assumed. ARC-AGI-3 makes goal discovery part of intelligence.

  6. 6

    Borrow from · The Duck, Reki, and forge

    Externalize planning and execution

    Use code for exact bookkeeping and simulation, structured actions for safe execution, and an arbiter when model proposals conflict.

    Why the merge mattersLanguage-model context is a poor database and a poor calculator. Tools let the model spend its capacity on abstraction and revision.

  7. 7

    Borrow from · State graphs, reflection memory, and minimum description length

    Compress memory into reusable rules

    Retain causal rules, falsified hypotheses, subgoals, and reusable procedures while evicting redundant frames and narration.

    Why the merge mattersThe agent needs history without replaying its entire history. Compression is what turns experience into knowledge.

  8. 8

    Borrow from · What no milestone has yet demonstrated

    Transfer the learning procedure

    Carry forward how to explore, model, infer, and plan—without carrying a hidden script for the previous environment.

    Why the merge mattersThe final benchmark is not asking whether one game can be engineered. It asks whether the agent can repeatedly learn games its designer has not seen.

Six tests the merged system must survive

  • Seen-environment test: does performance survive when every game-specific heuristic is removed?
  • Counterfactual test: can the agent predict the result of an untried action before taking it?
  • Goal-revision test: will it abandon an attractive but false objective when later evidence conflicts?
  • Memory test: does more experience make the policy clearer, or merely make the context longer?
  • Efficiency test: can it learn within the human-relative action budget rather than brute-force the transition graph?
  • Transfer test: does the same learning loop work on a hidden environment with different objects, controls, dynamics, and success signals?

What the whole search has been trying to become

The common thread is verification: programs against demonstrations, adapted predictions against examples, refinements against execution, and beliefs against an interactive world. A future winner will need to choose informative experiments, compress their results into a model, revise its goal when evidence changes, and succeed without trying everything.

Agent Architecture Atlas

Compare systems by their information loop.

Names and scores age quickly. Architecture is more durable: how a system represents the world, chooses experiments, stores experience, rejects wrong models, and plans its next action.

01

Directed state graph

Blind Squirrel / Just Explore

Represent
Observed states and transitions
Explore
Search unvisited graph edges
Remember
Explicit state graph
Verify
State equality and replay
Plan
Graph search

Evidence boundary: Limited

02

Learned action effects

StochasticGoose

Represent
CNN transition/value estimates
Explore
Prioritize likely progress
Remember
Replay buffer
Verify
Observed reward and transition
Plan
Informed search

Evidence boundary: Model-dependent

03

VLM tool harness

The Duck / Reki / forge

Represent
Images, grids, segments, notes
Explore
Model-selected probes
Remember
Summaries, queues, eviction
Verify
Guards and visual checks
Plan
Short-horizon tool use

Evidence boundary: Public/private milestone evidence

04

Executable world model

EWM

Represent
Persistent Python simulator
Explore
Resolve model contradictions
Remember
Code plus transition log
Verify
Exact replay
Plan
Simulate before acting

Evidence boundary: Public set only

05

Ontology-guided model

OPINE-World

Represent
Object-centric program
Explore
Prioritize ontology error
Remember
Program plus counterexamples
Verify
CEGIS replay
Plan
Model-based

Evidence boundary: Public set only

Primary-source trail

Every result points back to its protocol.

The local vendor/arcprize/ corpus contains an original Markdown research record for every public blog-index item plus a page-indexed research edition of the ARC-AGI-3 report. The canonical sources remain the authority.

1source

ARC Prize blog archive

Closed enumeration of the 37 public index items researched through July 29, 2026.

Open the original
2source

ARC Prize 2024 Winners & Technical Report

2024 high-score prizes, ARC-AGI-Pub non-prize table, paper awards, eligibility note.

Open the original
3source

ARC Prize 2025 Results and Analysis

2025 high-score and paper awards, honorable mentions, verified industry records, refinement synthesis.

Open the original
4source

ARC-AGI-3 Preview: 30-Day Learnings

2025 preview rankings and the search-versus-modeling diagnosis.

Open the original
5source

ARC Prize 2026 Milestone Prize #1

The Duck, Reki, forge, and the architecture of each open milestone submission.

Open the original
6source

ARC-AGI-3 Technical Report

Interactive benchmark design, scoring, human calibration, harness boundary, and launch baselines.

Open the original
7source

ARC Prize competition solution library

Official index to the 2020 Kaggle podium and public solution write-ups.

Open the original

YouTube first · local synths follow

ARC Radio

01 / 12 🦉 8-Bit Chiptune Playlist 🦉 Retro Video Game Music for Nostalgic Vibes YouTube · external stream

The 4 requested YouTube selections play first and require a network connection; their titles refresh from YouTube when they load. 8 original AI-composed retro-game loops follow and are generated live in your browser. Audio keeps playing when you close this panel and stops only when you press Pause.

Field notes · reader review

Help improve this guide

Found a wrong score, broken link, missing paper, or unclear passage? Tell us what you noticed.

How useful is it? optional
- / 5
What kind of note? optional

No account, no tracking. Sent straight to the maintainer.