Why we’re launching LithosBox
ultra-fast sandboxes for low-latency agents

Today we’re launching LithosBox in public preview, with two weeks of free usage to help you get started. LithosBox provides ultra-low-latency sandboxes that give agents Git-like control over their execution environments. Agents can checkpoint progress, explore alternatives in parallel, inspect what changed, and restore an earlier state without starting over. All of this comes with the gold-standard isolation guarantees of a microVM-based platform.

The LithosAI team has been working to meet demand for more models available via our public API. So why did we spend time building something else?

Fast inference is only part of the agent loop. An agent also needs to execute tools, inspect results, and recover when an approach fails. As inference gets faster, managing the environment becomes a larger part of the time it takes to finish a task.

We built LithosBox so the environment can keep up.

See it in action: LithosBox x Doom

Our Doom demo shows what happens when ultra-fast sandboxes meet ultra-low-latency inference. Together, LithosBox and LithosEngine deliver a 5x speedup over the best existing solution in this demo.

This is the combined benefit of faster inference and faster sandbox operations. Below, we explain the environment capabilities behind LithosBox and measure its sandbox performance separately.

Git-like control over a running environment

Agents do not always work in a straight line. They try an approach, inspect the outcome, and sometimes back up to try something else. Their environments should make that exploration easy.

Git provides this flexibility for source code. Agents need similar control over a running environment. Instead of tracking only source files, LithosBox lets agents checkpoint and branch the live state inside a sandbox, including its filesystem, running processes, and memory.

Three operations make this possible:

• Snapshot: Capture the sandbox’s current running state
• Branch: Create independent environments from the same checkpoint to explore alternatives in parallel
• Restore: Return the sandbox to an earlier checkpoint when an approach fails

Consider a coding agent attempting a difficult fix. These tools allow it to checkpoint its environment, try multiple patches in separate branches, run tests, and inspect what each attempt changed. If neither works, it can restore the checkpoint and try again without manually undoing changes or reconstructing its environment.

The environment becomes something the agent can explore, not just somewhere it executes commands.

Built for the agent’s inner loop

Fast startup matters, but it is only the beginning (no pun intended). An agent may snapshot, branch, and restore repeatedly throughout a task. If these operations are not highly performant, their costs dominate execution time.

The challenge is not simply supporting these operations. It is making them inexpensive enough to use routinely.

For long-running agents, cheap checkpoints make it practical to preserve progress more frequently. When an attempt fails, the agent can return to a recent state rather than reconstructing hours of work.

Long-running agents also spend time waiting for inference, human input, or a slow tool response. During those gaps, their environments should be able to sleep and resume quickly, preserving the running state without keeping the sandbox continuously active.

LithosBox is built for this execution pattern: frequent checkpoints, parallel exploration, and low-overhead transitions between working and waiting.

How LithosBox compares

To understand the impact on the agent’s execution loop, we compared LithosBox with two major sandbox providers by focusing on the operations an agent uses to preserve progress, explore alternatives, and recover.

* Only LithosBox brings back running processes, others are files only.

Try LithosBox in public preview

Faster agents start with faster inference and faster environments. LithosBox is now in public preview, and we’re offering two weeks of free LithosBox usage so you can experience the difference.

Get started at console.lithosai.cloud.