Runtime — Secure Execution Infrastructure for AI Agents

Inspiration

AI agents are getting increasingly capable of writing code, automating workflows, and interacting with software. But there's still a fundamental problem: where does all that code actually run?

Giving an AI model the ability to generate code is one thing. Giving it a secure, reliable environment to execute that code is an entirely different challenge.

Developers often find themselves managing containers, execution environments, infrastructure costs, and security boundaries instead of building their agents.

We built Runtime to solve that infrastructure problem.

What it does

Runtime provides isolated cloud sandboxes where AI agents can safely execute code, access files, run processes, and perform development tasks.

Each sandbox runs in its own Firecracker microVM with an isolated Linux environment.

Runtime is designed around three principles:

• Isolation: Execute agent-generated code inside an isolated environment instead of the application's host.
• Developer experience: Create, execute, pause, resume, and manage sandboxes through an API, SDK, or CLI.
• Execution economics: Use CPU-based pricing and lifecycle controls to reduce unnecessary infrastructure spending.

Our broader vision is to build an execution cloud specifically designed for autonomous software.

How we built it

Runtime combines lightweight virtual-machine isolation with a developer-focused execution API.

The platform uses Firecracker microVMs to provide isolated Linux environments. Developers interact with them using Runtime's SDKs, REST API, and CLI.

Sandboxes support command execution, filesystem operations, process management, network controls, persistent environments, and lifecycle management.

Runtime can integrate with existing agent frameworks, allowing developers to keep their model and orchestration logic while using Runtime as the execution backend.

How Apertus fits in

For Hack Apertus, our proposed integration connects the Apertus open-source language model with Runtime's sandbox execution layer.

Apertus generates code or determines an execution task. A controller creates an isolated Runtime sandbox, executes the task, captures the result, and returns the output to the agent.

This creates a reusable architecture for experimenting with open models that need to interact with real software.

The Apertus-specific integration and demonstration must be implemented and tested before this project is submitted as complete.

Challenges

Building infrastructure for autonomous agents presents several challenges:

• Isolating code that may be unpredictable or untrusted.
• Managing sandbox lifecycles without unnecessary compute overhead.
• Maintaining useful execution state across longer-running tasks.
• Making infrastructure simple enough for individual developers to adopt.
• Balancing execution speed, security controls, and cost.

What we learned

One of the most important lessons from building Runtime is that AI infrastructure needs to be designed around how autonomous software behaves.

Traditional infrastructure assumes applications follow relatively predictable execution patterns. Agents may execute code intermittently, create temporary environments, wait for external events, and resume work later.

That changes how execution infrastructure should be designed, priced, and managed.

What's next

Our long-term vision is to build an agent-native cloud that brings together secure execution, persistence, storage, networking, orchestration, and eventually inference.

For the Apertus integration, the next milestone is a reproducible, open-source demonstration of an Apertus-powered agent executing code in a Runtime sandbox.

We're building Runtime because the next generation of software shouldn't need to reinvent its execution infrastructure.

Website: https://withruntime.com

Built With

• ai-agents
• cloud-infrastructure
• code-execution
• firecracker
• linux
• microvms
• python
• rest-api
• sandboxing
• sdk
• typescript
• ubuntu