Part 1 of 4 in Gluon: Building an AI Agent Orchestrator series

The Tmux Chaos

Five tmux panes. All running simultaneously. Each one a Claude Code session working on something different—a homepage redesign, a bug fix in the auth layer, a refactor of the data pipeline, documentation for a new API, and tests for the entire module.

I'm jumping between them. Alt-arrow keys like muscle memory, frame by frame. One minute I'm watching the homepage session hang. The next I'm checking if the auth session has actually finished or crashed silently. Then the pipeline session threw an error I missed because I was focused on documentation. Meanwhile, the costs are climbing—$0.47 for this run, $0.82 for that one—and I have no idea how much I'm actually spending across all five.

Which session is working on what? How much have I spent today? Did that agent finish or get stuck? Is it still running?

These are questions I couldn't answer without hunting through terminal output. There was no single view of the work. No way to see: "Oh, three tasks are done, one is running, and one is blocked waiting for input." Just chaos. Context switching hell dressed up as productivity.

This wasn't a personal failing. It was a visibility problem. A signal that we'd entered a new era where the old tools were already obsolete.

The Insight

I'd spent years managing human teams. The patterns are simple: assign work, track progress, unblock blockers, measure output. When chaos strikes, pull up a project board—Kanban, Jira—and suddenly it has shape. Visibility fixes half the problems immediately. Coordination fixes the rest.

The thought was obvious: what if I applied these principles to coordinating AI agents?

The breakthrough: reframe it. Not a technical problem. A management problem. AI agents need what human teams need—visibility, status tracking, cost awareness, coordination across parallel work.

Andrej Karpathy said it clearly: "I really am mostly programming in English now, a bit sheepishly telling the LLM what code to write… in words. This is easily the biggest change to my basic coding workflow in 2 decades." We're already there. Agents are the default now. But the infrastructure to orchestrate them—to see them, coordinate them, measure them—didn't exist.

The market was signaling this too. 57% of organizations are running agents in production. That's not theoretical. That's now. And the tooling was still stuck in the tmux era.

Vibe Kanban showed the conceptual clarity of what was possible: a Kanban board treating AI agents like sprint team members, running them in parallel in isolated git worktrees. Beautiful and simple. But I wanted to go deeper—what if orchestration wasn't just about visibility, but cost tracking, session persistence, autonomous loops, and safety mechanisms? What if we built something that solved the production problem?

That's when I decided to build it.

Building With AI

The meta part: I used Claude Code to build Gluon, the orchestrator that manages Claude Code agents. AI building systems to orchestrate AI.

A long weekend of work. Python 3.12, FastAPI backend, React dashboard. Five layers: interface (CLI, web, bots), bot core, orchestration, services, and agent layer wrapping Claude's SDK. Not overengineered. Structured.

Two or three days of intense iteration. Done. Claude Code's capability to handle 200-file edits with 200K token context in 90 seconds made this possible. That speed compounds. Rapid feedback loops: try an idea, see it fail, refactor, ship in cycles that used to take weeks.

This happens because the bootstrap isn't about code. It's context and infrastructure. "When the first real feature gets implemented, AI starts with structured knowledge about the product, architecture, tech choices, and quality requirements. It doesn't start cold." I understood the problem deeply. Claude Code understood it too. The handoff was frictionless.

That's why Gluon exists. And what it signals about where we're headed.

What Gluon Actually Is

Gluon isn't trying to replace Claude Code or rebuild agents. It wraps the Claude Agent SDK with orchestration capabilities the SDK doesn't provide.

Think of it as a project manager for AI agents.

The architecture is straightforward:

Rendering diagram...

Submit a task via CLI, web, or chat bot. The orchestrator creates a session, spins up a GluonAgent, streams responses in real-time. Cost tracked at every step. The agent runs in its own git worktree—isolated, sandboxed, never touching main. When done, the session persists. Resume it later with full context intact.

What solves the tmux chaos:

