The agent-first cloud: why we built Managed Agents

Compute (EC2) opened the front door to the first generation cloud. Agents need something different: compute, inference, and data working as one. We built the cloud that delivers all three as one simple, intuitive developer experience for AI-natives.

Every era of the cloud has its own unit of work.

For the last twenty years, that unit was the virtual machine hour. Customers came for the compute, paid by the hour whether it was working or waiting, and every service that followed existed to drive more of it. Fourteen years ago our answer was a $5 Droplet, and a generation built on it because it was simple, and well-packaged.

Agents require that same simplicity, with a workload that no longer fits inside a VM.

An AI agent doesn’t run like a web server:

• It thinks in tokens and acts in short bursts of compute. Then it waits—on reasoning from a model, a response from a tool, or approval from a human.

• It might need four copies of itself this afternoon and none overnight. By tomorrow morning, it might need its working state back—on a different device, picked up by a different person, or another agent.

• Its natural units are tokens consumed, microVM-seconds of real execution, and state that outlives the session.

Trading VM-hours for tokens and microVM-seconds sounds like a small shift. It isn’t. It changes how you architect a cloud, how you secure it, and how you bill for it.

This week, DigitalOcean Managed Agents entered public preview: sandbox, inference, and data as one runtime, built for tokens and bursty compute, on top of the Droplets, databases, and networking that already work.

Why now: the workload changed faster than the infrastructure

That gap didn’t open on its own. Three trends pulled the workload ahead of the infrastructure built to run it, and drove our decision to invest in this platform:

• Tokens represent thought. An agentic task burns 5 to 30x the tokens of a chat interaction, and one ticket can fan out into a dozen model calls, a web search, a database query, and a pull request. Software economics are shifting from requests served to work completed, and completed work is paid for in tokens.

• Builders are choosing open intelligence. Open-weight models now carry the majority of agent token load. Once a product finds its market, the team moves to open weights both to control unit costs and to actually own their intelligence (instead of renting it).

• Teams building and running agents are drowning in complexity. After talking to dozens of founders and CTOs, I hear the same stack described differently: a harness on a laptop, sandboxes from one startup, inference from two more, storage at a hyperscaler, search from a sixth vendor—all held together with glue code. Nobody can accurately pinpoint the cost of a single run, how to secure it, or how to operate it at scale.

Managed Agents: everything an agent needs, tightly integrated

Managed Agents isn’t a sandbox product with add-ons. It’s where the three things an agent is made of finally live together:

• The sandbox gives it hands: an isolated machine to execute code, drive a browser, and produce artifacts.

• Inference gives it a brain: open-weight and frontier models served right next to the sandbox.

• The data layer gives it memory: workspace state, checkpoints, databases, and retrieval that outlive the session.

Every handoff between sandbox, inference, and data is a function call, not a WAN hop.

Managed Agents: bring your agent and your spec; DigitalOcean runs the sandbox, the tools, the models, and the telemetry.

Three factors make that real:

DigitalOcean Harness Runtime is durable execution

• Every session gets its own Firecracker microVM: its own kernel, hardware-level isolation, sub-second starts, and ~300ms resumes.

• Sessions outlive your laptop. Close the lid, and the agent finishes in the cloud. Reattach from your phone or hand the live session to a teammate. Checkpoint a warmed-up session, fork it four ways, and keep the winner.

• Bring Claude Code, Codex CLI, OpenCode, Hermes, LangGraph, or package your own authorized agent as a standard OCI image.

Action Gateway is governed action

• One managed MCP endpoint to 16,000+ tools across 500+ providers, from GitHub and Stripe to your own MCP servers. This replaces the credential, retry, and permission plumbing you’d otherwise own.

• It finds the right tool for your agent’s intent instead of dumping a catalog into the context window, repairs malformed calls, handles rate limits, and gates sensitive actions on human approval.

• Importantly, credentials are brokered at execution time and never reach the model, the prompt, or the sandbox. The agent never sees the key.

Agent pricing finally matches the workload

Agents are bursty: a compile here, a test run there, with long waits on tokens and approvals in between. Most offerings provision a VM and bill it from boot to shutdown. DigitalOcean bills CPU per second of actual use at $0.044 per vCPU-hour and memory at $0.0095 per GB-hour, with snapshots at $0.05 per GiB-month.

How it’s different: one platform instead of six vendors

With no other choice, teams settled with stitching five or six vendors together. Six vendors means fifteen seams: each one is an integration you build, a credential you store, and a place where a trace dies. As a result, securing and operating that mesh becomes your team’s second job. Point solutions are excellent but partial, because most sandbox companies don’t run inference, and model companies don’t manage agent memory or observability. Hyperscalers offer everything, but it’s metered as a dozen line items with enterprise-grade complexity to match.

Fifteen seams to secure and operate, or six capabilities pre-wired around your agent.

Agents are the first workload that exercises every layer of a cloud in a single loop: they think, they act on real systems, they remember, and they improve. A cohesive platform designs for the loop itself—one architecture, not a stack of bundled parts.

Here’s what a cohesive architecture results in:

• Accelerated development. Primitives arrive pre-integrated: the sandbox reaches the model router, the gateway reaches your tools, the workspace syncs to persistent storage. Your first session is one CLI command and a spec file.

