1 agent:     You + Claude
2 agents:    Claude + Codex (review)
5 agents:    Claude + Codex + Gemini + Haiku × 2 (pipeline)
20 agents:   Research team (5) + Impl team (5) + QA team (5) + Ops team (5)
100 agents:  Each team spawns sub-teams

{ "workers": 1 }     →  { "workers": 5 }     →  { "workers": 100 }

Level 0:  Unidirectional     A → B              (pipeline)
Level 1:  Bidirectional      A ↔ B              (dialogue)
Level 2:  Broadcast          A → [B, C, D]      (meeting)
Level 3:  Full mesh          A ↔ B ↔ C ↔ D      (N:N)

Level 0:  { "type": "pipeline" }
Level 1:  { "type": "dialogue", "rounds": 3 }
Level 2:  { "type": "meeting", "broadcast": true }
Level 3:  { "type": "mesh", "any_to_any": true }

Depth 0:  You → 1 agent
Depth 1:  You → agent → sub-agents
Depth 2:  You → agent → sub-agents → sub-sub-agents
Depth N:  Each agent can spawn its own connector.json

Depth 0:  connector.json (1 pipeline)
Depth 1:  connector.json → agent runs connector-sub.json
Depth 2:  connector-sub.json → agent runs connector-sub-sub.json
Depth N:  recursive, unlimited

         You
          │
     connector.json
      /     |     \
  Agent A  Agent B  Agent C
     |                |
  sub.json          sub.json
   / | \              |
  D  E  F            sub-sub.json
                      / \
                     G   H

1 machine:   All agents on your laptop
2 machines:  Laptop + server
N machines:  Laptop + GPU farm + data centers + air-gapped facilities

1 machine:   { "model": "claude" }
2 machines:  { "machine": "server", "model": "claude" }
N machines:  { "machine": "tokyo", "model": "claude" }

Dimensions 1-4:  AI inside the terminal (files, code, commands)
Dimension 5:     AI outside the terminal (windows, buttons, apps, screen)

{ "capabilities": { "kernel": { "observe": true, "control": ["ax-press", "key"] } } }

Nodes × Direction × Depth × Machines × OS Access = Total Complexity

Example:
  5 agents × mesh × 3 levels deep × 4 machines × OS control
  = potentially 5 × 5³ × 4 = 2,500 agent interactions
  + each agent can see and control the OS on its machine

A human cannot track 2,500 interactions across 4 machines with OS access.
An orchestrator AI can. With the right harness.

< 10 agents:    Human can track everything
10-50 agents:   Human tracks top level, AI tracks details
50-200 agents:  Human sets intent, AI manages structure
200+ agents:    Human defines goal, AI builds and runs entire organization

Level 0: Human                  "Build auth feature"
Level 1: Orchestrator AI        Reads intent → designs pipeline → spawns teams
Level 2: Team Lead AIs          Each manages 5-10 workers
Level 3: Worker AIs             Execute tasks, report results
Level 4: Sub-worker AIs         Handle sub-tasks spawned by workers

Human sees: Level 0 intent + Level 1 summary
AI manages: Level 1-4 entirely

Human intervention: "change direction" or "stop"
AI handles: everything else

OBSERVE:   niia serve --list          → see all sessions, all levels
           niia remote status list    → see all machines
           niia mesh --observe        → see all communication

DIRECT:    niia write --session S     → message any agent
           niia mesh --broadcast      → message all agents
           connector.json             → define the entire structure

STOP:      niia stop --session S      → stop one agent
           niia stop --recursive      → stop agent + all its children
           Ctrl+C on connector.json   → stop entire pipeline

connector.json:
  Dimension 1 (count):     "workers": N
  Dimension 2 (direction): "type": "mesh"
  Dimension 3 (depth):     agents run their own connector.json
  Dimension 4 (machines):  "machine": "anywhere"
  Dimension 5 (OS):        "capabilities": { "kernel": {...} }

  Same spec.
  Same daemon.
  Same control.
  Any scale.