Visibility: Every agent is visible on a Kanban board. Queue, Running, Review, Done. You know exactly what's happening.

Isolation: Each task gets its own git branch and worktree. No cross-contamination. No fights over resources.

Session persistence: Multi-day workflows work because the context survives. Stop an agent, come back tomorrow, resume with everything intact.

And then there's the autonomous part.

Ralph Loop: Autonomous Work

Gluon's real power emerges when you go autonomous. Ralph Loop is the self-driving mode—the agent keeps working toward completion without human intervention.

It sounds scary. And it should come with safeguards. As Andrej Karpathy put it: "We're cooperating with AI, they generate and humans verify. It is in our interest to make this loop go as fast as possible, and we have to keep the AI on a leash."

Safety is built in. The circuit breaker uses a state machine: CLOSED (normal) → HALF_OPEN (warning) → OPEN (stopped). If an agent gets stuck—same error five times, no progress for five iterations—the circuit opens and the loop stops. You get a notification. A human reviews. Then you decide what's next.

The loop detects completion through multiple signals. The agent can emit a RALPH_STATUS block. Or it looks for keywords. Or it scans TODO files. When completion confidence reaches 60%, the loop exits to Review. Human takes a look. If good, it goes to Done. If something's wrong, ask clarifying questions and the agent resumes.

A 50-line feature? Ralph typically needs 10-20 iterations. Hands off. Just watching. That's the shift.

The Kanban Workspace

The web dashboard is the nerve center. Four columns: Queue, Running, Review, Done.

Click to enlarge

Everything visible. Status clear. Cost tracked. Drag and drop to manage the workflow. Running tasks have colored health dots: green (healthy), yellow (slow), orange (looping), red (stuck). The visibility that was missing in tmux hell.

Organize by project or workspace. Filter as needed. The Kanban board does what it does for human teams: makes work visible and coordinates parallel streams.

Part 2 explores this in depth.

The Release

Gluon is live on GitHub at github.com/carrotly-ai/gluon-agent under the MIT license. Version 0.8.0. Production-ready. Actively maintained.

What's included: dashboard, CLI, bot transports (Telegram, Discord), Ralph Loop, formulas for multi-step workflows, supervision systems, circuit breakers. Real infrastructure.

80+ REST endpoints. 40+ MCP tools. 50+ CLI commands. Run it locally, deploy in Docker, connect to your chat workspace. Pick your workflow.

Why Now?

The timing is critical. The AI agents market is $10.91 billion in 2026 and projected to hit $182.97 billion by 2033—a 49.6% CAGR. This is enterprise infrastructure being built right now.

Gartner is tracking a 1,445% surge in multi-agent system inquiries. That's not hyperbole. It's market urgency. And Rajeev Rajan, CTO at Atlassian, said something striking: "Some teams at Atlassian have engineers basically writing zero lines of code: it's all agents, or orchestration of agents."

This is happening at Fortune 500 companies right now. The question isn't whether orchestration is coming. It's who builds it, and whether it's open infrastructure or proprietary walled gardens.

I'm betting on open infrastructure. Community-driven orchestration is more powerful than any single proprietary tool because it evolves at the pace of the ecosystem. It compounds collective intelligence instead of concentrating it.

What's Next

This is Part 1 of 4. I'm opening the aperture on how teams work with AI agents at scale.

Part 2 walks through the dashboard and real workflows.

Part 3 goes deep on Ralph Loop safety, circuit breaker patterns, and production autonomy.

Part 4 tackles team infrastructure—Docker, multi-project coordination, cost management, governance.

The future of software engineering isn't about writing better code. It's orchestrating AI agents to write code while humans focus on judgment, taste, and direction. That future is here. The tools to make it work at scale are now open source.

Series Navigation

• Post 1: From tmux Chaos to AI Agent Orchestration (you are here)
• Post 2: Inside the Cockpit
• Post 3: Ralph Loop — Autonomous Execution
• Post 4: From Solo Tool to Team Infrastructure