Skip to main content

​
Multi Agent. Multi AI Model. Multi Machine. For Claude, Codex, Gemini, OpenCode, and All the Other AIs.

One connector.json. Every AI you have. Working together.

​
The Reality of 2026

You don’t use one AI. Nobody does. 
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
Six AI tools. Six isolated terminals. Six separate conversations. They can’t see each other. They can’t help each other. You copy-paste between them. You are the integration layer.

​
What If They Could Work Together?

{
  "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
  }
}
Six AI models. Five phases. Parallel where possible. Each model does what it’s best at. 
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)
Total time: minutes. Total cost: a few dollars. Total quality: six different perspectives.

​
Multi Agent

Not one AI doing everything. Many AIs, each with a role. 
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 }

​
Multi Model

Not one model for every task. The right model for the right job. 
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 $$$$$$$$$
Cost-aware routing. Expensive models only where reasoning depth matters. Cheap models everywhere else. Local models where data can’t leave. 
{
  "models": {
    "expensive": "opus",
    "fast": "codex",
    "cheap": "haiku",
    "free": "ollama/llama3"
  }
}

​
Multi Machine

Not everything on your laptop. The right machine for the right workload. 
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." }
    ]
  }
}
Four machines. Four different AI models. Each placed where its resources are. Data never leaves the data server. Heavy inference runs on GPUs. Tests run on CI. You coordinate from your laptop.

​
For ALL AIs

connector.json doesn’t care which AI you use. If it runs in a terminal, it’s a valid worker. 
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
Why? Because connector.json uses PTY-for-AI — real terminal sessions, not API pipes. The daemon spawns a terminal, types the AI command, reads the output. It doesn’t matter what’s running inside. 
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
Same interface. Same commands. Same scratchpad. Different AI.

​
The Alternative

Without connector.json, multi-AI collaboration looks like this: 
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.
With connector.json: 
$ 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.

​
Try It

# Install
openclis install niia

# Start
niia login
niia serve

# Run multi-AI pipeline
niia run my-team.connector.json
One command. Every AI you have. Working together.