# arena-skill turns one Claude answer into a 100 agent tournament > arena-skill is a free MIT Claude Code skill that runs many sub-agents on a single task, brackets them, and lets a judge pick the survivor without touching your files. It costs 595 sub-agent calls by default, so the interesting part is where the design earns that spend and where it does not. **Jakeschincariol/arena-skill** — When Claude keeps giving you bad answers, make 100 versions of it fight to the death. Same task, 100 different strategies, a bracket, one answer left. Free Claude Code skill. - Repository: https://github.com/Jakeschincariol/arena-skill - Stars: 913 · Forks: 143 - Language: Python - License: MIT - Published: 2026-10-20 · Updated: 2026-10-20 · Language: en - Canonical page: https://hysenlabs.com/projects/jakeschincariol-arena-skill ## A retry loop replaced by a bracket Ask a model the same question three times and you get three answers of similar quality. The usual fix is to keep asking until something sticks, which is expensive and stops as soon as you like the wording rather than the reasoning. arena-skill takes a different route: it treats a disappointing answer as something to be attacked. You hand the skill one task, it runs that task through a field of competitors that each take a different route to it, and the answers are eliminated by a judge until one remains. What comes back is not a list of options to compare yourself. It is a single survivor plus the record of the attacks it had to answer on the way up. The intended user is an engineer working inside Claude Code who already has a task written down and is not satisfied with the answer Claude produced. The skill exists for the moment right after the first attempt, when rephrasing the prompt feels pointless. A second fit is a task where several plausible answers exist and you want a second opinion with structure rather than one more sample. Claude can also reach for the skill on its own when you say something like that the answer is bad and should be made to compete, and it asks before it spends anything when it starts that way. ## Two thousand one hundred sixty different ways to attack one task The variety comes from a strategy card. Every competitor receives the same task text, byte for byte, and one card that fixes how it should reason, which workflow it should follow and which overall strategy it should take. The card catalogue is listed as fifteen reasoning modes (first principles, inversion, analogy, adversarial, constraint first, worked example, Socratic, contrarian, systems thinking and more), twelve workflows (draft, critique and rewrite, outline first, test first, research then synthesise, three drafts and pick one) and twelve strategies (simplest thing that works, maximal rigour, user empathy first, edge cases first, speed). That multiplies out to 2,160 cards, and the dealer hands each agent its own with no repeats. The pairing step refuses to place two agents with the same reasoning mode against each other, so the matchups differ too. In a 100 agent field this matters less than the raw count of distinct approaches, but in a 16 agent run it is the main thing stopping two rounds from being the same argument twice. A card is not a quality signal either, since all cards are handed out. A competitor holding the first principles card has no inherent advantage over one holding speed. Cards shape the approach, and the rubric decides who survives. ## Attack, defend, and a judge that never sees the cards Each match has three phases. In the attack phase both sides criticise the other solution through their own card, listing what is wrong, what requirement was missed and the exact input that breaks it, with up to seven attacks tagged FATAL, MAJOR or MINOR. In the defend phase each side answers every attack it received, conceding or rebutting with evidence, then rewrites its solution to fix what it conceded. In the judge phase a separate sub-agent reads both revised solutions, checks every attack itself and scores both against a rubric kept in skills/arena/rubric.md. The weights are correctness 30, completeness against the task 25, resistance to the attacks raised 20, specificity 15 and clarity 10, and the judge is not shown the cards. bracket.py does the arithmetic on those scores. The higher total advances, and a solution carrying a verified fatal flaw cannot beat one without it. A round can therefore end level on points and still produce an elimination, because the flaw overrides the total. Odd numbers are handled the same pragmatic way: when survivors are odd, one competitor gets a bye, and the bye never goes to the same agent twice while any other agent is still waiting for one. The whole procedure is mechanical enough to be checked by a script, which is why it lives in code rather than in the conversation. ## One JSON file holds the entire tournament The state of a run is a single JSON file managed by bracket.py, and the main Claude session does nothing but drive the loop. Each sub-agent writes its own work to disk and replies with one line, so the main context holds receipts and bookkeeping rather than the hundreds of solution files themselves. The stated payoff is that a long run survives context compaction: if the conversation gets compacted halfway through, bracket.py next reads the file and continues from where the tournament actually stands. The plan output shows the shape of a run before it starts. This is what python3 skills/arena/bracket.py plan prints for 100 agents. ```bash round alive matches bye sub-agent calls waves spawn 100 - - 100 10 1 100 50 - 250 25 2 50 25 - 125 13 3 25 12 yes 60 8 4 13 6 yes 30 5 5 7 3 yes 15 3 6 4 2 - 10 3 7 2 1 - 5 3 total 595 70 alive per round: 100 -> 50 -> 25 -> 13 -> 7 -> 4 -> 2 -> 1 ``` The totals row is the number that matters: 595 sub-agent calls and 70 waves for the default field. Waves are groups of ten concurrent calls, so the wave count is the practical constraint on how long a tournament takes. ## Installing the skill three ways Installation is a copy or a marketplace line. The documented quick path is to paste a URL into Claude with the install instruction, so: ```bash https://github.com/Jakeschincariol/arena-skill Install this skill, then confirm /arena works. ``` To do it by hand in Claude Code, clone the repository and copy the skill folder into your skills directory: ```bash git clone https://github.com/Jakeschincariol/arena-skill.git cp -r arena-skill/skills/arena ~/.claude/skills/ ``` A third route installs it as a plugin: ```bash /plugin marketplace add Jakeschincariol/arena-skill /plugin install arena-skill@arena-skill ``` Claude Code namespaces plugin skills, so the plugin route gives you /arena-skill:arena. If you want the plain /arena command, copy the folder instead, and if you want the skill for one repository only, put the same folder in that repository's .claude/skills/ directory. The first use is a slash command carrying a task: ```bash /arena /arena --quick write the headline for our pricing page /arena --agents 32 fix the flaky test in tests/test_api.py /arena --seed 7 plan my launch week, I have 6 hours a day ``` Bare /arena takes your last request as the task and the answer you disliked as the thing to beat. The flags are --agents N for the competitor count, 100 by default, --quick for 16 competitors, --seed S to repeat the same seed, cards and bracket, and --wave W for sub-agents per wave, 10 by default. The prerequisites are Claude Code, because the skill spawns sub-agents with the Agent tool, and Python 3.8 or newer. Nothing needs to be installed with pip. ## What a full run costs in sub-agent calls The skill is free, but the tokens are yours, and the default field is large. The cost table lists 100 agents as 7 rounds and 595 sub-agent calls spread over 70 waves of ten. Sixty-four agents needs 379 calls and 49 waves, 32 agents needs 187 calls and 28 waves, 16 agents, which is the --quick setting, needs 91 calls and 16 waves, and 8 agents needs 43 calls and 10 waves. Add one call when there is a rejected answer to beat, since a final judge then compares the winner with it blind and reports the score even when the old answer wins. Every call reads the task and one or two solutions, so the bill moves with the size of the task and not only with the agent count. That is also why the wave column matters: --wave defaults to 10 and the guidance is to raise it only if you raised the limit in Claude Code. The skill prints these numbers before it starts, and you can produce the same numbers at any time with the plan command, which writes nothing. ```bash python3 bracket.py plan --agents 100 # rounds, calls, waves. Writes nothing ``` Run it before a tournament rather than after, so a default of 100 on a long task is visible while it can still be changed. ## Where the tournament approach stops making sense Several limits are visible in the design. The first is the shape of the cost. Even 16 agents need 91 calls, and each of those carries the task text, so on a long document the spend is driven by task size more than by the number of competitors. A task Claude can answer in one short reply is a poor candidate for a bracket. The second is that scoring is prose written by a model. The rubric weights are fixed, but whether a defect is FATAL or MINOR is a judgement call, and the judge only checks the attacks it decides to check. Nothing in the design executes code, so for a programming task the tournament argues about correctness without running anything. The third is scope. Every sub-agent writes inside .arena/ and the winner comes back to you, but applying it is left to you, since there is no patch step that lands the result in your files. The repository also has no GitHub releases, so there is no changelog to read when a new version arrives, and the top level layout is small: .claude-plugin/, .gitignore, LICENSE, README.md, skills/ and tests/. ## A single push, no release history The repository is not archived and the last push was on 2026-09-27. There are no GitHub releases, so versions are not published as artefacts and there is no stated upgrade path beyond pulling the repository and copying the skill folder again. The licence is MIT, which is permissive and carries no restriction on internal or commercial use of the code, while still requiring that the copyright notice and licence text travel with copies of the software. The skill needs no signup and no API key and connects to nothing beyond Claude Code itself, and it pulls in no extra Python packages. One structural risk sits underneath all of this. The judge scores each round, so if the judge misreads a line of the rubric the whole field converges on the wrong survivor, and the losing side is eliminated for the wrong reason. Keep the recorded seed, read the surviving attacks, and treat the output as a strong draft rather than a verified answer. ## Conclusion Adopt arena-skill when you already have a written task and a Claude answer you dislike, and start with /arena --quick to price a run before moving to the full 100 agents. Skip it for tasks Claude already handles in one short reply, for work where the code has to actually run, and whenever 91 sub-agent calls on a long document costs more than the answer is worth. Before trusting a survivor, check the rubric weights in skills/arena/rubric.md against your own priorities, match the wave setting to your Claude Code limit, and read what the sub-agents wrote in .arena/ before you copy anything out of it. ## FAQ ### What does arena-skill need before /arena will run? It needs Claude Code, because the skill spawns sub-agents with the Agent tool, and Python 3.8 or newer. There is nothing to pip install, no signup and no API key is needed. ### How many sub-agent calls does a full arena-skill run make? A 100 agent run makes 595 sub-agent calls over 7 rounds and 70 waves of 10. The --quick setting with 16 agents makes 91 calls, and 8 agents makes 43. ### Does arena-skill change files in my project? Every sub-agent writes inside .arena/, and the winning answer is returned to you rather than applied to your code. Adopting the result is left to you. ### Can I reproduce the same arena-skill tournament twice? Yes. Pass --seed S and you get the same seed, the same strategy cards and the same bracket. Without the flag the seed is random, and it gets recorded. ## Sources - [Issues](https://github.com/Jakeschincariol/arena-skill/issues) - [Jakeschincariol/arena-skill on GitHub](https://github.com/Jakeschincariol/arena-skill) - [License: MIT](https://github.com/Jakeschincariol/arena-skill/blob/main/LICENSE) - [README](https://github.com/Jakeschincariol/arena-skill/blob/main/README.md) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/jakeschincariol-arena-skill