SkillFoxx

arc-skill

A skill that makes the agent write a prediction before every move and cleared all 25 public ARC-AGI-3 games

  • 90 ★ on the repository
  • Last commit
Skill

Extended access

Why this level

  • Runs a Python harness and game sessions and in live mode calls ARC servers with your `ARC_API_KEY`
  • A game lasts thousands of actions and spends many model tokens
All reasons and checks

pbshgthm/arc-skillAuthor:pbshgthm

Install

In your terminal, with SkillFoxx CLI

npx skillfoxx add skills/arc-skill

Detects the agents on your machine, shows the access level and pins the version.

Other ways to install

Access and checks

How we review

Extended accessThe tool runs code or makes network calls and only reads external data.

  • Runs a Python harness and game sessions and in live mode calls ARC servers with your `ARC_API_KEY`
  • A game lasts thousands of actions and spends many model tokens

This is third-party code. Review the repository files before installing.

What it does

The skill teaches an agent to play ARC-AGI-3, a set of 25 video games that never explain their rules, from just a game ID. The core rule: before pressing a button the agent writes down which grid cells will change and how. The `arc` harness refuses a press with no prediction and grades it against the returned frame. A miss dates the moment the agent's model and the game came apart. The agent has five kinds of instruments: viewing the board as an image and as an exact grid, a press with a prediction attached, a plan of steps that halts at the first miss, offline computation over recorded grids (shape, lattice and line detection, motion tracing, pathfinding) and an optional executable game model searched with A*. Long games keep one page of notes: what is verified, what is assumed and what to test next. According to the author, Claude Code on Opus 5 cleared all 25 games in 7,645 actions.

Who it is for. Agent researchers and ARC Prize entrants who want to run an agent through ARC-AGI-3 with a verifiable method.

Good fit when

  • You want to solve an ARC-AGI-3 game with a command like `claude "solve ARC-AGI-3 game lp85"` from a single ID
  • You want to repeat the author's campaign and compare results with the scorecard on the ARC site
  • A long game does not fit in context and you need a one-page memory of verified and assumed facts
  • You want a pattern for making an agent test hypotheses with predictions and stop guessing

Not a fit when

  • You need a general coding agent: the skill is built for one game task
  • You have no `ARC_API_KEY` for live mode and the local simulator is not enough
  • You want solutions to specific games: the skill contains none

Example request

Solve ARC-AGI-3 game lp85 and write a prediction before every press

Limitations

  • The skill is built for ARC-AGI-3 and does not transfer to other tasks without rework.
  • Live mode needs an `ARC_API_KEY`; by default `start` runs on a local simulator with competition semantics.
  • The 25-of-25 result was obtained on Claude Opus 5 unmodified, and numbers on other models may differ, which the author does not report.
  • Games spend many model requests: the agent makes thousands of actions and hundreds of context compactions.

How to disable. Delete the `arc-skill` directory from the agent skills folder and the `ARC_API_KEY` variable from the environment. Run directories are removed like ordinary folders.

FAQ

How do I install arc-skill?

Run `npx skills add pbshgthm/arc-skill`. For live mode set the `ARC_API_KEY` variable, then ask the agent to solve a game by ID.

What is RHAE in the results?

The benchmark's own ARC-AGI-3 metric. The author reports 100.00 and calls it the ceiling of the scale.

Why is a press without a prediction refused?

That is the method's rule: the prediction is checked on the next frame, and a miss shows where the game model is wrong. The refusal costs no action.

Which prediction forms are supported?

Eight forms joined with `;`: a cell colour, a shape shift, a region change, a shape vanishing, level-up or win, change or no change. Each is graded on its own.

Can the author's result be verified?

Yes. The author replayed every recorded press through ARC servers and all 25 games reproduced. The scorecard is on the ARC Prize site and the write-up with board-by-board replays is on the project page.

Discussion

No questions or reviews yet.

Skills

A Claude Code skill: when you dislike an answer, it runs up to 100 sub-agents through attack-and-defend rounds and returns the one solution left standing

SkillExtended access1.5K

A collection of 14 portable skills for long agent runs: work planning, live app QA, search across past sessions and a phone call

PluginExtended access136

Anthropic skill for Claude Code that audits a multi-agent system and, by measurement, folds subagents into one loop with skills.

SkillExtended access546

A skill for creating skills that proves them by behavior: before-and-after runs, regression evals and ecosystem audit

SkillExtended access918

A catalog of nearly two hundred skills: code delivery, review, debugging, AI governance, product work and agent coordination.

SkillMinimal access175

A skill registry with a CLI and API: the agent describes a task and gets a recommendation with a trust score and install command

CLIExtended access371

README in short

The README presents the skill as a method for playing ARC-AGI-3 on one rule: prediction first, action second. It gives a campaign results table, eight prediction forms, five instrument groups and the notes page for long games. The main write-up sits on the project site.

README badge

Original SKILL.md

---
name: arc-skill
description: Solve an interactive hidden-rule ARC-AGI-3 game from its game ID. Contains the complete playing doctrine (predict before every action, graded claims, one-page notes, optional executable-rules search) plus the `arc` harness the agent drives. Use whenever asked to solve, play, or continue an ARC-AGI-3 game.
---

# Arc skill

Set the launcher once, work inside one directory per game, then start or resume:

```bash
ARC="<this-skill-directory>/scripts/arc"   # absolute path
mkdir -p <run-dir> && cd <run-dir>         # one directory = one run
"$ARC" start <GAME_ID>
```

`start` defaults to a local simulator with competition semantics: one logical
run, append-only history, paid resets, completed levels never lost. It is
crash-safe — after any interruption, rerun `"$ARC" start <GAME_ID>` and the run
is resumed or replayed exactly. Use `--mode competition` (live remote server,
~15-minute idle lease, no replay recovery) only when the user explicitly asks.
Never create a second run for the same game, never inspect the game's source or
private state, and never edit `.arc/` by hand except `NOTES.md`.

## The game

A 64×64 board of 16 colors, hidden rules, several levels. Interface priors
(not guarantees): ACTION1/2/3/4 = up/down/left/right, ACTION5 = interact,
ACTION6:x,y = click at x=column y=row, ACTION7 = undo. Availability can change
after every action.

**Finish first.** Historically every lost point came from unfinished games, not
from extra actions. Early levels are usually cheap tutorials: a wrong action
that teaches a mechanic beats a minute of deliberation. Act early, act often,
learn from every grade. Efficiency only matters once finishing is likely.

## The loop — look, predict, act, compare, note

1. **Look**: open the printed `IMAGE`; read the worded `TRANSITION` story.
2. **Predict + act**: every action requires `--predict`; the harness grades it:

```bash
"$ARC" act ACTION1 --predict "move 12,5 0,-1"
"$ARC" act ACTION6 3 14 --predict "cell 3,14=9; region 0:8,10:20" --because "test button"
```

Report a problem