The Problem Nobody Is Talking About: Agent Sprawl

Developers are quietly accumulating an agent problem. A single engineer now routinely runs Claude, Codex, and Cursor agents in parallel across different tasks — one refactoring a module, another writing tests, a third handling documentation. Each agent operates in complete isolation. There is no shared runtime, no unified visibility layer, no standard protocol for tracking what the collective herd of agents is actually doing at any given moment.

The tooling gap is not at the model layer. GPT-4o, Claude Sonnet, and Gemini are all capable of generating production-quality code. The real infrastructure hole sits between the developer and the agents — the orchestration layer, the process management, the ability to supervise concurrent agent sessions without switching between four different terminal windows or browser tabs. Nobody ships a solution for that part.

Can Celik recognized this gap and built herdr, a terminal-native agent multiplexer written in Rust that already carries nearly 10,000 GitHub stars. The project’s framing is precise: herdr is a runtime for the agent era, not another AI model wrapper or chat interface. It treats running multiple coding agents as an operational problem that demands a dedicated runtime solution.

Most AI coding coverage obsesses over benchmark comparisons — which model completes HumanEval fastest, which hallucinates less on complex algorithms. That conversation ignores the operational complexity developers face the moment they scale beyond a single agent session. Coordinating parallel AI workstreams, monitoring agent output across simultaneous processes, and maintaining developer oversight over automated coding pipelines are infrastructure problems. They require agent orchestration tooling built with the same seriousness that container runtimes brought to managing microservices.

The absence of a standard agent management layer means every team currently invents its own patchwork solution — shell scripts, tmux configurations, ad hoc logging. Agent sprawl is already happening. The category of developer tooling that addresses it is only beginning to form.

What herdr Actually Is — and Why ‘Multiplexer’ Is the Key Word

Can Celik built herdr with a one-line description that does a lot of work: “agent multiplexer that lives in your terminal.” Each word is load-bearing.

The multiplexer concept comes from systems programming, where a multiplexer manages multiple data streams through a single interface — think tmux handling multiple terminal sessions, or a network switch routing packets across connections. Celik borrows that architecture and applies it to AI coding agents. Instead of launching one agent at a time and babysitting it through a GUI, herdr runs many agents simultaneously and surfaces them through one persistent interface. The result is a control plane for agentic workloads, not a chat window.

The terminal-native decision is architectural, not aesthetic. Running inside the terminal keeps herdr lightweight and composable. Developers pipe it into existing shell scripts, chain it with other CLI tools, and integrate it into workflows that already live in the command line. There is no Electron app to install, no browser tab to keep open, no separate dashboard eating memory. The tool fits where developers already work.

The “runtime” framing carries the most strategic weight. Utilities are disposable — you run them, get output, and close them. A runtime is infrastructure. It runs continuously, manages process lifecycles, and acts as the substrate other things depend on. Celik positions herdr explicitly as “the runtime for the agent era,” signaling that the goal is not a single-purpose tool but a persistent layer that sits underneath agent-based development workflows.

Built in Rust and open source, herdr has reached 9,717 GitHub stars — a signal of genuine developer interest in terminal-native agent orchestration rather than GUI-wrapped alternatives. Celik works on herdr full-time without revenue, funding development through GitHub Sponsors, where tiers run from $25 per month for individual backers up to Gold-level sponsorships that include logo placement.

The combination — multiplexer model, terminal residency, runtime positioning — defines a specific bet: that managing AI agents should look more like managing system processes than like using a SaaS product.

The Open Source, No-Revenue Bet — and Why It Matters for Trust

Can Celik builds herdr full-time with zero revenue. No venture capital, no enterprise contracts, no freemium funnel. The project runs entirely on GitHub Sponsors, with individual backers starting at $25 a month and company logo placements beginning at the Gold tier. That’s an unusual stance in 2025, when most developer tooling startups are racing toward Series A rounds or acquisition conversations with larger platforms.

The funding model is a deliberate choice, and it carries real consequences for how herdr gets built. Tools backed by institutional money face pressure to monetize workflow data, introduce proprietary lock-in, or gate features behind paywalls. An AI agent runtime sitting between a developer and multiple autonomous coding agents is exactly the kind of infrastructure where those incentives become dangerous. herdr’s open source codebase, hosted on GitHub under the ogulcancelik/herdr repository, lets anyone audit what the runtime actually does with agent processes, session state, and terminal output. Fork it, inspect it, contribute to it — the code is public.

