ARC Prize — Complete Guide

What Is ARC Prize?

The world's most prestigious AI/AGI competition. ARC-AGI tests whether AI can reason the way humans do on abstract visual tasks. Winning requires genuine AI breakthroughs — not just engineering tricks.

2026 Prize Pool: $2,000,000

• Hosted on Kaggle
• URL: arcprize.org/competitions/2026

Two Tracks in 2026

ARC-AGI-2

• Prize: $1,000,000
• Goal: Open source a solution that achieves a breakthrough on ARC-AGI-2 benchmark
• 1st prize: $425K (requires open-source + interview + solution review)
• Requirement: Must open-source your solution BEFORE receiving official scores

ARC-AGI-3

• Prize pool: $75,000 in milestone prizes
• New format: Build AI agents that PLAY ARC-AGI-3 games
• Milestone 1 (Jun 30 2026): 1st $25K, 2nd $10K, 3rd $2.5K
• Milestone 2 (Sep 30 2026): 1st $25K, 2nd $10K, 3rd $2.5K
• Final submission: Nov 2 2026
• Results: Dec 4 2026

Key Dates 2026

Date	Event
Mar 25 2026	Competition opens
Jun 30 2026	ARC-AGI-3 Milestone 1
Sep 30 2026	ARC-AGI-3 Milestone 2
Nov 2 2026	Final submissions due
Nov 8 2026	Papers due
Dec 4 2026	Results announced

---

What ARC Tasks Look Like

Each task has a grid-based input/output pattern. The model must infer the RULE from 2–5 examples and apply it to a test grid.

Training example 1:
Input:          Output:
[[0,0,2],       [[0,0,0],
 [0,2,0],        [0,0,2],
 [2,0,0]]        [0,2,0]]

Test:           → Your model must predict this output
Input:
[[1,0,0],
 [0,1,0],
 [0,0,1]]

The task above might encode "shift all colored cells down by one". Your model must generalize the rule from examples — not memorize.

---

What Approaches Actually Work

Approach 1: Program Synthesis (Top Method)

Treat ARC as a programming puzzle — search for a program that transforms input → output.

Domain-Specific Language (DSL) approach:

1. Define a set of primitive operations (rotate, mirror, recolor, crop, tile, etc.)
2. Compose operations to generate candidate programs
3. Search for the combination that produces correct outputs for all training pairs
4. Apply winning program to test input

# Example DSL primitives
def rotate_90(grid): return [list(row) for row in zip(*grid[::-1])]
def flip_h(grid): return [row[::-1] for row in grid]
def recolor(grid, from_color, to_color):
    return [[to_color if c == from_color else c for c in row] for row in grid]

# Composition search (brute force for 1-2 operations)
from itertools import product

PRIMITIVES = [rotate_90, flip_h, lambda g: flip_h(rotate_90(g))]

def search_program(train_pairs):
    """Find single operation that works on all training pairs."""
    for fn in PRIMITIVES:
        if all(fn(inp) == out for inp, out in train_pairs):
            return fn
    return None

Why it works: 80%+ of ARC tasks can be solved with 3–5 chained primitive operations. DSL approaches won the 2024 competition.

Approach 2: LLM with Few-Shot Reasoning (o3, Gemini 2.5)

Use frontier LLMs with in-context examples. Describe the grid transformation in text and ask the model to infer the rule.

Key finding from 2024: OpenAI's o3 achieved 75.7% on ARC-AGI-1 (previously only 4% with GPT-4). This was a breakthrough moment showing chain-of-thought reasoning helps significantly.

# Prompt template for LLM approach
PROMPT_TEMPLATE = """
You are solving an ARC (Abstraction and Reasoning Corpus) task. 
Study the training examples carefully to identify the transformation rule,
then apply it to the test input.

Training Examples:
{training_examples}

Test Input:
{test_input}

First, describe the transformation rule you observe in the training examples.
Then apply this rule step-by-step to the test input.
Output ONLY the final grid as a Python list of lists.
"""

def arc_with_llm(task, model_client):
    training_str = "\n".join([
        f"Example {i+1}:\nInput: {pair['input']}\nOutput: {pair['output']}"
        for i, pair in enumerate(task['train'])
    ])
    prompt = PROMPT_TEMPLATE.format(
        training_examples=training_str,
        test_input=task['test'][0]['input']
    )
    return model_client.generate(prompt)

Approach 3: Neural + Symbolic Hybrid (Best 2024 Open Source)

Combine neural network perception with symbolic rule search:

1. Neural net encodes the grid structure (color patterns, object positions)
2. Symbolic search finds the transformation rule over the encoded representation
3. Apply rule to test input

Approach 4: Test-Time Training (TTT) for Vision Models

Fine-tune a pretrained vision model on each individual task at test time:

1. Create synthetic variants of the training pairs (augmentations, rotations)
2. Fine-tune the model on this tiny per-task dataset during inference
3. Generate prediction

Documented result: TTT improved accuracy by 12–18% on ARC tasks vs static inference.

---

Practical Code: ARC Task Loader

import json
from pathlib import Path

