Your machine right now:
  claude    → deep reasoning, architecture
  codex     → fast code generation, review
  gemini    → broad analysis, large context
  aider     → lightweight edits, git-native
  opencode  → open-source, customizable
  ollama    → local, private, free

{
  "connector": "2.0",
  "name": "full-team",

  "models": {
    "architect": "claude",
    "coder": "codex",
    "researcher": "gemini",
    "reviewer": "opencode",
    "documenter": "aider",
    "data-analyst": "ollama/llama3"
  },

  "pipeline": {
    "phases": [
      {
        "name": "research",
        "parallel": true,
        "workers": [
          { "model": "researcher", "prompt": "Survey the codebase. Map all auth-related files." },
          { "model": "data-analyst", "prompt": "Analyze production logs for auth failures. Local data only." }
        ]
      },
      {
        "name": "design",
        "model": "architect",
        "prompt": "Read research from scratchpad. Design the auth refactor."
      },
      {
        "name": "implement",
        "model": "coder",
        "prompt": "Read the design. Implement it. Fast."
      },
      {
        "name": "review",
        "parallel": true,
        "workers": [
          { "model": "reviewer", "prompt": "Independent code review. Be harsh." },
          { "model": "architect", "prompt": "Architecture review. Does this match the design?" }
        ]
      },
      {
        "name": "document",
        "model": "documenter",
        "prompt": "Read the diff. Update docs and changelog."
      }
    ],
    "scratchpad": true
  }
}

Gemini researches (broad context, fast search)
  + Ollama analyzes local data (private, no API cost)
    ↓
Claude designs (deep reasoning)
    ↓
Codex implements (fast code generation)
    ↓
OpenCode reviews (independent, harsh)
  + Claude checks architecture alignment
    ↓
Aider documents (lightweight, git-native)

1 agent:     Claude does research + design + code + review + docs
             = one perspective. Blind spots everywhere.

6 agents:    Each AI does what it's best at.
             Gemini researches (breadth).
             Claude designs (depth).
             Codex implements (speed).
             OpenCode reviews (independence).
             = six perspectives. Blind spots caught.

{ "workers": 6 }

Research:        Gemini (1M context, broad search)     $
Design:          Claude Opus (deep reasoning)          $$$
Implementation:  Codex (fast, code-optimized)          $$
Review:          OpenCode (independent, no vendor bias) $
Documentation:   Aider (lightweight, git-native)       $
Data analysis:   Ollama (local, free, private)         $0

Total: $$$ instead of $$$$$$$$$

{
  "models": {
    "expensive": "opus",
    "fast": "codex",
    "cheap": "haiku",
    "free": "ollama/llama3"
  }
}

Your laptop:
  Claude (coordination) + Aider (docs)
  → fast network, your dev environment

GPU server:
  Ollama/llama-70b (heavy inference)
  → 4x A100, can't run on laptop

CI server:
  Codex (implementation) + OpenCode (review)
  → build tools, test infrastructure

Data server:
  Ollama/llama3 (data analysis)
  → production database, data can't leave

{
  "machines": {
    "laptop": "MY-LAPTOP.local",
    "gpu": "GPU-SERVER.local",
    "ci": "CI-SERVER.local",
    "data": "DATA-SERVER.local"
  },
  "pipeline": {
    "phases": [
      { "machine": "data",   "model": "ollama/llama3",  "prompt": "Analyze production data." },
      { "machine": "laptop", "model": "claude",         "prompt": "Design the fix." },
      { "machine": "gpu",    "model": "ollama/llama-70b","prompt": "Heavy code generation." },
      { "machine": "ci",     "model": "codex",          "prompt": "Run full test suite." }
    ]
  }
}

Currently tested:
  ✅ Claude Code (claude)
  ✅ Codex CLI (codex)
  ✅ Gemini CLI (gemini)
  ✅ Aider (aider)
  ✅ OpenCode (opencode)
  ✅ Ollama (ollama run llama3)

Works by design (any terminal CLI):
  ✅ Amp
  ✅ Cline
  ✅ Goose
  ✅ Continue
  ✅ Roo Code
  ✅ Any future AI CLI

niia write --session S1 $'claude\r'     → Claude is a worker
niia write --session S2 $'codex\r'      → Codex is a worker
niia write --session S3 $'gemini\r'     → Gemini is a worker
niia write --session S4 $'aider\r'      → Aider is a worker
niia write --session S5 $'ollama run llama3\r' → Ollama is a worker

You:  "Claude, research the auth module"
      [wait 2 minutes]
      [copy Claude's output]
      "Codex, review this code: [paste]"
      [wait 1 minute]
      [copy Codex's output]
      "Gemini, does this match the RFC? [paste]"
      [wait 1 minute]
      ...

You are the integration layer.
You are the bottleneck.
You copy-paste between AI silos.

$ niia run auth-refactor.connector.json

[Phase 1: Research]  Gemini + Ollama    → 30 seconds (parallel)
[Phase 2: Design]    Claude             → 45 seconds
[Phase 3: Implement] Codex              → 60 seconds
[Phase 4: Review]    OpenCode + Claude  → 30 seconds (parallel)
[Phase 5: Document]  Aider              → 15 seconds

Total: ~3 minutes. No copy-paste. Six AI perspectives.

# Install
openclis install niia

# Start
niia login
niia serve

# Run multi-AI pipeline
niia run my-team.connector.json