Turn sandboxes into autonomous employees

The recipe

You'd never onboard a new hire with one paragraph of instructions and no laptop. A specialized agent is the same: it needs an environment, not just a prompt. Building one is five ingredients and two multipliers:

• A workspace — its own sandbox.
• Tools — the libraries and CLIs of its trade, really installed.
• System access — the services it operates, wired in as capabilities.
• Curated context — the skills, runbooks, and house style of the job.
• Work + supervision — real tasks, reviewed as diffs.
• then autonomy (events wake it) and scale (a team of them).

1 · Give it a workspace

Start a sandbox and name it for the role — release-captain, support-triager, migrations. That dedicated sandbox is the agent: everything you add below scopes to it. The free plan includes one sandbox; Pro runs as many as you have roles, so a team never shares an environment. See Quickstart to bring one up.

2 · Install its tools

Tell the agent what the job runs on and let it propose an environment layer — a database client, a headless browser, a language toolchain, whatever the work needs. You approve the layer and it's baked into the image and genuinely installed, not described in a prompt. The mechanics are in Docker setup; the rule is that an agent can never change its own environment without your sign-off.

3 · Connect its systems

Add the services the role touches as capabilities — GitHub, a database, Sentry, Stripe, an SSH host, an MCP server, or your own internal tools — in a click each. The credential is stored inside the sandbox and never shown back to you or written into the workspace files; the agent operates the service from chat. A capability that ships a skill also teaches the agent how to use it the same turn.

4 · Curate its context

Specialization lives here. Load only what this one job needs, and load it every turn:

• Skills — short procedures the agent loads on demand (.claude/skills).
• House style + project rules — a CLAUDE.md the agent reads each turn.
• Repos, docs, and runbooks — the material the role actually works from, in the workspace.
• Agent plugins — a packaged bundle of skills, subagents, and hooks for a whole discipline.

Curated context is what makes the output yours instead of the model's average — the single biggest lever on quality.

5 · Give it work, keep the wheel

Hand it a real task. In interactive chat the agent starts in plan mode — it proposes, you approve — and every change it makes is a diff you commit or discard. Loosen or tighten that per conversation. Environment rebuilds always wait for your explicit approval. This is how you trust an agent with real access without losing the ability to say no.

6 · Make it autonomous

An employee doesn't wait to be told to start. Automations wake the agent on the events that matter:

• Schedules — a nightly cleanup, a morning report, a weekly release.
• Webhooks — a push, a Sentry alert, a Stripe payment.
• Listeners — a new email or a Discord message.

Each wake is a fresh, specialized run that leaves a transcript, and you can gate it behind a guard command so it only proceeds when a condition holds. The agent keeps working between your check-ins.

7 · Grow a team

Once one role is specialized, the next is cheap: give it its own sandbox and repeat. Roles can hand work down the line, too — an agent's run can fire the webhook that wakes another, so triage passes to a fixer and a fixer passes to a reviewer.

That's the whole arc: a sandbox becomes a specialized agent, a specialized agent becomes an autonomous employee, and a handful of them become a team — all on hardware you own, driven from any browser.