Arena skill
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
- 1,104 ★ on the repository
- Last commit
- MIT
Extended access
Why this level
- Spawns up to 100 sub-agents and hundreds of calls, which spends tokens fast
- Sub-agents write files into the project's `.arena/` folder, one approval per file in the default permission mode
Install
- Works in
In your terminal, with SkillFoxx CLI
npx skillfoxx add skills/arenaDetects the agents on your machine, shows the access level and pins the version.
Other ways to install
Access and checks
How we reviewExtended accessThe tool runs code or makes network calls and only reads external data.
- Spawns up to 100 sub-agents and hundreds of calls, which spends tokens fast
- Sub-agents write files into the project's `.arena/` folder, one approval per file in the default permission mode
This is third-party code. Review the repository files before installing.
What it does
Arena runs a tournament of solutions in Claude Code when you are unhappy with an answer. `/arena` takes your last request as the task and the answer you rejected as the one to beat. Each of up to 100 sub-agents gets the same task text word for word and its own strategy card: a way of reasoning, a workflow and an overall approach. The agents then pair off. Each attacks the other's solution, then defends and rewrites its own, and a separate judge scores the match on a written rubric: correctness, completeness, robustness to attacks, specificity and clarity. The loser is out, and 100 becomes 50, then 25, 13, 7, 4, 2 and 1. You get back the surviving solution, the attacks it beat and the round count. If you started from a rejected answer, a last judge compares the winner with it blind and reports the score even when the old answer wins. The skill never touches your files: every sub-agent writes inside `.arena/`.
Who it is for. For Claude Code users who need one strong answer to an important task rather than another attempt at the same approach.
Good fit when
- Claude gave a weak headline, plan or code and asking again returns the same mediocre options
- The task matters and you are willing to spend tokens on a full 100-agent tournament
- You want an everyday option: `--quick` runs 16 competitors
- You want a reproducible setup: the same `--seed` gives the same cards and bracket
- You want to see why a solution is better: the skill shows the attacks it survived and the score against the rejected answer
Not a fit when
- The task is vague: the skill does not fix a bad brief, and 100 agents return 100 flavours of vague
- You need a fast answer: the full 100-agent run makes 595 sub-agent calls in 70 waves
- You are not in Claude Code: the skill spawns sub-agents through the Agent tool
- You want the agent to edit your project directly: the skill returns a solution and applying it is your call
Example request
/arena --quick write the headline for our pricing pageLimitations
Claude Code and Python 3.8 or newer are required, with nothing to pip install. The sub-agents run on the same model as your session, so «100 versions of Claude» means 100 strategy cards, not 100 different models. The judges are Claude too: the rubric sits in the repository for you to read and change. The winner is the strongest solution this tournament found, not proof that it is right.
The full tournament spends a lot of tokens. Claude Code runs at most 10 tool calls at once by default, so sub-agents go in waves of 10; change `--wave` only if you raised the limit. Outside accept-edits mode each file in `.arena/` needs its own approval. Sub-agents cannot see your chat: anything that did not make it into the task file `.arena/<run>/task.md` is unknown to them. The same `--seed` gives the same cards and bracket, not the same answers.
How to disable. Delete `~/.claude/skills/arena` or `.claude/skills/arena` in the project. If you installed it as a plugin, remove it through `/plugin`. Past runs live in the project's `.arena/` folder, which you can delete.
FAQ
How do I install Arena in Claude Code?
Paste the repository link into the chat and ask it to install the skill and confirm `/arena` works, or copy the folder: `git clone` and `cp -r arena-skill/skills/arena ~/.claude/skills/`. The plugin route is `/plugin marketplace add Jakeschincariol/arena-skill` and `/plugin install arena-skill@arena-skill`, but then it is invoked as `/arena-skill:arena`.
How much does an Arena run cost?
The skill is free, the tokens are yours. A full 100-agent tournament makes 595 sub-agent calls in 70 waves, 32 agents make 187 calls, and 16 with `--quick` make 91. The skill prints these numbers before starting, and `python3 skills/arena/bracket.py plan --agents N` shows them any time.
How does Arena pick a winner?
A judge reads both revised solutions, checks every attack itself and scores on the rubric: correctness 30, completeness 25, robustness to attacks 20, specificity 15, clarity 10. `bracket.py` does the arithmetic: the higher total goes through, and a solution with a verified fatal flaw cannot beat one without.
Does Arena change files in my project?
No. Every sub-agent writes inside `.arena/`. Code changes come back as a diff or full files inside the winning answer, and applying them is your call; the skill asks first.
What are the strategy cards?
Each competitor gets a three-part card: a reasoning mode (first principles, inversion, analogy and others, 15 in all), a workflow (12 options) and a strategy (12 options). That makes 2,160 distinct cards, and no two competitors share one.
Discussion
No questions or reviews yet.
Related
Skills31 skills for Claude Code and Codex: cross-vendor review, task handoff on low quota, a morning brief and a nightly retrospective
A skill that turns several Claude Code, Codex and Cursor windows into a team with a coordinator, shared registry and cross-review
Multi-agent orchestration for Claude Code: teams, roles, autopilot and task routing across skills and subagents
A meta-skill for Claude Code that turns a domain description into an agent team and the skills it uses, using six team-architecture patterns
A learning kit for Claude Code: feature walkthroughs plus copy-paste templates for commands, skills, memory, hooks and subagents
A skill that turns a goal into a ready prompt: the agent works in builder and critic loops until its output wins a blind comparison with a reference
Comparison with similar tools
Entries that share the main search query, and how they differ.
| Entry | Official | Repository stars | Main difference |
|---|---|---|---|
| Arena (this entry) | no | 1,104 | |
| Claude-Codex Review Skill | no | 5 | review of a single plan or code by a second agent, with no tournament |
| Agency Orchestrator | no | 2,420 | assembles a team of roles from a YAML workflow for a finished result |
README in short
The project is built on one idea: when Claude keeps giving bad answers, run a tournament instead of asking again. The description walks through the phases: spawn, attack, defend, judge, repeat and result. Cost tables by number of competitors follow, then the `bracket.py` utility that keeps the tournament state in a single JSON file so the main session never loses the thread. A «fine print» section states plainly that these are 100 sub-agents of one model and that winning means surviving matches against a rubric.
README badge
Original SKILL.md
---
name: arena
description: >-
Make 100 versions of Claude fight to the death over one task. Spins up N
sub-agents (default 100, --quick for 16), gives every one the exact same
task plus a different strategy card (reasoning mode, workflow, strategy),
then runs a single-elimination bracket: they attack each other's solutions,
defend and revise, and a judge scores every match on a written rubric until
one solution survives. Use when the user is not satisfied with an answer,
calls it a bad answer, says try again or do better, says "arena", or asks
to make them compete.
argument-hint: "[--agents N | --quick] [--seed S] <task>"
---
# arena
For when Claude keeps giving a bad answer. Instead of asking again and again, this runs a tournament:
N sub-agents get the exact same task, each attacks it with a different reasoning mode, workflow and
strategy, and then they attack each other in a bracket until one solution is left. You are the
orchestrator. You never compete and you never judge.
What the user typed after `/arena`: `$ARGUMENTS`
If that is blank, or still reads like a placeholder, nothing was passed: take the task from the
conversation.
## The tool
Every piece of bookkeeping goes through `bracket.py` in this skill's folder:
```bash
python3 "${CLAUDE_SKILL_DIR}/bracket.py" <command>
```
Below, `ARENA` means exactly that command. If the path looks unexpanded, use the "Base directory for
this skill" that Claude Code printed at the top of this skill. The state lives in
`.arena/<run>/arena.json` in the current directory, and every command after `init` finds it through
`.arena/LATEST`.
## Step 1: size it, and get a yes if nobody asked for it
Read the flags out of the request. Everything that is not a flag is the task.
| flag | meaning |
| --- | --- |
| `--agents N` | N competitors. Default 100. |
| `--quick` | 16 competitors. The everyday setting. |
| `--seed S` | Fixes the cards and the pairings. Default: random, and recorded. |
| `--wave W` | Sub-agents per wave. Default 10. Only raise it if the user raised Claude Code's limit. |