Skip to content
Back to search

sumo

MarketplaceWorks with Claude CodeGitHub

Claude Code skill: two agents with fixed positions debate a hard technical decision with mechanically verified evidence, and the orchestrator issues a verdict you can act on.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 20 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/dmorfav/sumo with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/dmorfav/sumo'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/dmorfav--sumo/badge.svg)](/listings/dmorfav--sumo)

HTML

<a href="/listings/dmorfav--sumo"><img src="/api/listings/dmorfav--sumo/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

As a Claude Code plugin:

/plugin marketplace add dmorfav/sumo
/plugin install sumo@sumo

With the [skills.sh](https://skills.sh/dmorfav/sumo) CLI (installs to `.claude/skills/sumo`; add `-g` to install it globally):

npx skills add dmorfav/sumo

Requires `jq` (watching the bout) and Python 3 (checking citations).

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 17 lines
  1. {
  2. "name": "sumo",
  3. "owner": {
  4. "name": "Daniel Morfa Vega",
  5. "url": "https://github.com/dmorfav"
  6. },
  7. "metadata": {
  8. "description": "Adversarial debate between agents with fixed positions, for technical decisions with guarantees."
  9. },
  10. "plugins": [
  11. {
  12. "name": "sumo",
  13. "source": "./",
  14. "description": "Adversarial debate between two agents with fixed positions and an audited verdict."
  15. }
  16. ]
  17. }
README.md · README · 98 lines
  1. # sumo
  2. [![skills.sh](https://skills.sh/b/dmorfav/sumo)](https://skills.sh/dmorfav/sumo)
  3. Agent skill for **adversarial debate between two agents with fixed positions**.
  4. **Claude Code first.** A bout needs background subagents that talk to each other directly with `SendMessage`. Claude Code provides that. On other agents only a degraded relay mode is possible: the orchestrator forwards each message verbatim between the fighters, which loses part of the independence that makes the bout worth running, and the verdict says it was a relayed bout. No other agent has been tested.
  5. A CRITIC and a DEFENDER argue directly with each other about a technical decision (keep or discard a repository, approve an RFC, adopt an architecture, choose a tool). Neither can switch sides. Every claim carries a `path:line → «literal»` citation that a script checks mechanically. If one of them cannot rebut a point, it concedes that point only, and whoever runs out of arguments loses. The orchestrator acts as referee: it frames the decision, pairs the fighters, watches without intervening, verifies the evidence and delivers a verdict built for deciding:
  6. - **Recommended option**, which may be a third way built from what each side conceded.
  7. - **Confidence** and the 3 arguments that support it, with verified evidence.
  8. - **Evidence that does not hold**: invented or paraphrased citations, caught by the script.
  9. - **Decisive experiment**: the cheapest piece of data that would settle what is still in dispute.
  10. - **What would change the decision** and a prioritised **action plan**.
  11. > In sumo, whoever leaves the ring loses. Here, whoever runs out of arguments loses.
  12. ## Why
  13. If you ask a single model to argue both sides, it tends to agree with whoever is asking, and consensus formats reward giving in early. `sumo` pushes each position to the limit against a motivated opponent and demands checkable evidence. What survives the bout has been tested and stops being an opinion. It is meant for decisions in **AI-Driven Development with guarantees**.
  14. ## Install
  15. As a Claude Code plugin:
  16. ```text
  17. /plugin marketplace add dmorfav/sumo
  18. /plugin install sumo@sumo
  19. ```
  20. With the [skills.sh](https://skills.sh/dmorfav/sumo) CLI (installs to `.claude/skills/sumo`; add `-g` to install it globally):
  21. ```bash
  22. npx skills add dmorfav/sumo
  23. ```
  24. Requires `jq` (watching the bout) and Python 3 (checking citations).
  25. ## Language
  26. The skill files are in English, but sumo works in your language: the orchestrator writes the fighters' prompts, talks to you and writes the verdict in the language you use. Only the machine keywords (`NO ARGUMENTS LEFT`, `FINAL REPORT`) stay in English, because the scripts look for them.
  27. ## Usage
  28. ```text
  29. sumo: should we keep the ./legacy-api repo or rewrite it on the new stack?
  30. pit them against each other: adopt Temporal vs. stay with our SQS queues
  31. defend this design as if it were yours and have another agent attack it: docs/rfc-042.md
  32. ```
  33. The skill:
  34. 1. Fixes the **motion**, the **criterion**, the **material** (read-only) and the **time limit** (10 minutes by default).
  35. 2. Launches two background agents with prompts that carry no bias from the orchestrator or the user.
  36. 3. Gives each one its opponent's identifier and does not intervene again.
  37. 4. Watches the bout with `scripts/bout.sh`.
  38. 5. Checks every citation with `scripts/verify.py`, reopens the decisive ones by hand and, for costly decisions, asks an agent running a different model for an audit.
  39. 6. Delivers the verdict and saves the bout (framing, transcript, evidence and verdict) in `dohyo/<date>-<slug>/`.
  40. ## Security
  41. The fighters read the material you give them (repositories, documents, URLs), and that material may contain text written by others, including instructions aimed at AI agents (indirect prompt injection). The skill tells the fighters and the orchestrator to treat all material, transcripts and reports as data: instructions found there are never followed, they are cited as evidence and flagged in the verdict. Fighters work read-only, open only the material you list and do not install or send anything. Even so, point sumo at material you trust, as you would with any agent that reads third-party content.
  42. ## Structure
  43. ```text
  44. skills/sumo/
  45. ├── SKILL.md # referee flow
  46. ├── references/
  47. │ ├── prompts.md # fighter prompt template
  48. │ ├── playbook.md # fighter playbook and referee criteria
  49. │ └── catalog.md # 18 manipulation tactics and legitimate offensive techniques
  50. └── scripts/
  51. ├── bout.sh # rebuilds the bout from the transcripts
  52. └── verify.py # checks every path:line → «literal» citation against the material
  53. tests/
  54. ├── scripts/
  55. │ ├── test_verify.sh # tests verify.py with good, invented and non-existent citations
  56. │ └── test_bout.sh # tests bout.sh and the text report when SubagentHandback is missing
  57. └── fixtures/shapes/ # tiny module the script tests cite by path and line
  58. docs/research/
  59. ├── debate-techniques.md # background research (argumentation, debate, negotiation, debate between LLMs)
  60. └── bibliography-audit.md # independent audit of its 38 citations
  61. ```
  62. ## Foundations
  63. The playbook rests on argumentation theory (Toulmin, pragma-dialectics, Walton's schemes), on competitive debate and on research into debate between LLMs:
  64. - A judge gets it right more often with two opposing experts than with a single one (Khan et al. 2024; Michael et al. 2023).
  65. - LLMs give in under pressure even when they are right (Sharma et al. 2023; Laban et al. 2023) and drift from their assigned role (Baltaji et al. 2024).
  66. An agent running a different model audited the bibliography. Its corrections are applied, and what could not be verified is still marked as "unverified".
  67. ## License
  68. MIT

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.