SENJU (千手, thousand hands):  Parallel dispatch. Do N things at once.
ASURA (阿修羅, three faces):   Phase orchestration. Do things in order, synthesize.

Use AI:       "Claude, build this feature." → wait → receive result.
              You don't need to understand the internal structure.
              This is driving a car.

Design AI:    "How should 15 agents across 4 levels coordinate?"
              You need to understand the fractal pattern.
              This is building the engine.

"Send N workers out. Collect results."

  SENJU
  ├── Worker A → result
  ├── Worker B → result
  ├── Worker C → result
  └── Worker D → result
       ↓
  [all results collected]

{
  "phases": [{
    "name": "research",
    "parallel": true,
    "workers": 5
  }]
}

"Do this in phases. Each phase sees the previous phase's output."

  ASURA
  Phase 1: Research    → scratchpad
  Phase 2: Synthesize  → reads scratchpad → plan
  Phase 3: Implement   → reads plan → code
  Phase 4: Verify      → reads code → report

{
  "pipeline": {
    "phases": [
      { "name": "research",   "workers": 5 },
      { "name": "synthesize", "workers": 1 },
      { "name": "implement",  "workers": 1 },
      { "name": "verify",     "workers": 3 }
    ]
  }
}

You (Human)
  ↕
ASURA-0 (orchestrator)
  │
  ├── Phase 1: SENJU × 3 (research workers)
  │     │
  │     ├── Worker A ← looks like SENJU from above
  │     │     but inside, it becomes ASURA:
  │     │     ├── Phase 1a: read files
  │     │     ├── Phase 1b: analyze patterns
  │     │     └── Phase 1c: write summary
  │     │
  │     ├── Worker B ← also becomes ASURA internally
  │     │     ├── Phase 1a: search code
  │     │     ├── Phase 1b: trace call chain
  │     │     └── Phase 1c: SENJU × 2 (sub-workers)
  │     │           ├── Sub-worker B1
  │     │           └── Sub-worker B2
  │     │
  │     └── Worker C
  │
  ├── Phase 2: Synthesize
  └── Phase 3: Implement

Dimension 1:  ASURA with N SENJU workers
              = flat multi-agent (what everyone does)

Dimension 2:  Each SENJU is itself an ASURA with M workers
              = N × M agents across 2 levels

Dimension 3:  Those M workers are also ASURAs with K workers
              = N × M × K agents across 3 levels

Dimension D:  Recursive to depth D
              = N^D agents (theoretical maximum)

Level 0:  Human ↔ ASURA
Level 1:  ASURA ↔ SENJU (which are ASURAs inside)
Level 2:  ASURA ↔ SENJU (which are ASURAs inside)
Level N:  Same pattern. Same roles. Different depth.

Human: "Build the auth feature"
  ↕
ASURA-0: "I'll break this into research, implementation, and verification."
  ↓
  [ASURA-0 spawns SENJU workers]
  [Some workers become ASURAs internally]
  [Those spawn their own workers]
  [The tree grows to depth 3, 15 agents total]
  ↓
ASURA-0: "Auth feature implemented. 12 files changed. Tests passing. Here's the PR."
  ↕
Human: "Ship it."

Without ASURA model:
  Human must manage 15 agents directly → cognitive overload → failure

With ASURA model:
  Human manages 1 ASURA → ASURA manages the tree → scales to any depth

Human
  ├── ASURA-frontend: "Build the UI" → [own SENJU team]
  ├── ASURA-backend:  "Build the API" → [own SENJU team]
  └── ASURA-qa:       "Test everything" → [own SENJU team]

Each ASURA reports to the human independently.
Human synthesizes across ASURAs.
Or one ASURA is designated as meta-orchestrator.

Evolution:
  Skill (prototype)     → ran inside Claude Code, Claude-only
  connector.json (spec) → declarative, any AI, any machine
  PTY-for-AI (runtime)  → headless daemon, cross-machine

The model stayed the same. The implementation grew.

{
  "connector": "2.0",
  "name": "feature-build",

  "pipeline": {
    "phases": [
      {
        "name": "research",
        "workers": 5,
        "model": "haiku"
      },
      {
        "name": "synthesize",
        "workers": 1,
        "model": "opus"
      },
      {
        "name": "implement",
        "workers": 1,
        "model": "opus",
        "capabilities": { "can_spawn_teams": true }
      },
      {
        "name": "verify",
        "workers": 3,
        "model": "sonnet"
      }
    ],
    "scratchpad": true
  }
}

Era               Pattern                   Literacy
─────────────     ─────────────────────     ──────────────────
1980s             Files and directories     "Where is my data?"
1990s             Client-server             "What talks to what?"
2010s             Containers + K8s          "What runs where?"
2020s             AI agents                 "Who does what?"
2025+             Fractal orchestration     "Who orchestrates whom,
                                             and how deep does it go?"

Without this literacy:
  "I have 5 AI agents running in parallel"
  = flat. 1-dimensional. Everyone does this.

With this literacy:
  "I have an ASURA with 5 SENJU workers,
   2 of which are ASURAs with their own 3-worker SENJUs,
   across 2 machines, with sandboxed worktrees per level"
  = designed. Multi-dimensional. Intentional depth.

SENJU: "Do N things at once"            → parallel workers
ASURA: "Do things in phases"            → sequential orchestration
Key:   Any SENJU can become ASURA       → recursive depth
Human: Understands the pattern           → designs the structure
Human: Doesn't need to understand inside → uses the structure

This is not a framework. This is a model.
connector.json expresses it. PTY-for-AI executes it.
The model scales to any depth, any width, any number of machines.

The pattern is the literacy.
The literacy is the power.