A Misc42 Labs dispatch

Volume 06 · Edition 2026 · Linux

One codebase.
Four minds.

A workshop instrument for the developer who already pays for claude, gemini, codex, and aider — and wants them playing in the same orchestra, not four separate tabs.

Read the source See the pipeline

एक कोडबेस,
चार दिमाग।

one codebase · four minds

v0.6.0 · live on Linux

8 phases, 4 voices, one merged commit.

read left → right · one run

Classify

Clarify

Analyse

Plan

Dispatch

Execute

Review

Merge

Verify

claudeOrchestrator · plan · review
geminiResearch · long context
codexTerminal · devops · build
aiderSurgical multi-file edits

0 · classify100 · merged commit ★

The Problem · Editorial

One agent isn't enough. Five tabs aren't serious.

Every coding agent CLI has a strength the others don't. claude is best at high-level architecture and review. gemini reads enormous contexts. codex is sharp on terminal and devops chores. aider does surgical multi-file diffs nobody else matches. Most working days you need two or three of them on the same problem at once.

Most existing wrappers proxy each CLI through a pseudo-terminal layer. It works until it doesn't. A codex update banner, a gemini edit-accept dialog, a claude policy confirmation mid-execution — every one of those interactive surfaces jams the wrapper, the orchestrator stalls, the pipeline aborts. We learned this the hard way across four live runs.

theClub doesn't paper over the pty problem. It removes the pty.

Each agent now spawns directly with native stream-json flags. No terminal means no prompts can render, which means no interactive surface can break the run. The fix is architectural — not a config tweak, not a flag soup, not a vendored wrapper that'll rot the next time a CLI releases a confirmation dialog. The 8-phase pipeline that drives the four agents stays the same; the transport underneath got replaced.

The Pipeline · 8 movements

One goal in, one merged commit out.

Each phase has a strict contract — what comes in, what goes out, how it fails. Cheap-path tasks skip the heavy stages. Complex multi-verb goals fan out across all four agents.

00
Classify
phase 00
A heuristic-first classifier inspects the goal. Confident trivial / complex verdicts skip the model call entirely. Only the genuinely ambiguous middle pays for a tiebreak.
claudesolo
01
Clarify · Analyse
phase 01
claude asks one clarifying question if the goal is underspecified (5-minute timeout, skippable). gemini reads the repo in parallel and returns a structured analysis.
claudegeminiparallel · 2 agents
02
Plan
phase 02
claude turns the goal + analysis into a strict-JSON plan. Per-task agent assignment, file scope, priority — no free-text guesswork.
claudesolo
03
Dispatch
phase 03
Each plan task spawns its assigned agent in its own git worktree. Per-agent stream-json adapters tee NDJSON events back to the orchestrator.
claudegeminicodexaiderparallel · 4 agents
04
Execute
phase 04
Agents work in parallel. File changes, commits, costs — every event is captured. The orchestrator never blocks on a single agent's interactive surface (there are none).
codexaiderparallel · 2 agents
05
Review
phase 05
claude scores each agent's diff against the plan. Approve / reject per task. Rejected work loops back into Execute with feedback — capped at three reflections.
claudesolo
06
Merge
phase 06
Approved branches merge to main. Conflict detection runs ahead of time. A bad merge triggers a bisect — the orchestrator finds the culprit branch and rolls it back, preserving the good work.
claudesolo
07
Verify · Score
phase 07
Build check runs (cargo / tsc / vite). Per-agent quality / speed / token-efficiency scores persist to .theclub/scores.json for adaptive routing on future runs.
codexclaudeparallel · 2 agents

The Interface · 3 plates

The instruments, photographed in repose.

theClub is a desktop app, not a hosted dashboard. The three plates below are real screenshots of the running app on Linux — no mockups, no faked numbers, no “coming soon” sticker.

Plate 01 · home screen · idle
Stage layout
One lead pane on the left, three workers stacked on the right. Each card carries its agent's identity colour and a per-CLI start button — no chrome you don't read.
Plate 02 · ctrl+b · pipeline status
The Blackboard
Ctrl+B opens the conductor's score: every agent, every task, elapsed time, context burn, token spend. Glance once, know exactly where the pipeline is.
Plate 03 · per-agent · live numbers
Per-agent drawer
Click any agent's header to scope the drawer to it. Status, tokens, context-window usage, score — plus reasoning effort and a manual-override toggle that tells the orchestrator to skip this worker on dispatch.

The Cast · Dramatis Personae

Four CLIs. Each plays to type.

theClub doesn't average the four agents into a single mediocre voice. Each one keeps its character — the orchestrator plays each to its strength.

