~2x at the median
Overlapping heavy gates versus solo runs in our Ranch Hand gate logs, across 1,511 runs on one Rust workspace.
Worktree slots isolate source and build caches, but every slot still shares one CPU, one SSD, and one pool of RAM. paniolo queue runs a command only after its named host lane admits it, in arrival order, so gates stop colliding on the machine.
# Enroll this machine once
paniolo queue host enroll
# Send a heavy gate through the shared lane
paniolo queue run --queue heavy-load --label pre-push --repository slot-01 -- git push
# Who is running, who is waiting
paniolo queue status --queue heavy-loadParallel agents look free until the hardware binds. Two heavy gates on one workstation oversubscribe the CPU, the memory, and the disk at the same time, and both get slower together.
Overlapping heavy gates versus solo runs in our Ranch Hand gate logs, across 1,511 runs on one Rust workspace.
Simulated session speedup from halving tool time versus halving model generation, across roughly 12,000 real agent sessions. Tool time is where sessions are won.
Model calls to tool executions per session across 13 million GitHub Copilot sessions. Every additional concurrent agent multiplies tool-side load roughly linearly.
Our gate numbers are observational data from daily development, not a controlled benchmark; a gate that runs longer for any reason is more likely to overlap. The external figures are the authors' own, digested in our research index.
A small local broker arbitrates each configured lane. Queues are host-scoped and capacity one by design, so every caller that matters reaches the same line.
You name the queue and pass the command after --. Arguments run with no shell interpolation, and safe labels (--label, --repository) are what status shows; command text never enters shared state.
Requests admit in arrival order. --no-wait returns a busy outcome so you can switch to lighter work, and --wait-timeout bounds the wait without ever imposing a runtime limit on the child.
A dedicated runner holds the lane's grant until the process and every descendant exits, so a surviving compiler child cannot free the lane early. Nested calls on the same queue reuse the verified grant instead of deadlocking.
When the grant frees, the broker admits the next waiter automatically. If the broker or a runner dies mid-run, the lane stays occupied until recovery proves the work is quiescent.
A prompt that asks agents not to overlap builds works until a hook, a child subagent, or a second terminal launches one anyway. The queue enforces the same rule for every caller.
An unavailable or expired broker reports unavailable. Status never assumes a lane is idle because it failed to look.
The queue coordinates one user's processes on one host, including enrolled WSL guests. It is a scheduling contract, not a security boundary.
Waiting commands are never persisted for automatic replay. A request cancelled before admission is a guarantee that no child launched.
Cancelling a waiting request needs its private receipt in the same configuration context. Only the owner can pull a request out of line.
Configuration cannot raise a lane's limit or create a private fallback. A conflicting scope or limit refuses and names the registered owner.
Native supervision is qualified on Windows. Other platforms refuse rather than silently running an uncoordinated fallback.
Queues live in the harness paniolo.config.json under a top-level queue section. The description tells an agent when to choose the lane; operation mappings wire known hooks to it. Neither one runs anything by itself.
"queue": {
"queues": {
"heavy-load": {
"description": "Use when an agent needs to run a process with heavy memory and/or CPU load.",
"scope": "host",
"maxConcurrent": 1
}
},
"operations": {
"pre-push-gate": { "queue": "heavy-load" },
"release": { "queue": "heavy-load" }
},
"agentStatus": {
"enabled": true
}
}paniolo queue config effective --json shows the resolved catalog with the tracked-versus-local provenance of every value, so an agent can see which file set each rule.
The evidence for serializing heavy local work is old and consistent. Microsoft's C++ build-throughput investigation documented the oversubscription curve from the vendor side: parallel builds speed up only until CPU, memory, or the filesystem binds, and a script that spawned a quadratic number of compiler processes paged the machine into a two-to-three-times slowdown. Ranch Hand gates hit the same walls with linkers instead of cl.exe.
Microsoft C++ team, Nov 2021 — devblogs.microsoft.com/cppblog/cpp-build-throughput-investigation-and-tune-upOn the agent-workload side, the session-level FreeInference analysis (roughly 12,000 sessions, 1.19 million model requests, 1.21 million tool calls across 13 agent harnesses) puts tool execution at 21.7% of session time and user idle at 50.3%. Halving tool time produced a simulated 1.38x speedup, against 1.16x for decode. Faster models buy less than faster tools.
Nixon, Tian, Zheng, Yang, Gunawi — FreeInference, 2026, systems.seas.harvard.edu/blog/agentic-traces-freeinference · dataset 10.5281/zenodo.23903440At production scale, the Copilot characterization found model calls coupled to tool executions nearly one to one. Multiply concurrent agents and you multiply tool-side load by about the same factor, which is what a host lane exists to bound.
Liu, Qiu, Goiri, Fonseca, Bianchini, Choukse — arXiv 2026, arxiv.org/abs/2608.00101The queue pairs naturally with worktree slots: slots keep source and caches apart, the lane keeps the machine for one gate at a time. The case for testing the merged state before either branch lands goes back to Brun, Holmes, Ernst, and Notkin's FSE 2011 study, where a third of the 399 merges version control called clean still broke the build or the tests. Rebase once, then spend one gate.
Brun, Holmes, Ernst, Notkin — FSE 2011, dl.acm.org/doi/10.1145/2025113.2025139More of the research behind the Harness lives on the harness research page, and every digested paper is listed in the paper index.
queue (list, status, config) and queue_write (cancel) tools; running a wrapped command stays CLI-only.paniolo queue host enroll once per machine. Linux and macOS refuse until their supervisors qualify rather than running uncoordinated.-- runs as an argument vector with no shell interpolation, keeping its working directory, environment, stdio, and exit code.paniolo queue host recover reconciles it explicitly; nothing grants overlapping work because a timeout elapsed.paniolo queue to keep their heavy gates from colliding.Keep the machine for one gate at a time.
paniolo queue run --queue heavy-load -- <command>