claudes-ai-buddies

Any AI can join. They compete. They collaborate. They can just talk.

Quick Start

# 1. Install the engines you want (one or more)
npm install -g @openai/codex        # OpenAI Codex
npm install -g @google/gemini-cli   # Google Gemini
brew install opencode               # OpenCode (MiniMax, Anthropic, Google, etc.)

# 2. Authenticate
codex auth login                    # uses your OpenAI account
gemini auth login                   # uses your Google account
opencode providers login            # optional — pick a provider (works without for free model)

# 3. Add the marketplace & install
claude plugin marketplace add cukas/claudes-ai-buddies
claude plugin install claudes-ai-buddies@cukas

# Done — start a new Claude Code session

Works with any combination of Codex, Gemini, OpenCode, or any custom AI CLI you register.

All Skills

Campfire — Open Multi-AI Conversation

/campfire "What's the best way to handle auth in microservices?"

All buddies respond to a topic together. No competition, no ranking — just thinking together. Each buddy speaks in their own voice:

🔵 Codex:
> The service mesh approach with mTLS is cleanest...

🟣 Gemini:
> I'd push back on that — JWT with short-lived tokens scales better...

🟢 OpenCode:
> What if you combine both? mTLS between services, JWT for user-facing...

🟠 Claude:
> Three different angles, and OpenCode's hybrid is interesting...

Aliases: /think, /talk

Brainstorm — Confidence Bid

/brainstorm "Fix the race condition in the WebSocket reconnection handler"

Each buddy assesses the task, rates their confidence, and proposes an approach. Claude calibrates the scores and recommends who should take it.

• Disagreements are the signal — if AIs disagree, that's where the insight is
• Claude calibrates — adjusts inflated/deflated scores based on approach quality
• Context-aware — Claude passes relevant conversation context when it helps

Forge — Competitive Build

/forge "Add input validation to math utils" --fitness "npm test"

Buddies independently implement the same task in isolated git worktrees. A staged pipeline scores them objectively — the best code wins.

• Staged pipeline — starter runs first; challengers only if needed; synthesis on close calls
• Composite scoring — diff size, lint, style, test pass, duration = 0-100 score
• ELO tracking — persistent ratings per task class
• Speculative tests — omit --fitness and engines propose test suites
• --async — run in background, continue your conversation

1. Context — detects languages, conventions, and candidate files
2. Stage 1: Starter — one engine runs first. Auto-accepted if score >= 88 with clean lint
3. Stage 2: Challengers — remaining engines run in parallel if the starter didn't clear the bar
4. Stage 3: Synthesis — on close calls (spread < 8 pts), losers critique, winner refines
5. Scoreboard — composite scores (diff 30%, lint 15%, style 15%, files 10%, duration 5%, tests 25%)
6. ELO — winner gains rating vs each loser, per auto-detected task class
7. Converge — you approve the winning diff before it touches your working tree

Tribunal — Evidence-Based Debate

/tribunal "Should we refactor the auth middleware to use async/await?"

Two buddies debate with evidence citations (file:line). Claude judges on evidence quality, not consensus.

Direct Chat & Code Reviews

Talk directly to any buddy. With conversational mode enabled, they remember across calls:

/codex "What's the best way to implement a rate limiter in Go?"
/gemini "Debug this: TypeError: Cannot read property 'map' of undefined"
/opencode "Review this architecture for scaling issues"

Code reviews with native review protocols:

/codex-review                                  # review uncommitted changes
/gemini-review branch:main "focus on security" # review branch diff with focus
/opencode-review commit:abc1234                # review specific commit

Companion Scripts (v4)

Each buddy has a companion script that connects via the engine's native protocol for richer integration:

All companions fall back gracefully to the legacy CLI if the protocol isn't available.

Configuration

Optional — works out of the box. Config at ~/.claudes-ai-buddies/config.json:

Dynamic Buddy Registry

Any CLI-based AI tool can become a buddy:

/add-buddy --id aider --binary aider --display "Aider" --modes exec

Registered buddies automatically participate in /forge, /brainstorm, /tribunal, and /campfire.

How It Works

┌──────────┐     ┌──────────────┐     ┌─────────────┐     ┌──────────────┐
│   User   │────>│  Claude Code  │────>│  Registry    │────>│  Any AI CLI   │
│          │     │  (orchestrator│     │  (buddy JSON │     │  (codex, gem  │
│          │<────│   + judge)    │<────│   + companion│<────│   aider, ...) │
└──────────┘     └──────────────┘     └─────────────┘     └──────────────┘

• Companion scripts — native protocol integration (JSONRPC, JSON output, session resume)
• No MCP servers — direct CLI subprocess calls with graceful fallback
• No API keys in transit — each engine uses its own auth
• No timeouts by default — buddies respond when ready, user can interrupt
• Context injection — Claude passes conversation context when it helps
• Conversational mode — buddies remember across calls via session/thread resume

Testing

bash tests/run-tests.sh

=== Results: 270/270 passed, 0 failed ===

Part of the cukas Plugin Ecosystem

All available via the claude-plugins monorepo.

MIT License