claude
role
The orchestrator
High-level architecture, planning, and review. Drives the pipeline phases. Long-lived child with stdin-streamed turns — saves 3 seconds + a cache reload on every follow-up.
```
stdbuf -oL claude --print \
  --output-format stream-json \
  --input-format stream-json \
  --permission-mode bypassPermissions \
  --bare --session-id <uuid>
```
gemini
role
The reader
Big-context analysis. Sweeps the repo, returns structured maps. Env-scrubs GEMINI_API_KEY / GOOGLE_API_KEY so OAuth wins; a 200 ms spawn stagger dodges the refresh race.
```
gemini -p "<prompt>" \
  --output-format stream-json \
  --yolo --skip-trust \
  --include-directories <wt> \
  --session-id <uuid>
```
codex
role
The hand on the terminal
Devops, build, and config chores. Exec mode hard-codes approval_policy=never in the binary itself — no interactive prompts can render, full stop. Resume via thread-id for multi-turn.
```
codex exec --json \
  --sandbox workspace-write \
  --cd <worktree> \
  --skip-git-repo-check \
  --output-last-message <path>
```
aider
role
The surgeon
Surgical multi-file diffs via SEARCH/REPLACE blocks. No native NDJSON — the adapter parses stdout with a regex set. Scope enforcement guards each Applied-edit; no-op detection via git rev-parse pre/post.
```
aider --message "<task>" \
  --no-stream --no-pretty \
  --yes-always \
  --file <path> [--file ...] \
  --edit-format diff
```

Install · Linux v1

Clone, install, run.

v0.6.0 ships from source. Tauri v2 desktop, Rust backend, React frontend. No installer yet — macOS & Windows arrive when the Linux build hardens.

Step 01

Prerequisites

Rust toolchain (rustup)
Node.js 20 or newer
Tauri v2 system deps: libsoup-3.0-dev, libwebkit2gtk-4.1-dev, libjavascriptcoregtk-4.1-dev
Any combination of: claude, gemini, codex, aider CLIs — the more authenticated, the more agents engage

Step 02

Run

git clone https://github.com/Misc42/theClub
cd theClub
npm install
npm run tauri dev

First boot warms each authenticated agent in the background, so the first goal you submit dispatches without a cold-start wait. No telemetry leaves the machine.

Step 03

Auth keys (BYO)

~/.claude.json
claude code OAuth
~/.codex/auth.json
codex OAuth · or OPENAI_API_KEY
~/.gemini/oauth_creds.json
gemini OAuth · NOT GEMINI_API_KEY env
~/.aider/oauth-keys.env
OPENROUTER_API_KEY for aider

theClub never touches your keys — each CLI talks to its provider directly. Worktree-jail hooks scope each worker so it can only write inside its assigned branch directory.

FAQ · Letters to the editor

Questions people actually ask.

Q·01

Why four agents and not one big model?

Each CLI has a strength the others don't. claude is sharpest on high-level architecture and review, gemini absorbs huge contexts, codex handles terminal and devops chores, aider does surgical multi-file diffs that nobody else matches. theClub plays each to its strength inside one pipeline — analyse with gemini, plan with claude, execute with aider and codex, review back with claude. When the goal is trivial the cheap-path classifier short-circuits all of that to a single agent.

Q·02

Why not just open four terminals?

Because reconciling four parallel diffs by hand is awful. Each agent in theClub edits in its own git worktree (parallel, no stomping). The orchestrator collects diffs, runs one review pass, and merges only what survives — with surgical rollback that bisects bad merges to find the culprit while preserving the good work. Hours of manual reconciliation collapse into seconds.

Q·03

Does this send my code anywhere?

Only to the model providers you've authenticated. theClub itself is a local Tauri desktop app — no analytics, no telemetry, no cloud middleware. Each CLI talks to its own backend (claude / gemini / openai / openrouter) directly with your keys. The orchestrator just shuffles inputs and outputs between worktrees on your machine.

Q·04

What happened to agentapi?

v0.5.x wrapped each CLI through agentapi's pseudo-terminal proxy. Every mid-run prompt — codex update banners, gemini edit-accept gates, claude policy confirmations — could jam the wrapper and abort the pipeline. v0.6.0 removed the pty layer entirely: each adapter spawns its CLI directly with stream-json flags. No terminal means no prompts can render. The fix is in the architecture, not in config tweaks.

Q·05

Linux only?

For now. Tauri v2 builds for macOS and Windows trivially, but the Linux build is what's actually been smoked. macOS and Windows installers come once Linux v1 stabilises — likely v0.7.x.

Q·06

Is it free?

theClub is open source under AGPL-3.0. You pay for whatever models you point it at. There's no theClub subscription, no hosted tier, no Pro version.

Q·07

Why is this a ‘Misc42 Labs developer tool’?

Misc42 Labs is the studio building consumer software for Indian users (Sanketra, Mukut, Tvashtra). theClub is the workshop instrument the studio uses to ship those products. We open-source it because if a workshop instrument is sharp enough to ship our own products, it's sharp enough to share.

One codebase.Four minds.

Stage layout

The Blackboard

Per-agent drawer