Here is the comparison that should offend the multi-monitor religion. You can engineer the chair, the desk, the Thunderbolt chain, the extra panels — and then discover that a laptop on the couch is, for agent work, basically as good. That is not a hardware punchline. It is evidence that the constraint moved.

The old developer workload genuinely needed glass. Code, docs, terminal, browser: you operated all four and used extra screens as working-memory extension. Agents change the topology. They execute independently. Your interactive bandwidth does not. You still have roughly one brain, one keyboard, and one thing you can actually read at a time. Psychology has been blunt about the scale of that channel for decades: focus-of-attention capacity is small — on the order of a handful of chunks, not a trading-floor wall of feeds.¹

Visibility doesn’t scale. Triage does.

Twenty agent panes do not create twenty-agent vision. They convert hidden chaos into visible chaos. The human cockpit is a manager’s desk, not a factory floor of CCTV feeds. Managers do not get better by staring at every camera at once. They need the right exception at the right moment — and a fast way to put the next idea somewhere before it dies.

The scarce metric is idea-to-agent latency

The first half-truth about multi-agent UX is “tell me which agent deserves my attention.” For operators past chat tourism, the better sentence is: I’ve just had an idea. Give me somewhere to put it before I lose it.

That bottleneck has a name: dispatch latency — idea to clean goal owner to leave. Not compute. Not screen acreage. Not even observability most of the time. When strong goal patterns remove the human from the middle of the loop (“you’re responsible for completeness; keep working until done”), the normal mode becomes human-pull: you re-enter when you care, when you distrust a result, or when something is truly stuck. Continuous agent-push (“which Claude dinged?”) becomes noise dressed as helpfulness.

Industry energy is pouring into the other plane. Public agent guidance from Anthropic distinguishes workflows from agents that dynamically direct tool use, and describes orchestrator–worker patterns where a lead model delegates and synthesises.² Multi-agent research systems go further with specialised subagents in parallel.³ Necessary work. Incomplete. Almost none of that vocabulary names the human capture buffer or idea-to-agent latency as a first-class product metric.

Three states everyone conflates

The missing abstraction is not the agent, the terminal, or even the goal. It is the intent queue above the goals — and three states chat UIs keep muddling together:

1. THOUGHT — volatile spark (“oh — also recover the old dev conversations”)
2. INTENT-BACKLOG — externalised, not yet owned
3. ACTIVE-GOAL — one agent owns the outcome until done

The wrong default is still: thought → type into current agent. That is how you walk up to a staff member six hours into a hard job and say “also do the invoices tomorrow,” then act surprised when both jobs blend and degrade. Intent should be buffered outside execution. Humans learned that with managers and staff a long time ago. Then we wired the manager’s mouth into the worker’s stream of consciousness via a chat box.

Goal slots and semantic occupancy

Under a real goal, a session holds more than a conversation. It holds plan, context, subagents, failures, recovery, and a definition of done. That is semantic occupancy. The agent is not “free” because the CPU is idle. It is committed.

So the work unit changes:

terminal = process
    → terminal = chat
    → session = goal owner

One unit of intent gets one goal slot and one owner — even if the work shares a repo, machine, or project label. “While you’re there…” is contamination dressed as efficiency. Session sprawl is often the correct map of concurrent goals, not evidence of indiscipline. Context engineering makes the same point from the model side: cluttered context degrades output before you hit a hard token wall.⁴ Dumping a second goal into an occupied agent is attention diffusion with a human author.

CAPTURE ≠ SEND

Inventory what is durable in a modern agent stack: transcripts, checkpoints, databases, tool outputs. The exception is the emergent human thought. It decays — especially associative edges that are valuable precisely because you just traversed them. Five minutes later you have residue without the connection.

Yet interfaces give priority to the model’s output and to form-first classification. That is backwards. Write the product pressure as a formula:

Agent concurrency raises arrival rate. Time-to-externalise is almost entirely an interface choice. The near-sacred rule: never make the human wait to externalise intent. Working memory is limited; forcing a thought to stay only in mind while you finish listening, choose a project, and find a free agent spends the same scarce resource that does not scale.¹

CAPTURE gets the thought into a durable buffer — no project, no priority, no Enter that starts a six-hour job. SEND / PROMOTE comes later: classify, compile a North Star goal with a done test, allocate a free slot. Enterprise software usually reverses the order: choose project, category, type, priority, title — then watch the idea die in the lobby.

Field hacks write the requirements document for free: Apple Notes as the global inbox; half-typed messages left unsent in agent windows; two phones so listen and speak do not share one air medium. If a consumer notes app is the highest-level orchestrator above agent SDKs, browsers, and databases, laugh — then take the hint.

Sketch the plane

INBOX / INTENT BUFFER
  ○ free-floating intents (cross-project OK)
ACTIVE GOALS
  ● owned outcomes + agent id
DONE / RESULTS
  ✓ review later

Operations that matter: capture → promote → allocate owner → leave. Full stack under the hood:

volatile intent
  → intent buffer
  → delegation plane
  → goal compiler (North Star + done test)
  → goal owner (one occupied agent)
  → execution hierarchy
  → world-loop closure

Control rooms and terminal multiplexers attack the bottom. Goal harnesses improve the middle. Pain for people who have outgrown “how do I watch twenty Claudes?” lives in the top band. Human-over-the-loop research is catching up to supervisory posture — AI on the routine path, human on judgment — but still rarely names the capture buffer as infrastructure.⁵

Practice: pidgin, tools, human-pull

Two habits raise delegation bandwidth without a new product.

Agent pidgin. Stop typing like you are managing a human’s feelings. Terse compressed instructions; the agent expands operational detail. Typing stopped being the bottleneck. Waiting to capture still is.

Leave the tool loop. If you screenshot errors into chat, paste stack traces, and copy database rows “for” the agent, you are not managing — you are an MCP server made of meat. Give the agent the browser, the shell, the database. Keep the intent loop. Drop the adapter loop. Judge world-loop closure, not path elegance: a ridiculous intermediate file is fine if validation passes and the waste is disposable.

Operate the desk: one fat focal surface; the rest as state; ambient left alone. Default to human-pull. Other domains are describing the same shift — analysts managing a team of agents rather than personally reviewing every alert.⁶

Checklist

1. Always-on capture channel (CAPTURE ≠ SEND)
2. Name three states before you act
3. One slot per unit of intent
4. Promote deliberately (North Star + done test), then allocate
5. Pull on curiosity, distrust, or exception — not every ding
6. Measure idea-to-capture time, capture-to-owner time, contamination incidents

This note does not own goal-formation economics, host-machine topology, or discovery posture. It owns the human-side interface: goal slots, CAPTURE ≠ SEND, attention topology, dispatch latency. Adjacent work on long-running agents, context engineering, and throughput under concurrency covers the neighbouring planes.

Name the missing layer. Build or improvise the Delegation Plane. Protect the slots. Capture before you classify. Pull when you care. Let the factory run.