Hosted Agent Infrastructure
Design remote sandbox infrastructure for fast, persistent, collaborative background coding agents.
The material describes sandbox isolation, resource limits, token separation, snapshots, and user attribution. However, examples interpolate tokens and user identity into shell commands, place a user's GitHub token in an exposed identity object, and default to `git reset --hard origin/main`. Explicit user confirmation, robust secret handling, least-privilege validation, and rollback protection are incomplete. The destructive synchronization default lacks consent or recovery, creating an unresolved red-line risk and warranting blocked status.
The architecture covers lifecycle, warm pools, synchronization, snapshots, and failure topics, but the script leaves many key methods as `pass`; the Modal, API, and client examples also depend on undefined components and lack robust failure and race handling. The file labels the code as pseudocode, and static evidence cannot establish runnable key paths, so the score is conservatively capped below 10.
Activation scenarios, non-fit boundaries, and ownership relative to adjacent skills are comparatively clear. The scope covers background coding, remote sandboxes, multi-client interfaces, and multiplayer sessions. Inputs, output contracts, platform/network fit, Chinese-language support, and mainland-China reachability are insufficiently specified, limiting trigger precision and environment confidence.
The skill provides directory structure, layered guidance, checklists, examples, gotchas, references, license metadata, creation/update dates, and a version. Deductions reflect unclear maintenance ownership and update path, incomplete dependency/version assumptions, and inconsistent skill-count claims in the repository README.
The material offers useful architecture decomposition, lifecycle checklists, and implementation patterns for hosted-agent systems, with broad topic coverage. The main script is not executable as provided, several infrastructure methods are unimplemented, and security and consistency issues require substantial engineering work. Static review cannot verify directly usable representative results, so effectiveness remains near the conservative happy-path level.
The skill includes references, code examples, metadata, and repository CI/test signals. The supplied CI primarily validates the researcher system and other examples, not this skill's key paths; no committed tests or third-party execution evidence cover `sandbox_manager.py`. The evidence is auditable but thinly reproducible, so the score is capped at 4.
- Do not adopt the example's `git reset --hard` directly; isolate uncommitted state, obtain explicit authorization, and preserve recoverable snapshots.
- Do not interpolate tokens into shell commands or retain them in long-lived identity objects; use short-lived, scoped tokens with secure injection and log redaction.
- Implement and test the script's `pass` methods, race handling, exception paths, and infrastructure interfaces before deployment.
- The supplied material contains no skill-specific key-path tests or third-party execution evidence.
What does this skill do, and when should you use it?
This skill is for hosted and background agents that run in remote sandboxes instead of on local machines. It covers sandbox lifecycle management, prebuilt images, warm pools, snapshot restoration, per-session isolation, real-time streaming, and multiplayer collaboration. It also addresses server-first agent frameworks, self-spawned sessions, user-attributed GitHub commits, and Slack, web, and Chrome extension clients. It fits teams building production remote coding-agent infrastructure, but not tasks limited to agent topology, tool contracts, or local filesystem state.
Provides design guidance and checklists for planning sandbox startup, synchronization, read/write gating, snapshots, restoration, timeouts, and teardown; designing prebuilt environment images and warm pools containing repositories, dependencies, build results, and caches; structuring API-layer session isolation, WebSocket events, cross-client synchronization, and multiplayer authorship; and configuring Git identity, pushing branches, and creating pull requests through an API using the prompting user's GitHub token. The SKILL.md does not include a directly runnable implementation.
- An infrastructure engineer designing remote execution for background coding agents that run independently of user devices.
- A platform team building prebuilt images and warm sandbox pools to reduce cold-start latency for busy repositories.
- A product team synchronizing agent sessions across Slack, web, Chrome extension, and VS Code clients.
- An agent-framework team enabling agents to start parallel sessions, check their status, and continue the main task.
- A development organization implementing multiplayer debugging, code review, or live QA sessions.
- A security-conscious team creating branches and pull requests under the prompting user's GitHub identity.
What are this skill's strengths and limitations?
- Covers the hosted runtime boundary from sandbox infrastructure through APIs, clients, authentication, and multiplayer support.
- Includes concrete patterns for prebuilt images, warm pools, snapshots, read/write synchronization, and artifact extraction.
- Identifies operational failure modes including cold starts, token expiration, state loss, runaway costs, and missing Git configuration.
- Preserves user attribution and PR auditability, which suits human-reviewed coding workflows.
- It is primarily design guidance and workflow examples, not a deployable sandbox or API implementation.
- Teams must choose and integrate the remote sandbox, GitHub authentication, storage, WebSocket, and client technologies.
- The SKILL.md provides no test suite or validated implementation for a specific platform.
- The recommendations assume relatively sophisticated infrastructure needs such as concurrency, background execution, and collaboration.
How do you install this skill?
Clone the repository:
git clone https://github.com/muratcankoylan/Agent-Skills-for-Context-Engineering.gitCopy the complete skills/hosted-agents directory into the host's skills directory, for example:
mkdir -p .codex/skills
cp -R Agent-Skills-for-Context-Engineering/skills/hosted-agents .codex/skillsThe folder can also be copied to .claude/skills/ or .cursor/skills/. Preserve the directory layout; do not flatten the skill into a standalone SKILL.md file.
How do you use this skill?
Activate it for hosted-agent infrastructure work, for example: "Design a background coding-agent system with warm sandboxes, session snapshots, real-time streaming, and user-authored GitHub pull requests." Before implementation, decide the sandbox lifecycle, image rebuild policy, read/write synchronization, per-session isolation, authentication ownership, output extraction, and budget and teardown rules. The skill supplies architecture guidance; the concrete sandbox provider, API, and tool contracts must be designed separately.
How does this skill compare with similar options?
The skill contrasts hosted execution with local-machine constraints and names Modal Sandboxes, Cloudflare Durable Objects, Ramp's background-agent infrastructure, and OpenCode as external references. It does not provide a systematic product comparison or a final vendor-selection recommendation.