def load_arc_tasks(data_dir: str):
    """Load all ARC tasks from the standard directory structure."""
    tasks = {}
    for path in Path(data_dir).glob("*.json"):
        with open(path) as f:
            task = json.load(f)
        tasks[path.stem] = task  # key = task ID
    return tasks

def display_task(task):
    """Print a task for visual inspection."""
    print("=== TRAINING PAIRS ===")
    for i, pair in enumerate(task['train']):
        print(f"\nPair {i+1}:")
        print("Input:")
        for row in pair['input']:
            print(' '.join(str(c) for c in row))
        print("Output:")
        for row in pair['output']:
            print(' '.join(str(c) for c in row))
    print("\n=== TEST INPUT ===")
    for row in task['test'][0]['input']:
        print(' '.join(str(c) for c in row))

def grid_to_tensor(grid):
    """Convert grid to one-hot tensor for neural approaches."""
    import torch
    import numpy as np
    n_colors = 10  # ARC uses colors 0–9
    grid_np = np.array(grid)
    H, W = grid_np.shape
    one_hot = torch.zeros(n_colors, H, W)
    for c in range(n_colors):
        one_hot[c] = torch.tensor(grid_np == c, dtype=torch.float)
    return one_hot

---

DSL Primitive Library (Start Here)

import numpy as np

def to_np(grid): return np.array(grid)
def to_list(arr): return arr.tolist()

# Geometric transforms
def rot90(g): return to_list(np.rot90(to_np(g)))
def rot180(g): return to_list(np.rot90(to_np(g), 2))
def rot270(g): return to_list(np.rot90(to_np(g), 3))
def flip_h(g): return to_list(np.fliplr(to_np(g)))
def flip_v(g): return to_list(np.flipud(to_np(g)))
def transpose(g): return to_list(np.transpose(to_np(g)))

# Color operations
def recolor(g, from_c, to_c):
    a = to_np(g).copy()
    a[a == from_c] = to_c
    return to_list(a)

def swap_colors(g, c1, c2):
    a = to_np(g).copy()
    mask1, mask2 = a == c1, a == c2
    a[mask1] = c2
    a[mask2] = c1
    return to_list(a)

# Object extraction
def get_objects(g, background=0):
    """Find connected components (objects) in the grid."""
    from scipy import ndimage
    a = to_np(g)
    labeled, n = ndimage.label(a != background)
    objects = []
    for i in range(1, n + 1):
        mask = labeled == i
        rows, cols = np.where(mask)
        objects.append({
            'color': int(a[rows[0], cols[0]]),
            'cells': list(zip(rows.tolist(), cols.tolist())),
            'bbox': (rows.min(), cols.min(), rows.max(), cols.max()),
            'size': int(mask.sum())
        })
    return objects

# Grid operations
def crop_to_content(g, background=0):
    """Remove padding rows/columns that are all background."""
    a = to_np(g)
    rows = np.any(a != background, axis=1)
    cols = np.any(a != background, axis=0)
    return to_list(a[rows][:, cols])

def tile(g, reps_h, reps_w):
    """Tile the grid reps_h × reps_w times."""
    return to_list(np.tile(to_np(g), (reps_h, reps_w)))

def pad(g, top=1, bottom=1, left=1, right=1, fill=0):
    return to_list(np.pad(to_np(g), ((top, bottom), (left, right)), constant_values=fill))

---

Scoring and Evaluation

def evaluate(prediction, ground_truth):
    """ARC scoring: exact match only (no partial credit)."""
    return int(prediction == ground_truth)

def batch_evaluate(predictions, ground_truths):
    """Score a batch — returns fraction correct."""
    return sum(evaluate(p, gt) for p, gt in zip(predictions, ground_truths)) / len(predictions)

ARC is binary: you either solve the task or you don't. Partial matches don't count. This makes ensembling different:

Ensembling for ARC: Generate multiple candidate outputs from different approaches and take the most common prediction (plurality vote). If all disagree, submit your best single approach.

---

What Did NOT Work (Save Time Here)

• Pure CNN/vision models without task-specific fine-tuning: ~4% accuracy (no better than random for most tasks)
• Large LLMs with standard prompting (GPT-4, Claude 2): 5–10% (reasoning chain helps; standard prompting doesn't)
• Overfitting to the public validation set: ARC has a private test set with harder tasks
• No test-time compute: Static models fail — the real wins come from test-time search or TTT

---

Why Enter Even If You Don't Win

• Partial progress = conference paper (NeurIPS, ICML, ICLR)
• Global recognition in the AI research community
• Proves genuine AI research capability to employers
• Previous solutions published here: arcprize.org/blog

---

Resources

Resource	URL
Original ARC paper	arxiv.org/abs/1911.01547
ARC Prize website	arcprize.org
2024 winning solution (Ryan Greenblatt)	arcprize.org/blog/oai-o3-pub-breakthrough
MinARC — smallest ARC DSL solver	github.com/michaelhodel/arc-dsl
RE-ARC — data augmentation for ARC	github.com/michaelhodel/re-arc
ARC Dataset	github.com/fchollet/ARC-AGI
Kaggle competition page	kaggle.com/competitions/arc-prize-2025
Top 2024 solutions	kaggle.com/competitions/arc-prize-2024/discussion