← Back to Blog

Scaling Agentic Development on Constrained Compute with Resource Queues

Running one coding agent in a terminal is easy. Running a team of agents across a laptop and a couple of spare servers—without them trampling each other's builds, burning tokens in polling loops, or crashing your machines—is where things break down.

The bottleneck in multi-agent engineering isn't getting agents to write code. It's coordinating who does what, verifying the work, and distributing heavy test runs across constrained hardware. In Coral, we solve this without heavy container orchestration or custom CI clusters: you pair goal-driven orchestration, contract-based task queues, and resource queues, with remote machines reached over SSH, where agents claim heavy or small slots based on goal priority.

The Tasks tab of the demo team forge-wars: eight tasks with their state (done, in progress, blocked, queued, in review), the agent each belongs to and when it was last updated.
A Coral team: several agents work on one project and hand work to each other on a shared board.

From Single-Shot Prompts to Mixed-Vendor Agent Teams

Most agent tooling today is built around a single vendor's loop. The moment you want to mix models—say, an Orchestrator on one provider, implementation workers on another, and a dedicated reviewer on a third—you're left gluing terminals together by hand.

In Coral, a team is vendor-agnostic. As detailed in How Coral Runs a Team of AI Coding Agents, you can put Claude Code, Codex, Antigravity (agy), and Pi.dev agents on the same shared board (coral-board). Permissions are defined once in Coral's vocabulary (such as file_read, shell:<pattern>, or git_write) and mapped to each CLI's own permission settings.

Each agent runs in its own tmux session—and optionally its own git worktree—playing specialized roles such as Orchestrator, Core Backend, Frontend Dev, Mobile Dev, DevOps Engineer, Security Reviewer, and QA Engineer.

Coral's Agents view for the demo team forge-wars: six agents listed in the sidebar, three working, one marked Needs input with a question, and two idle.
The Agents view for a team: who is working, who is waiting for an answer, and who is idle (How Coral Runs a Team of AI Coding Agents).

Task Queues with Contracts, Not To-Do Lists

A shared checklist isn't enough when multiple agents are modifying code asynchronously. If an agent marks a task "done" before tests pass or artifacts exist, downstream agents immediately build on broken state.

Coral replaces simple to-do lists with a task queue built on contracts (Coral README):

Agents That Wait Instead of Poll

When an agent hands off work or asks for a review, the naive pattern is a sleep loop that polls a channel every few seconds. That burns tokens, clutters transcripts, and wastes compute.

Instead, Coral uses agents that wait (Coral README). A worker runs:

coral-board wait --from Orchestrator

and ends its turn. Coral suspends the waiting state and wakes the agent the moment the reply or next task lands. When an agent hits a question only a human can answer, it posts to Needs you in the Inbox and picks up another task rather than sitting idle (Keeping an agent team focused, day and night). Idle agents can also sleep to free memory and can usually resume their exact vendor session later, even after a Coral restart.

Board Search Gives the Team a Memory

A restarted agent may come back with a fresh context. A new teammate starts with even less. In Coral 2.1, both can use coral-board search to find the decision, the earlier fix, or the reason a task closed before they ask the team or repeat the work.

One search covers the agent’s team board messages, task titles, descriptions and completion notes, goal titles, outcomes and Done when criteria, and the agent’s own past chats. Use --source to pick where to look, --state or --goal to narrow task and goal matches, --assignee to narrow task matches by agent, or --since to focus on recent work. A chat hit points to the earlier turn, where the agent can recover the context and pick up where its last session left off.

For example, an agent checking whether the team already fixed a problem can search completed tasks.

coral-board search "cache warmup" \
  --source tasks --state completed

On a demo board, this returned one hit, task #1, “Fix cache warmup after restart,” marked completed. The agent can open that task to see how it was resolved.

Wider access to messages or chats requires the Operator to raise the agent’s search access. Coral refuses a request above the granted level and logs wider reads without recording the query or results. Tasks and goals stay scoped to the agent’s own board.

Goals as High-Level Direction

