You type 4 sentences.
The system deploys 60 agents.

AI agents are fast. Humans are the bottleneck.

A single AI coding agent can implement a feature in minutes. But a developer working with agents one at a time hits a wall: they become the serializer. They define each task, review each output, integrate each result. For every agent added, the human coordination cost grows linearly.

The agent is not the bottleneck. The human is.

The question we answered: Can one person effectively command dozens of agents on a shared codebase without the coordination overhead destroying the gains?

Yes. With three ideas.

Hierarchy. Decomposition. Files.

The multiplication layer

This is the core innovation. Without it, the human manually breaks down every objective. With it, you type 4 sentences and the system generates 12+ independent work streams automatically.

The Decomposer enforces one hard rule: no sub-objective can touch the same file as another sub-objective. If two pieces of work share a dependency, they stay in the same sub-objective. This prevents merge conflicts when 12 builders are writing code simultaneously.

The octopus

Every operation follows nine sequential phases. Within each phase, agents fan out in parallel (the arms of the octopus), then collapse their work into shared files before the next phase begins (the spine).

From sentences to agents

The human types 4 objectives. Here's how the system expands that into a coordinated fleet:

The time scales sublinearly: doubling objectives doesn't double time because the extra agents run in parallel. The sequential phases (strategy, decompose, integrate) are fixed overhead regardless of objective count.

Operation OPBLITZ3

The first field deployment. One operator typed four objectives for the empire1.io web application. The system deployed 16 agents across 4 phases. This was before the Decomposer existed, so decomposition was manual.

The operator typed one command and read one battle map. The equivalent sequential process would need ~50 context switches (defining tasks, reviewing outputs, debugging integration, re-running tests). That's the 200x cognitive load compression.

With the Decomposer now in place, the same 4 objectives would produce 12 sub-objectives and deploy ~71 agents instead of 16. Same human input, 4x more parallelism.

The filesystem is the protocol

Traditional multi-agent systems use message passing: agents send requests to each other and wait for responses. This creates O(n²) communication channels for n agents, ordering dependencies, and cascading failures when one agent is slow.

CommandCC eliminates all inter-agent communication. The filesystem is the only coordination mechanism:

Phase 1 writes OPERATION-PLAN.md.
Phase 2 reads it, writes DECOMPOSITION.md.
Phase 3 reads that, writes ARCHITECTURE-*.md.
And so on. No agent ever reads a file that hasn't been written by a prior phase. The phase sequence guarantees ordering without explicit synchronization.

This means agents don't need to know about each other. A builder doesn't know how many other builders are running. It just reads its architecture file, writes its code, and produces a build report. The system handles everything else.

Four steps