Your Coding Agent Needs a Sidekick
Monitors, gardener agents, sidekick guidance, and experimental handoffs for long-running coding agents.
The tweet that kicked this off was simple:
Why don't we give codex a change_effort tool?
— Josh (@JoshPurtell) June 28, 2026
If I'm running a 12 hour /goal session, it'd be nice to get xhigh on core code, high on evals/testing, medium on running tests, and low on documentation.
Surely it's not that hard for the model to make those judgements?
That is a good request. It is also only the first knob. In a long coding session, the human should not have to live inside the transcript just to know whether the agent should think harder, run tests, ask for review, or stop before losing state.
The bigger primitive is a sidekick: an auxiliary agent that watches the core worker, summarizes progress for the operator, and sometimes does independent context work before the worker acts.
The Conversation
Long coding sessions hit three walls at once:
- Context pressure - the worker model runs out of room; compaction becomes a hidden product decision.
- Operator overload - hundreds of tool calls make the transcript unusable as the default status surface.
- Steering fatigue - the human is still acting as scheduler, approval router, and status reader.
Devin Fusion is the cleanest public version of the sidekick idea: a main frontier agent plus a cheaper sidekick model that can gather context and take delegated work. OpenAI's monitoring writeup shows the safety version: a monitor reviews agent behavior and escalates when actions stop matching intent or policy. Claude Code auto mode shows the approval-routing version: routine actions can proceed, risky ones still wake the human.
Stack starts from the operator question:
What should the human see while the agent is working, and what should another model be allowed to do on the worker's behalf?
Stack's Answer
Stack treats sidekicks as first-class actors around the worker:
Edits code, runs tools, executes evals, and owns the primary task loop.
One substrate for worker actions, monitor summaries, and handoff milestones.
Summarizes progress, routes approvals, flags drift, and can request handoff.
Queues operator work, handles maintenance, and can force an auditable boundary.
The default Stack view is calm: monitor updates like "working on", "stuck on",
"progress", and "next". Pressing a opens Agent view, where the same timeline
expands into the full worker and monitor tape. There is no private monitor store;
the UI and programmatic consumers read the same event substrate.
That matters because a useful monitor is not a narrator inventing a second version of the run. It is an actor with a different job: keep the operator abreast of real progress while preserving auditability when the full tape matters.
Stack Aux makes that cheap enough to run continuously. Aux inference is exposed
for roles like monitor and gardener, while worker and primary requests are
rejected. The TUI labels those monitor passes as aux, and the Synth usage panel
shows the promo pool and org-day remaining budget alongside normal usage.
Sidekick Or Handoff?
These are different tools.
A sidekick helps without taking ownership. It can explore code, summarize state, propose a plan, or identify likely failure modes. The primary worker still decides what to implement.
A handoff moves ownership across a hard boundary. The current segment seals a packet, the operator or policy approves it, and the successor starts from that packet.
Worker runs until policy or operator asks for a boundary.
Summary, goal state, changed files, checks, parent config.
Successor bootstraps from artifacts only, not parent stdout replay.
The invariant is important: the successor prompt is built from artifact payloads, not a replay of parent stdout. That is the product distinction from ordinary compaction. A handoff is not a smaller transcript. It is a reviewable boundary with a parent config, child config, goal state, changed files, checks, and a durable record of what crossed.
Four Experiments
The honest result from Harbor TicTacToe dogfood is split: handoffs lost, sidekicks helped, and subagents are the next result to publish.
The best sidekick-guided run scored 0.2932, the best Harbor score in this
sequence. It is not a victory lap. Two sidekick reps were invalid because the
DeepSeek artifact came back malformed or truncated. The primary workers still ran
with fallback guidance and the candidate verifiers succeeded, so the failure was
sidekick artifact generation, not Harbor service startup. Counting invalid
sidekick runs as zero, the all-run sidekick reward mean was 0.1500.
This is why the feature ships with an experimental label. Stack can seal artifacts, route successors, capture per-segment usage, separate invalid runs, and keep the operator informed. But handoff routing is not trivial. The right auxiliary pattern has to be learned, not guessed. The implementation-subagent arm made real ad hoc delegation choices, but the result was negative: more work crossed the boundary, and the frontier got worse.
Cloud SMR is why we still believe in artifact-backed continuity. Managed research runs already rely on explicit receipts, recovery boundaries, and continuation artifacts. Local Stack is a harder product surface because it is interactive, cheaper, and closer to the raw coding loop.
What Comes Next
MAPO is the follow-up, not a hidden claim in this post.
The offline version should optimize auxiliary protocols on GameBench dev splits: no sidekick, sidekick, handoff, effort level, artifact format, timing, and acceptance preflight. The online version can adapt Stack policy from live receipts once a candidate is safe enough to graduate.
That is the punchline: handoffs are available but experimental; sidekicks look more promising for this benchmark; OSS MAPO is how we intend to make the choice consistent instead of hand-written.
Stack · public alpha
Run agents with sidekicks, receipts, and visible progress.
Stack is the local-first cockpit for long agent sessions: watch progress, capture run evidence, and work with monitors, sidekicks, handoffs, and GameBench receipts. Open source, installable today.
Install (macOS)
curl -fsSL https://stack.usesynth.ai/install.sh | sh
agent + sidekickOpen source (MIT), public alpha. macOS (Apple Silicon) today; more platforms and Homebrew are on the way.
Core Stack is local-first. A Synth account is only needed for hosted features, API keys, and metered auxiliary inference.
Prefer git? git clone https://github.com/synth-laboratories/stack.git && cd stack && make install