Managing agents at the individual task level doesn't scale; it leads to drift and constant micromanagement. As I wrote in How I Hit 3.6K Commits a Week with Agentic Development, the unlock is shifting from task-level prompting to goal-oriented development.

A goal states a single Outcome, a verifiable Done when check, and a driver (typically the Orchestrator) (How an agent team works toward a goal). You set the goals and order them by priority. From there:

  1. The Orchestrator breaks each goal into concrete tasks and assigns them to specialized agents.
  2. Agents attach tasks to a goal (coral-board task goal TASK GOAL) and upload outputs (coral-agent artifact upload FILE --task N), grouping all design notes, test evidence, and review reports back onto the goal's Artifacts tab.
  3. When all tasks for a goal finish and no files are waiting for review, Coral surfaces the goal in your Inbox as "looks done" for final sign-off (Coral README).
The Goals page of Coral’s Inbox, filtered to one team: 24 goals with filters for Active (21) and Blocked (3), and each goal listed with its state, team, task progress and when it was updated.
The Inbox's Goals page, filtered to one team: active and blocked goals, each with its task progress (How an agent team works toward a goal).
A goal open in Coral: its outcome and done-when lines, 15 of 18 tasks done, tabs Tasks 18 and Artifacts 11, and a table of open tasks with their state and the agent who holds each one.
One goal in detail: its outcome, its done-when line, task completion count, and each open task with the agent who holds it (How an agent team works toward a goal).

The Constrained-Compute Problem: Distributing Testing Without Killing Your Machines

Even with clean task contracts and goal-level direction, one operational bottleneck remains: constrained compute.

Most individual developers and small teams aren't running an elastic Kubernetes cluster. You might have your local workstation and one or two spare servers or build boxes. If six agents finish coding at the same time and all kick off full integration suites, race-detector sweeps, or multi-platform builds on the same machine, the box grinds to a halt.

Before we built a proper queue, our Orchestrator used an ad-hoc message board protocol (HEAVY RUN START / HEAVY RUN END) to keep agents from piling onto the same machine (When AI agents share a machine). It worked—until it didn't. Agents still overlapped, board chatter piled up, and median wait times dragged out.

You don't need Docker images, custom schedulers, or heavy infrastructure to fix this. All you need is SSH access to your machines and a resource queue that agents use directly.

How Resource Slots and Leases Work

Instead of giving agents unrestricted license to run any test anywhere, you expose each machine's capacity as typed resource slots—for example, heavy slots on a build server and small slots on a local box. Agents are instructed to claim an appropriate slot before running tests and to scope their test commands to the slot they hold.

In coral-board, you define a resource once:

coral-board resource define mac-heavy --slots 2 --machine mac --lease 45m --match "go test ./..."

Then an agent claims a slot, waits if capacity is full, runs its job over SSH or locally, and releases it:

coral-board resource claim mac-heavy --wait && go test -p 4 ./... && coral-board resource release mac-heavy

For supported agents like Claude Code, an enforcing hook automatically intercepts heavy commands matching the configured pattern and waits for a slot—so an agent can't accidentally bypass the queue (When AI agents share a machine).

An agent’s chat in Coral: it claims a mac-heavy slot with --wait, waits first in line, gets the slot and runs its browser tests, while the team board on the right shows the hand-off.
An agent claims a slot, waits first in line, runs its tests, and the board shows the hand-off (When AI agents share a machine).

Three design choices make this reliable on real hardware:

What Changed in Practice

After shipping the built-in resource queue in coral-board, the impact on our own constrained hardware was immediate (When AI agents share a machine):

Coral's Resource queue analytics view, showing the before-and-after comparison: HEAVY RUN posts before the queue went live, and the queue's own records since.
Coral's Analytics > Resource queue view comparing ad-hoc board posts (left) against the built-in resource queue (right) (When AI agents share a machine). Tap to enlarge.

Putting It Together

When you combine these pieces, running 24/7 multi-agent workflows on modest hardware becomes predictable:

If you want to try this setup on your own laptop and servers, you can download Coral (open source under Apache 2.0) or explore the subgentic/coral repository.

Try Coral

Open source. Runs on your own computer.

Download Coral

Keep reading