Don't give your agents a sandbox. Give them the ocean.

Persistent computer with ephemeral compute. Provision what they need, run what they want, release everything when they're done.

Request access How it works

Agent compute should feel like magic.

Your agent asks for what the task needs, watches it appear, and lets it vanish when the work is done.

Forget about infraNo servers to name, patch or keep warm for your agents.
Scale upFrom a one-line script to a full build, sized for each task.
Scale down to zeroWhen the task ends, nothing keeps running and nothing keeps billing.

Your agents are only as capable as the environments you give them.

Preconfigured Environments shaped before the task exists.

Reserved Capacity held idle, paid for, waiting for work.

Missing Dependencies nobody installed.

Infra first Setup work before the real task can start.

The sandbox is a fishbowl.

Its limits are fixed in advance. Your agent can only do what fits inside the bowl you gave it.

In practice: a sandbox sized before the task exists.

Shark Magic is buckets of any size.

A small container for a script, a large one for a build, several for parallel work.

In practice: isolated environments with their own CPU, RAM and storage, provisioned per task.

The ocean is on demand.

Nothing reserved and idle. Take resources when you need them, release them when you're done.

In practice: a shared pool of compute. Released capacity returns to it.

Any environment. Any size. As long as you need it.

Each task gets its own isolated environment, sized to the job. When the task ends, so does the environment.

$ npm run build

CPU: 8vCPU
Memory: 16GB
Disk: 40GB
Lifetime: Until exit

One task. One environment.One lifetime.

Provision.

The agent asks for what the task needs. An isolated environment, sized to it, appears.

Execute.

Run code, install dependencies, use tools, delegate subtasks. All of it inside its own walls.

Release.

Everything is torn down. The capacity flows back to the pool. No idle machines between tasks.

What matters persists. Compute is ephemeral.

Your agent, its state, its files and its objects stay put from task to task. The compute that runs them comes and goes.

Persistent

AgentWho it is and how it works.

StateWhat it remembers between tasks.

FilesWhat it wrote and will need again.

ObjectsOutputs, artifacts and data.

EphemeralRunningReleased

Running compute Appears for the task. Gone when it ends.

Nothing to set up. Nothing to tear down.

Your agent asks for a bucket, works inside it and lets it go. Isolation, scheduling and cleanup happen on our side, mid-task, with no human wiring anything first.

Ready in: [COLD START TIME]
Largest bucket: [MAX vCPU / RAM]
Billing: Per [BILLING UNIT], stops at release

Give them the ocean.

The agent decides. Shark Magic handles the rest.

Ephemeral containers already exist. The difference is who drives them: here the agent itself requests, composes and releases environments, mid-task, with no one setting up infrastructure first.