Ephemeral Dev Environments
On-demand Fly Machines for sandboxed code execution, autonomous task queues, and burst processing. Agents get their own isolated environments that spin up in seconds and vanish when done.
What is Forge Compute?
Forge Compute gives your agents isolated development environments where they can execute code, run tools, and process data without affecting your production systems. Each environment is an ephemeral Fly Machine that spins up on demand, runs the task, and is destroyed afterward.
This solves the fundamental problem of letting AI agents run code safely. The sandbox enforces CPU, memory, disk, and network limits. Cost guardrails prevent runaway spending. Auth bridging ensures the agent operates under the correct user permissions. And the queued autonomy system lets agents work through task backlogs while you are away, with escalation policies that know when to stop and ask for help.
Core Infrastructure
The building blocks that make ephemeral compute environments practical for agent workloads at any scale.
Ephemeral Fly Machines
Each compute session spins up a dedicated Fly Machine with a full development environment. The machine lives only as long as the task requires, then is destroyed. No persistent infrastructure to manage or pay for when idle.
Warm Pool Management
Cold-starting a machine takes seconds. For latency-sensitive workloads, Forge Compute maintains a warm pool of pre-provisioned machines. When a task arrives, it grabs a warm machine instantly instead of waiting for provisioning.
Auth Bridging
The calling user's subscription tier and API credentials are securely forwarded into the ephemeral machine. Agents running inside the machine inherit permissions from the user who triggered the task, with costs metered back to their account.
Resource-Limited Sandbox
Every machine runs inside strict resource boundaries. CPU cores, memory allocation, disk space, network bandwidth, and execution time are all capped per the user's subscription tier. Runaway processes are terminated automatically.
Queued Autonomy
Tasks queue up in a persistent task queue and execute when resources are available. Agents can work through backlogs autonomously, with escalation policies that determine when to pause and ask for human input.
Burst Execution
When you reconnect after a period of autonomous work, Forge Compute triggers burst execution -- processing queued tasks at higher concurrency to catch up. File-level conflict resolution handles any overlapping changes.
Sandbox Resource Limits
Every ephemeral machine operates within strict, configurable boundaries. Limits scale with subscription tier and can be overridden per-task for specific workloads.
CPU Limits
Each machine gets a defined number of CPU cores based on subscription tier. Free tier gets shared vCPUs. Pro and above get dedicated cores with guaranteed performance.
Memory Caps
RAM allocation scales with tier. Processes that exceed their memory cap are OOM-killed gracefully, with partial results preserved and returned to the calling agent.
Disk Quotas
Ephemeral disk space is allocated per session. Large file operations are supported within quota. When the session ends, the disk is wiped -- no data persists between sessions unless explicitly synced to project snapshots.
Network Policies
Outbound network access is controlled per agent. Agents can be restricted to specific domains, blocked from internet access entirely, or given full outbound connectivity depending on the task's security requirements.
Execution Time
Maximum execution time per task is enforced. Long-running tasks receive warnings before timeout and can checkpoint their progress. Timed-out tasks return partial results and can be resumed in a new session.
Cost Guardrails
Monthly budget caps prevent runaway spending. The system tracks cumulative compute cost in real time and blocks new machine provisioning when the budget is exhausted, with configurable warning thresholds at 50%, 75%, and 90%.
Queued Autonomy
Let agents work through task queues autonomously while you are away. Escalation policies ensure they pause when they should, and burst execution catches up when you return.
Persistent Task Queue
Tasks are stored in a durable queue backed by the database. Queue entries include task definitions, priority levels, dependency chains, and estimated costs. The queue survives restarts and can be inspected at any time.
Escalation Policies
Define rules for when agents should stop working autonomously and escalate to a human. Configurable thresholds for cost, number of tasks, error rates, and uncertainty levels. When a threshold is hit, the queue pauses and notifies you.
Project Snapshot Sync
Before autonomous execution begins, the current project state is snapshotted. When you reconnect, the system diffs the snapshot against the current state and presents changes for review before merging back.
Conflict Resolution
When autonomous work and manual edits overlap, file-level conflict resolution kicks in. The system identifies conflicts, presents diffs, and either auto-resolves non-overlapping changes or asks for your input on true conflicts.
Run Code Safely
Learn how to provision ephemeral environments, configure sandbox limits, and set up queued autonomy for your agents.