Maxxwell by Rindler
Writing

Herded Workflows: Running Agents in Parallel

2026-11-20

A herded workflow is a multi-agent coding setup where you run many independent AI coding agents in parallel, and a separate orchestration layer (in Maxxwell’s.


A herded workflow is a multi-agent coding setup where you run many independent AI coding agents in parallel, and a separate orchestration layer (in Maxxwell’s case, the “orchestrator seat”) owns the goals and routes your attention, while those agents handle execution in their own terminals.

How a herded workflow works

In a herded workflow, each worker is a normal coding agent session: Claude Code, Codex, Cursor agent, or similar. They run in real terminals or runtimes you already trust. Maxxwell does not replace these agents; it treats them as a fleet of workers.

On top of that fleet sits the goal layer. In Maxxwell, this is itself a briefed coding-agent session: the orchestrator. You give it a written brief for the feature or task, it helps you break work into lanes, and it coordinates across sessions instead of you manually hopping between eight terminals.

Every worker session carries a visible state. Maxxwell labels each lane as working, idle, waiting on you, not started, needs sign-in, blocked, done, dead, or not heard from, with a “possibly stalled” overlay when activity seems to have stopped. That state is derived from actual session activity - when Maxxwell cannot confirm, it says so instead of guessing.

Control in a herded workflow is explicit. Fleet-level controls (e.g., “start a new worker on backend tests” or “pause all refactor lanes”) draft instructions rather than apply them. In Maxxwell, pressing such a control writes a fully formed, unsent sentence into the composer targeting the orchestrator or a worker; you still press Enter. The human remains the one who decides what actually runs.

Sessions in a herded workflow outlive any single app window. You can quit Maxxwell; the underlying agent terminals stay up, ready to reattach. The herd is your processes, not the UI. When you are back, the orchestrator seat can summarize what happened while you were away and what still waits on you.

Why herded workflows matter for serious developers

Once you have more than two or three agent sessions open, the bottleneck is not the models. It is your own attention. You spend your day answering minor questions, checking whether a lane is stuck, and rediscovering context you already gave another session.

Industry data makes the scale clear. Stack Overflow’s 2025 survey reports that 84% of developers use or plan to use AI tools, and over half of professional developers use them daily. JetBrains’ 2025 survey found 85% of developers regularly use AI tools, and almost 1 in 5 saves eight hours or more per week. Those hours often become fragmented across tabs and terminals.

At the same time, trust lags. Only 29% of developers in Stack Overflow’s data say they trust AI outputs to be accurate, and 46% actively distrust them. Google’s 2025 DORA report shows 90% adoption but the same pattern: AI enhances productivity, not judgment. That means you do not want blind automation. You want a way to run many workers while keeping clear gates on what lands.

A herded workflow addresses that gap in three ways:

If you are already running multiple agents, a herded workflow does not add new magic capabilities. It turns the mess you already have into something you can read and steer. GitHub’s own “mission control” framing for agents points in the same direction: parallel agents are useful, but coordination is where the real value is.

For a deeper walkthrough of the UI and controls, see this guide on Maxxwell’s orchestration model: Maxxwell herd workflows: tracking every coding agent session in one pane.

Related terms and what a herded workflow is not

A herded workflow is not just “using a lot of agents.” Most developers already do that: multiple Claude or Cursor panes, plus an IDE copilot. That is ad-hoc multi-agent use: each session knows only what you paste into it; you are the scheduler, dispatcher, and debugger.

A herded workflow adds a persistent goal layer and readable state for the fleet. Instead of “twelve independent chats,” you get “one feature broken into lanes, each with a role and state.” The workers stay unmodified; orchestration sits above them.

It also differs from agent autopilot systems that claim to fully own your workflow. Some tools attempt automatic drift correction, context recycling, or scheduled goal checks. Maxxwell explicitly does not: it does not silently re-aim sessions, auto-compact context, restart stopped work, or revalidate goals on its own schedule.

The herded model is closer to mission control than to a self-driving car. You still decide when to split a task into more lanes, when to kill a dead one, and when to accept or reject a change. Maxxwell gives you:

Compared to single-agent copilots (IDE chat, inline completions), a herded workflow assumes that the unit of work is a feature, not a file. Copilots are great at local edits and quick answers. Herded workflows are about orchestrating dozens of such edits across repos and environments.

Example: orchestrating a complex feature across many sessions

Take a feature you would normally schedule for a small team over a week: “Add SSO with SAML and OIDC, update user roles, and ship an audit log.” You have a monorepo with frontend, backend, infra code, and a couple of internal libraries.

In a herded workflow with Maxxwell:

  1. You brief the orchestrator seat once. You paste a structured brief: current auth stack, target SSO providers, non-negotiable security constraints, rollout plan, and where tests live. The orchestrator helps decompose this into lanes: backend auth, frontend flows, audit logging, docs, and infrastructure.
  1. The orchestrator spins up workers with clear roles. It drafts commands like “start a new worker in services/auth to add SAML/OIDC support” or “start a worker in frontend to implement login UI and error paths.” These come to you as unsent instructions; you approve them, and Maxxwell launches real agent sessions in the appropriate directories or worktrees.
  1. Each lane runs in parallel in your own tools. One worker is refactoring the auth middleware, another is wiring OIDC callbacks, another is generating Terraform changes for new secrets, another is writing end-to-end tests. All of them are regular Claude/Codex/Cursor sessions running under your account.
  1. You watch the herd, not twelve terminals. In the Maxxwell window, you see: backend-auth worker is working with rising context pressure, frontend worker is waiting on you for a UX choice, infra worker is needs sign-in on aws sso login, docs worker is idle. Instead of polling each one, you clear the high-leverage blockers.
  1. You keep control of what lands. When the backend lane finishes, the worker proposes code changes and test updates. The worker reports back what it changed and what is still waiting on review. You still run git diff, review, and merge. If you want to compact an overgrown lane, you hit one-click compact; Maxxwell summarizes, but only because you asked.
  1. You can drop to the metal anytime. If the OIDC lane is going off track, you attach to that terminal, talk directly to the agent, or take over the shell and push your own commits. Quitting Maxxwell does not kill any of this; sessions keep running until you end them.

By the time the feature is ready, you have used agents for boilerplate, integration glue, and documentation, but you never ceded control of security constraints, rollout, or what hit production. The herd did the execution work; the orchestrator and state view kept your decisions focused.

Herded workflows are the answer to “I have eight sessions open and I am the slowest part of this.” They keep your existing agents, give them a shared goal, and turn your attention from terminal whack-a-mole into actual engineering decisions.