Subagent (how others do it):
  Parent owns the child.
  Child has limited tools.
  Child cannot spawn its own children.
  Depth: typically 1-2 levels.

Agent (connector.json):
  Every worker is a full terminal session.
  Full tool access. Full context window.
  Can run its own connector.json inside.
  Depth: unlimited.

Main Session (you)
  ↓ niia run project.connector.json
  ├── Agent: "architect" (Opus)
  │     ↓ reads codebase, decides to split into frontend + backend
  │     ↓ niia run frontend.connector.json  ← spawns its own team
  │     ├── Agent: "react-dev" (Sonnet)
  │     ├── Agent: "css-expert" (Haiku)
  │     └── Agent: "test-writer" (Haiku)
  │
  ├── Agent: "backend-lead" (Opus)
  │     ↓ niia run backend.connector.json  ← spawns its own team
  │     ├── Agent: "api-dev" (Sonnet)
  │     ├── Agent: "db-migration" (Codex)
  │     │     ↓ niia run migration.connector.json  ← goes deeper
  │     │     ├── Agent: "schema-design" (Haiku)
  │     │     └── Agent: "data-backfill" (Haiku)
  │     └── Agent: "security-review" (Codex)
  │
  └── Agent: "qa-lead" (Gemini)
        ↓ waits for architect + backend to finish
        ↓ niia run qa.connector.json
        ├── Agent: "e2e-tester" (Sonnet)
        ├── Agent: "load-tester" (Haiku)
        └── Agent: "accessibility" (Gemini)

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

  "pipeline": {
    "phases": [
      {
        "name": "plan",
        "model": "opus",
        "prompt": "Analyze the project. Break it into frontend and backend workstreams. For each, create a connector.json and run it with 'niia run'.",
        "capabilities": {
          "can_spawn_teams": true,
          "connector_templates": ["frontend.json", "backend.json", "qa.json"]
        }
      }
    ]
  }
}

# See all active sessions across all levels
niia serve --list
  Session 1: architect (Opus)        → running
  Session 2: react-dev (Sonnet)      → running  [spawned by: architect]
  Session 3: css-expert (Haiku)      → idle     [spawned by: architect]
  Session 4: backend-lead (Opus)     → running
  Session 5: api-dev (Sonnet)        → running  [spawned by: backend-lead]
  Session 6: db-migration (Codex)    → running  [spawned by: backend-lead]
  Session 7: schema-design (Haiku)   → done     [spawned by: db-migration]
  ...

# Read any agent's output, at any depth
niia get-answer --session 7 "schema"

# Send message to any agent, at any depth
niia write --session 6 $'pause the migration, schema changed\r'

# Stop an entire subtree
niia stop --session 4 --recursive    # stops backend-lead + all its children

scratchpad/                          ← main level
├── architect-findings.md
├── frontend/                        ← architect's sub-team
│   ├── react-components.md
│   ├── css-tokens.md
│   └── test-results.md
├── backend/                         ← backend-lead's sub-team
│   ├── api-design.md
│   ├── migration/                   ← db-migration's sub-team
│   │   ├── schema.sql
│   │   └── backfill-status.md
│   └── security-report.md
└── qa/                              ← qa-lead's sub-team
    ├── e2e-results.md
    └── load-test-metrics.md

Claude Teams:      Leader → [Worker, Worker, Worker]
                   1 level. Fixed.

connector.json:    Agent → [Agent → [Agent → [Agent...]]]
                   N levels. Dynamic.
                   Each agent decides its own decomposition.

Level 0: 1 agent (you + main session)
Level 1: 3 agents (architect, backend, qa)
Level 2: 8 agents (sub-teams)
Level 3: 4 agents (sub-sub-teams)
Total:   16 agents working simultaneously

Cost:    Level 2-3 uses cheap models (Haiku)
         Level 0-1 uses expensive models (Opus)
         Average cost per agent is low
         Total throughput is massive

{
  "limits": {
    "max_depth": 4,
    "max_total_agents": 20,
    "max_cost_usd": 50,
    "timeout_per_agent_ms": 1800000
  }
}