Build Scalable, Collaborative Coding Agents

Covers architecture patterns for hosted agents running in remote sandboxed environments rather than locally, so session speed is limited only by model provider time-to-first-token - all infrastructure setup happens before the user's session starts. Its three layers: sandbox infrastructure (pre-building environment images on a cadence like every 30 minutes, each with the repo cloned, dependencies installed, and caches warmed from one build and test run; filesystem snapshots at build, session-end, and pre-exit points for instant restoration; a warm pool of pre-warmed sandboxes that starts warming as soon as a user begins typing), an API layer (per-session state isolation via a dedicated database like SQLite per session; WebSocket streaming with hibernation to cut idle compute cost; a single state system synchronized across chat, Slack, Chrome extension, web, and VS Code clients), and client interfaces across those same surfaces.

It recommends a server-first agent framework - TUI and desktop apps as thin clients, so logic isn't duplicated - with code as its own source of truth, preventing the agent from hallucinating about its own capabilities, and a plugin system that can listen to, block, or modify tool-execution events. Speed optimizations: predictive warm-up starting the moment a user begins typing, parallel file reads that don't wait for git sync to complete (only writes are blocked until sync finishes), and pushing as much work as possible into the image-build step since build time is invisible to users. It also covers self-spawning agents - tools to start, check in on, and continue past sub-sessions for parallel research or splitting a large change into smaller PRs - and authentication using the prompting user's own GitHub token for commits and PRs, never the app's identity, so users can't approve their own changes - even though the initial repository clone during image build uses a GitHub app installation token rather than any specific user's credentials, since that step isn't tied to a person yet.

Multiplayer support - useful for teaching non-engineers, live QA sessions, real-time PR review, and collaborative debugging - becomes nearly free once the session-state model isn't tied to a single author: each prompt carries its own authorship info, code changes attribute to the prompting user, and a session link enables instant collaboration. Handling messages sent while the agent is mid-execution comes down to a queue-versus-insert choice; queueing is simpler and lets users queue up next-step thoughts while the agent keeps working. The web client's stats page tracks sessions resulting in merged PRs as the primary success metric, alongside a live "humans prompting" count in the last five minutes, and the Chrome extension is distributed via managed device policy specifically to bypass the Chrome Web Store review process.

Use it when building background coding agents independent of user devices, designing sandboxed execution environments, implementing multiplayer sessions with shared state, building multi-client interfaces (Slack, web, Chrome extension), or scaling agent infrastructure past local-machine limits.

Input: an agent architecture needing to scale past a single local machine or support multiple simultaneous users and clients. Output: a sandbox image-build and warm-pool strategy, a per-session-isolated API layer with real-time streaming, and client implementations - a Slack bot, a web interface with a hosted VS Code view, and a Chrome extension using DOM and React-internals extraction instead of screenshots to save tokens.

Builds on sibling patterns multi-agent-patterns (self-spawning agents follow supervisor patterns), tool-design (agent-spawning and status-check tools), context-optimization, and filesystem-context (session state and artifacts), citing Ramp's background-agent writeup, Modal Sandboxes, Cloudflare Durable Objects, and OpenCode as external prior art.

Teams building hosted, multi-user coding-agent infrastructure who need concrete sandbox, API, and client-architecture patterns rather than ad hoc scaling decisions.