WARC

WARC

A 35M-parameter world model for ARC-AGI-3 games that predicts the next game frame from the last three frames and an action, and keeps training itself while an agent plays.

Made by third-intelligence on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: WARC is a world model for ARC-AGI-3, built as a 35M-parameter vision transformer that takes actions into account. Given the last three game frames and the next action, it predicts the following frame cell by cell.

It also learns during play. After each new step it sees, it trains briefly on recent steps and adjusts all of its weights. Its pretraining uses recordings of people playing different games. The author reports that on a game it has not seen, it gets four in five mechanics right at 80% or better on the cells those mechanics change.

Who it suits: AI researchers and agent builders who work on ARC-AGI-3 style games and want a model that predicts what an action will do. It is a research artifact, not a general tool.

Industry | Who uses it | How they use it | Example
Research | ARC-AGI researchers | Study test-time training of a world model | Check accuracy on games held out from pretraining
Game AI | Agent developers | Predict the next frame inside an agent loop | Preview what a click will change before taking it
Education | Students of reinforcement learning | Learn how a learned world model works | Run the next-frame example on one checkpoint

People looking for a text, image or chat model can skip it, since WARC only predicts game frames.

Where to use it:

• Python 3.12 with PyTorch, in a virtual environment
• A machine with a CUDA GPU, since the card's example runs on the cuda device
• The project's GitHub repository, which holds the code, the agent and a Kaggle notebook
• Windows, macOS or Linux with Python, for downloading the weights

Use case | Who | What they get back
Predict the next frame | Researchers | A colour for each of the 64 by 64 cells of the next frame
Adapt to a new game while playing | Agent developers | Predictions that improve as the game goes on
Compare checkpoints | Researchers | Validation accuracy for four trained checkpoints

How to set it up: Get the code from the project's GitHub repository first, then install and download the weights.

• Python 3.12 and git
• A CUDA GPU
• torch 2.7.0 and torchvision 0.22.0 built for CUDA 12.6, as the card pins them
• The code from the GitHub repository third-intelligence/WARC

1. Clone the GitHub repository and move into its folder.
2. Create a virtual environment and activate it.
3. Install torch and torchvision, then the requirements file.
4. Download the four checkpoints into a models folder.

cd WARC
python3.12 -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
hf download third-intelligence/WARC --local-dir models    # the four checkpoints (pip install huggingface_hub)

If you only want the weights, Hugging Face gives these two commands.

pip install -U huggingface_hub
hf download third-intelligence/WARC

How to use it: You load a checkpoint and pass it the last three frames, which are 64 by 64 grids of 16 colours, plus the action. Actions 1 to 5 are the keys ACTION1 to ACTION5, and 6 is a click at a column and row. The output is a score for each of the 16 colours in every cell.

import sys
import torch

sys.path[:0] = ["agent", "agent/VARC"]
from warc_model.model import build_from_checkpoint

device = torch.device("cuda")
model, meta = build_from_checkpoint("models/all25/checkpoint_best.pt", device=device)

# The last three frames, (1, 3, 64, 64) colours 0-15. Actions: 1-5 are the keys ACTION1-ACTION5,
# 6 is a click at column x and row y; x and y are -1 for a key.
frames = torch.randint(0, 16, (1, 3, 64, 64), device=device)     # replace with frames of a game
action, x, y = (torch.tensor(v, device=device) for v in ([6], [10], [20]))
hist_action, hist_x, hist_y = (torch.tensor(v, device=device) for v in ([[1, 2]], [[-1, -1]], [[-1, -1]]))

with torch.no_grad():
    logits = model(frames[:, -1], torch.zeros(1, dtype=torch.long, device=device), action, x, y,
                   hist_obs=frames, hist_action_ids=hist_action, hist_action_xs=hist_x,
                   hist_action_ys=hist_y)["ffp_logits"]          # (1, 16, 64, 64)
next_frame = logits.argmax(1)[0]                                 # (64, 64) predicted colours

For the live-training loop inside a game, the agent and the training commands, the card sends you to the project's README and reproducibility notes.

The repository holds four checkpoints. Three of them, fold1 to fold3, are each pretrained on 16 or 17 games with the rest held out for testing. The fourth, all25, is pretrained on all 25 games and keeps one recording per game for validation.

Example: You load the all25 checkpoint and give it three frames of a game plus a click at column 10 and row 20. It returns a score for each colour in each cell, and the highest score per cell gives the predicted next frame.

For newcomers and experts: Think of WARC as a model that guesses what the game screen will look like after you press a key or click. A good first try is to run the short script above on one checkpoint, using random frames as placeholders.

Underneath, it uses 2x2 patches and 10 transformer blocks of width 512, conditioned on the action through adaptive layer normalization. While a game runs, each new observation triggers 20 gradient steps over thirty transitions, ten of them the newest. The trade-off is that updating all weights each step costs compute.

Give the last three frames and an action
The transformer scores each cell's colour
Take the highest score as the next frame
Train briefly on the new step

Good to know: The card lists validation exact-frame accuracy for each checkpoint, measured on games or recordings held out from training.

Title: Validation exact-frame accuracy
fold1: 85.7%
fold2: 79.2%
fold3: 78.5%
all25: 80.0%

• Training data: 340 recordings of people playing the 25 public ARC-AGI-3 games, which the ARC Prize Foundation published
• Size: each checkpoint is 146 MB and holds the weights, the configuration and the game split
• License: CC0 1.0 for the weights and code, and third-party parts keep their own licences
• Cost to run: no API key or paid service is named, but you need a CUDA GPU
• Data it reaches: the game frames you pass in, plus the code and weights you download
• Not for: general text or image tasks, since it only predicts frames of ARC-AGI-3 style games

On Hugging Face, 13 November 2026

• Downloads in the last 30 days: 0
• Likes: 2
• License: cc0-1.0
• Tags: world-model, arc-agi-3, test-time-training, next-frame-prediction, vision-transformer, pytorch

Links

• Model: https://huggingface.co/third-intelligence/WARC
• Files: https://huggingface.co/third-intelligence/WARC/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download third-intelligence/WARC

Then follow the usage in its model card. Nothing in this kit runs by itself.