• Minimized latency. The sandbox, models, and data share a platform (and often a data center), so the loop skips the cross-vendor network tax, and cache-aware routing keeps warm context next to the model serving it.

• Secure by default. Hardware-virtualized isolation per session, credentials brokered per call, governed egress, and human sign-off on sensitive actions. SSO, MFA, role-based access, and audit logs are standard features, not enterprise-tier add-ons.

• Streamlined observability and operations. One stream holds runtime traces, tool calls, model calls, step timings, and cost. Usage lands on one transparent statement.

• Open & heterogeneous architecture. Choose your harness, framework, or model: self-hosted open weights like Kimi K3 and GLM 5.3, pay-as-you-go frontier models, or your own key, with custom images and your own MCP servers alongside DigitalOcean’s.

Durable economics: the full-stack advantage

An agent idles through most of its session, waiting on tokens, tools, and humans. That’s the whole story of agent economics. If you’re billed on provisioned capacity, you’re paying for the waiting. DigitalOcean bills on active CPU and peak memory, so you pay for the work, not the wait…

The same hour, two meters: provisioned billing charges the whole box, active billing charges the bursts. The waits in between cost $0 with active CPU billing. Illustrative session at public preview list pricing.

The infrastructure cost under a typical run rounds to cents; the tokens are what drives the spend. For example, a default 2 vCPU, 4 GB session costs $0.126 an hour fully allocated, but at a typical 25% activity level it costs about $0.060. While the agent waits, the CPU line is zero—auto-pause catches idle sessions.

You help control the spend through routing. The DigitalOcean Inference Router can match each step to the model it actually needs: routine steps go to hosted open weights like Kimi K3 and GLM 5.3, complex reasoning goes to a frontier model pay-as-you-go, or you can route through your own key.

Co-locating inference and data:where the value compounds

Warm context stays next to the model, so fewer tokens get recomputed. Retrieval reads from the same lakehouse your agent writes to, keeping context short and cited, not stale and copied. Using checkpoints means work is never redone unnecessarily, and every run’s telemetry sharpens the next one. On a stitched stack, each of those handoffs costs an egress fee and needs an integration someone maintains. Running on DigitalOcean Managed Agents, it’s a straightforward function call.

Where the economics are heading: cheaper intelligence, bigger workloads

Today infrastructure is roughly 3 to 8% of a typical run’s cost, and the rest is tokens—a mix that will shift as the cost of intelligence keeps falling. But smarter models don’t shrink an agent’s compute footprint—they multiply it with more steps, more tool calls, and more parallel forks per outcome. Play that forward and compute rises steadily as a share of every run, even as the run itself gets cheaper.

Who Managed Agents are for

Three types of teams are building with Managed Agents:

• Companies whose product is an agent: DigitalOcean operates the layer your customers never see: per-tenant microVM isolation, credential brokering, and golden environment templates you fork per customer in milliseconds. These Managed Agent builders include companies like OpenHands and Amplitude.

• Teams automating real work: Qencode built a support-triage agent that reads every request across Slack, email, and Intercom, files or updates the corresponding Jira ticket, and flags low-confidence cases for a human. Early results include winning back an estimated 4 to 8 hours a week, with almost instantaneous response times (down from hours).

• AI-natives already running coding agents: Do Claude Code, Codex CLI, or OpenCode sessions live on laptops and pet VMs around your organization? Managed Agents is their new durable home, with parallel sessions, shared state, checkpoint-and-fork, and governed tool access—all with no infrastructure to manage.

Agents that learn from their own work (coming soon)

Running agents is half the problem. Teaching them to learn from their own work is the other half—that’s the data and learning layer rolling out over the coming weeks.

It’s the flywheel working behind the agent. DigitalOcean Signals will watch production trajectories and surfaces the failure fingerprint of an agent confusing its users in terms of corrections, repeated queries, handoffs to a human, and abandonment. Evaluations turn each failure into a regression test scored by an LLM judge.

In an internal demo, an optimized support agent went from failing a monetary accuracy check to passing it while using 99% fewer input tokens, at roughly a third lower latency.

The agent loop: think, act, remember, improve. Every step runs on one platform, so every handoff is a function call, not a cross-vendor hop.

DigitalOcean Simulations (preview) is designed to replay whole scenario sets against simulated users before you ship: ten production scenarios, end to end, in under a minute. Every event designed to land in our planned AI Data Platform, an open, Iceberg-based lakehouse where your agent telemetry is one SQL query away.

A stitched-together stack can’t run this loop. An integrated stack can. The run produces the data, and the data produces a better run.

Build the future with Managed Agents

Every era of the cloud has its own unit of work, and every era gets the platform built for it. Fourteen years ago that was a $5 Droplet. Today it’s Managed Agents: compute, inference, and data as one runtime on the DigitalOcean AI-Native Cloud, any framework and any model, billed for the work and not the wait.

Get started today. One command deploys your first session.

Forward-looking statement: This blog post contains forward-looking statements about products, features, and plans that are on our roadmap or under discussion, including their capabilities and availability. These are not guarantees. The development, release, and timing of any products or features described here remain at DigitalOcean’s sole discretion and are subject to change, delay, or cancellation at any time without notice. DigitalOcean Managed Agents and Simulations are offered as public previews; DigitalOcean expects, but does not guarantee, that public preview services will perform for production-level workloads.