c11: When AI Agents Need Their Own Terminal Real Estate Manager
Hook
What if your coding agent could spawn its own terminals, split panes, open browsers, and coordinate with other agents through shared JSON metadata—without you touching the keyboard?
Context
Traditional terminal multiplexers like tmux and screen were built for humans who occasionally automate. You can script them with tmux send-keys or screen -X, but the mental model is always "human configures layout, automation fills it in." As AI coding agents evolved from chat assistants to autonomous developers that spawn sub-processes, validate in browsers, and run for hours, this human-first design became a bottleneck. An agent fixing a React component needs to: edit code in one terminal, run tests in another, boot a dev server in a third, open the browser to validate, maybe tail logs in a fourth. In Claude or Cursor, the agent describes these steps but you execute them—spawning terminals, arranging windows, copying URLs. The agent treats your desktop as a black box it can only observe through command output.
c11 inverts this. Built by the Stage-11-Agentics team as a macOS-native Swift application, it's a terminal multiplexer where agents are first-class citizens with full programmatic control. Every panel (terminal or browser) exposes a Unix socket RPC interface. Agents don't just run inside terminals—they script the multiplexer itself, treating window layout as mutable state. Need three more terminals? Call the split API. Want to pass context to another agent? Write to your panel's JSON metadata blob visible in the sidebar. Finished validating? Close the browser panel programmatically. The "hyperengineer" tagline isn't hyperbole—it's optimized for workflows where you're orchestrating multiple autonomous agents simultaneously, each managing their own workspace real estate.
Technical Insight
c11's architecture is a hierarchy: window → workspace → area → panel. Each workspace is an independent namespace with its own tab in the UI. Within a workspace, areas are recursive split containers (horizontal/vertical), and panels are leaf nodes running either a Ghostty terminal process or a WKWebView browser. The key innovation is the socket layer. When c11 spawns a panel, it creates a Unix domain socket at a predictable path and exposes RPC methods:
// Simplified from c11's panel manifest system
struct PanelManifest: Codable {
var id: UUID
var type: PanelType // .terminal or .browser
var metadata: [String: AnyCodable] // Open JSON blob
}
enum RPCCommand {
case splitArea(direction: SplitDirection)
case spawnPanel(manifest: PanelManifest)
case writeMetadata(key: String, value: AnyCodable)
case closePanel(id: UUID)
case evaluateJS(script: String) // Browser panels only
}
An agent running in panel A can communicate with c11's socket to split its area and spawn panel B. Panel B's agent can read panel A's metadata from the sidebar or via API. This creates an ad-hoc message bus—not formally designed like Redis pub/sub, but emergent from the open metadata blobs. A supervisor agent might write {"status": "waiting", "progress": 0.3} that renders in the sidebar, while a worker agent polls sibling metadata to coordinate work distribution.
The browser panel integration is where c11 differentiates from "just add WKWebView to a terminal app." Because the browser lives in the same workspace as terminals, agents can:
# Agent script running in a terminal panel
cd my-react-app
npm run dev & # Backgrounds the dev server
sleep 5 # Wait for boot
# Call c11's socket API to spawn browser panel
echo '{"command":"spawnPanel","type":"browser","url":"http://localhost:3000"}' | \
nc -U /tmp/c11-workspace-${WORKSPACE_ID}.sock
# Wait, then introspect the DOM via accessibility API
echo '{"command":"evaluateJS","script":"document.querySelector('h1').textContent"}' | \
nc -U /tmp/c11-workspace-${WORKSPACE_ID}.sock
This solves the validation loop problem: agents can boot a server, open it, and verify DOM state without brittle screenshot parsing or leaving their execution context. The accessibility tree introspection (inherited from macOS's native APIs) gives structured data, not just pixels.
Workspace persistence is another architectural win. When you switch tabs, c11 serializes the entire tree—split ratios, panel manifests with metadata, scroll positions—to local storage. Switching back restores pixel-perfect state. For multi-repo workflows (microservices team working on 5 repos simultaneously), you create one workspace per repo. Each workspace might have 10-15 panels by end of day. tmux sessions can do this, but switching is tmux attach -t session-name plus mental overhead. c11 makes it spatial and visual.
The process-per-panel model is both strength and weakness. Each Ghostty terminal is an independent process, inheriting Ghostty's GPU-accelerated rendering. tmux routes everything through a single server, creating a rendering bottleneck when you have 20+ panes. c11 parallelizes rendering across CPU cores. But it also means 50 panels = 50 Ghostty processes. The README's admission that you can OOM an 8GB MacBook Air isn't a bug—it's the trade-off. Hyperengineers with 64GB M3 Maxes aren't concerned.
Gotcha
The socket API has zero authentication. Any process on your Mac can connect to /tmp/c11-workspace-*.sock and script any panel. If a malicious npm package or compromised agent runs rm -rf / in a hidden panel, or exfiltrates AWS credentials from another panel's environment, c11 won't stop it. The threat model assumes all code in all panels is trusted—reasonable for solo developers, catastrophic for shared machines or if you're running agents that execute untrusted code (like an agent that reviews pull requests by checking out and running tests). tmux has the same issue, but tmux doesn't market itself as agent-native. When agents are autonomous, the attack surface expands.
The metadata coordination layer is last-write-wins with no schema. If two agents write to the same key simultaneously, one silently clobbers the other. There's no locking, versioning, or conflict resolution. For simple supervisor/worker patterns this is fine, but complex multi-agent orchestration will hit race conditions. You'll need to build your own coordination primitives (locks via file system, turn-taking protocols) on top of c11's open JSON blobs. The bigger adoption problem is the chicken-and-egg: existing agent frameworks (LangChain, AutoGPT, Cursor) don't ship c11 support out of the box. You'll write glue code to make your agents speak c11's socket protocol, which means this is only worth it if terminal management is genuinely your bottleneck.
Verdict
Use if: You're on macOS running 3+ autonomous AI agents simultaneously across multiple repositories, you've hit the limits of manual window management, and you're willing to write socket-based glue code to connect your agent framework to c11's RPC API. The programmable layout and metadata bus are legitimately novel for multi-agent orchestration patterns where agents spawn sub-agents or coordinate through shared state. Also use if you're building agent tooling and want to offer spatial workspace control as a feature—c11 proves the primitives work. Skip if: You're on Linux/Windows, you run one agent at a time, you need security boundaries between processes, or you're expecting plug-and-play integration with existing agent tools. Also skip if you have 8GB RAM—the process-per-panel model will punish you. For traditional terminal multiplexing without the agent-native features, tmux or Zellij are more mature and cross-platform. c11 is a power tool for a bleeding-edge workflow that most developers aren't living yet.