That auditability matters more for agent orchestration tooling than for almost any other category of developer infrastructure. When a tool manages multiple AI agents running concurrently in a terminal environment, trust in the runtime layer isn’t optional. Developers need to know the tool isn’t phoning home, reshaping outputs, or building proprietary dependency chains that make migration painful later.

The fact that Celik is building this independently also signals something about the market. Agent multiplexing, terminal-native AI workflows, and multi-agent runtime coordination are early enough that no dominant commercial model has emerged yet. The space hasn’t been carved up by Salesforce, Microsoft, or any of the major cloud providers. That gap is exactly where independent open source builders operate best — moving fast, staying accountable to users rather than investors, and setting architectural precedents before the consolidation wave arrives.

herdr’s 9,700-plus GitHub stars suggest developers recognize the gap too. Sponsorship keeps the project alive and the roadmap free from external interference.

The Bigger Vision: A Runtime for the ‘Agent Era’

Can Celik doesn’t describe herdr as a productivity tool or a developer convenience. He calls it “the runtime for the agent era” — a phrase that signals foundational ambition, not incremental improvement.

The framing matters. Runtimes aren’t accessories; they’re the substrate everything else runs on. When Celik positions herdr as a runtime rather than a dashboard or a wrapper, he’s making a claim about where AI agent orchestration sits in the infrastructure stack — at the bottom, not the top.

The historical parallel to Docker is hard to ignore. Before containerization, deploying software meant wrestling with environment mismatches, fragile dependencies, and brittle server configurations. Docker didn’t make deployment slightly easier — it redefined what deployment meant and became mandatory infrastructure for the cloud era. Agent runtimes like herdr are positioning for the same kind of transition. Right now, running multiple AI coding agents in parallel is awkward and manual. If multi-agent development becomes standard practice — and the trajectory suggests it will — the orchestration layer becomes load-bearing infrastructure.

That shift reframes the problem entirely. The AI agents themselves are not the hard part. Claude, GPT-4, Gemini, and open-source models are already capable enough to write, test, and refactor code autonomously. The hard part is managing what happens when you run dozens of them simultaneously: scheduling work across agents, monitoring session health, catching failures before they cascade, and keeping a human developer in meaningful control of the herd. That management layer — agent lifecycle management, terminal multiplexing, parallel execution control — is exactly what herdr is built to own.

Celik is building herdr full-time with no revenue, funding development entirely through GitHub Sponsors. That’s a bet that the agent orchestration runtime becomes critical infrastructure before the market consolidates around a well-funded incumbent. With nearly 10,000 GitHub stars on the herdr repository, the developer community is taking the bet seriously.

What the Broader Industry Should Take From This

Large AI labs are pouring billions into model capability. OpenAI, Anthropic, and Google are locked in a benchmark race while the operational layer — how agents actually run, persist, and scale in production — remains largely unaddressed by any of them. Independent projects are moving into that vacuum. Herdr, a Rust-based agent multiplexer sitting at nearly 10,000 GitHub stars, is one of the clearest examples of grassroots infrastructure filling a gap that enterprise teams will eventually need solved at serious scale.

The terminal-native design philosophy behind herdr challenges a widespread assumption in AI tooling: that developer products require polished web interfaces to gain adoption. For power users, composability beats aesthetics. A runtime that lives in the terminal integrates cleanly into existing shell scripts, CI pipelines, and workflow automation. It behaves like infrastructure is supposed to behave — scriptable, observable, and composable with everything already in a developer’s stack. GUI wrappers add friction for the engineers who move the fastest.

The sustainability angle matters too. Can Celik, herdr’s sole developer, built a tiered GitHub Sponsors structure that starts at $25 per month for individual backers and scales to named logo placement for companies at the Gold tier. Partnership inquiries route directly to hey@herdr.dev. This is a developer working full-time on open source agent orchestration infrastructure with no revenue — and still thinking systematically about how the project sustains itself long-term. That posture signals maturity. Too many open source projects collapse under adoption weight because they never built a funding model before they needed one.

The broader lesson for the AI developer tools space: the runtime and orchestration layer for AI coding agents is open territory. Enterprises running multiple agents across complex codebases need process management, session control, and multi-agent coordination that no major vendor currently ships as a first-class product. Terminal-native agent runtimes, agent process managers, and AI workflow orchestrators built for developers who live in the command line represent a category that is early and underfunded relative to its eventual importance. The projects building seriously in this space right now — with strong architectural foundations and early sustainability thinking — are the ones that will define how agentic development infrastructure looks at scale.