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.
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.
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):
- Outcome-conditioned dependencies: Tasks declare what they are blocked by and on which exact outcome (
success,failure, ortermination), moving cleanly through structured states (Queued,In progress,In review,Blocked,Done) (How Coral Runs a Team of AI Coding Agents). - Required artifacts: A task can require artifacts before it closes: the expected outputs (test logs, diffs, review reports, or design notes).
- Atomic completion: Writing the result, attaching the artifacts, and unblocking downstream tasks happen in a single transaction.
- Review holds (
review_pending): An Orchestrator can place a completed task onreview_pendinghold, freeing the worker to pick up new work while gating downstream steps until QA or security review signs off.
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:
- The Orchestrator breaks each goal into concrete tasks and assigns them to specialized agents.
- 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. - 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 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).
Three design choices make this reliable on real hardware:
- Leases, not locks: Claims are leases that renew while work runs. If an agent crashes mid-test, the lease expires and frees the slot—no orphaned locks holding up the machine.
smallvs.heavyscoping: Lightweight, targeted checks (unit tests on changed files, linters) run onsmallslots, while full end-to-end suites, race-detector sweeps, and batched release checks claimheavyslots on a dedicated test machine (Level Up Coding).- Goal-driven priority: Every task belongs to a prioritized goal, and waiting agents in the resource queue are ranked by task priority (
critical,high,medium,low) before falling back to first-come-first-served. When two agents contend for aheavyslot, the work tied to your highest-priority goal wins automatically—without you or the Orchestrator having to micromanage machine scheduling.
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):
- Overlapping heavy runs: Dropped 44% (from 634.3 min/day to 353.7 min/day).
- Slot-request board chatter: Dropped 61% (from 12.9 posts/day to 5 posts/day).
- Median wait for a slot: Dropped from ~27 minutes to 0 seconds.
Putting It Together
When you combine these pieces, running 24/7 multi-agent workflows on modest hardware becomes predictable:
- Mixed-vendor teams let you match the right model to each role on one shared board (Coral README).
- Contract-based task queues ensure downstream work only unblocks when required artifacts and reviews are complete.
- Agents that wait eliminate polling loops and wasted tokens.
- Board search helps agents recover decisions and resume earlier work.
- Prioritized goals give you high-level steering without micromanaging prompts.
- Resource queues, with remote machines reached over SSH, and
heavyandsmallslots, lease-based claims, and goal-driven priority keep constrained machines responsive while automatically advancing your most important work.
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.
Keep reading
- How Coral keeps an agent team unblockedCoral's health check shows what every agent is really doing, nudges work that stalls, and gives the orchestrator what it needs to keep the team moving.
- How to use Fable 5.2 without blowing your budgetHow we use Fable 5.2 as a principal engineer, Opus 5.5 as orchestrator, and Sonnet 5.5, Codex agents and Antigravity as agents, and how that keeps cost down and quality up.
- 10 AI Agents, One Codebase, 25 MinutesWe pointed 10 AI agents at a single codebase and used Coral to coordinate the work. Here's what happened.