Akamai Inference + Agent Sandbox: Give Your AI Agents a Safe Place to Run Code

Nothing here is sponsored — no affiliate links on this page. Every product claim below is Akamai's own from its October 27, 2026 launch announcement, not an independently verified result. We have not run these products ourselves — this is researched analysis, not hands-on testing.

Akamai launched two products on October 27, 2026, and together they answer the question every team shipping AI agents is quietly asking: where do agents actually run, and what stops the code they write from running wild? One serves models. The other cages the code agents write. Neither is a new model — and that is exactly why this launch matters for developers.

What Akamai actually launched

Akamai Inference is managed model serving. You get open-weight and custom models through OpenAI-compatible APIs, so existing applications can move without rewrites, according to Akamai. Choose serverless, pay-per-use inference or a dedicated deployment. At launch the catalogue includes 12 open-weight models ranging from 8 billion to 2.8 trillion parameters, including NVIDIA Nemotron 3 Ultra, OpenAI gpt-oss-120b, and Google Gemma 4, plus embedding models for retrieval-augmented generation.

Akamai Agent Sandbox is the more interesting half. Agents run on Akamai Functions, and the code they write runs in its own isolated environment, sequestered from the agent's runtime. It is delivered as an open source component of the Spin framework, and it uses WebAssembly isolation to set clear limits on compute, memory, outbound connections, and system capabilities. In plain terms: the agent can think and act, but the code it generates executes in a box with walls you define.

Both are in beta at launch. Akamai Inference beta includes serverless deployment options. For NVIDIA B300 GPU clusters, Akamai says to contact its sales team — so treat the biggest hardware tier as a sales conversation, not a self-serve click.

Why the sandbox is the real story

Models keep getting cheaper and smarter. That is not the bottleneck anymore. The bottleneck is trust. The moment an agent writes and runs its own code, you have a program writing programs inside your infrastructure. Without isolation, that code can reach whatever the agent can reach — your data, your network, your credentials, your customers.

This is the same lesson running through the whole agent-infrastructure wave. Replit's business launch this week was built around an agent "habitat" — orchestration, sandboxing, and identity controls. Akamai is now offering its version of that habitat on its own cloud: managed inference on one side, isolated execution on the other, with its security portfolio wrapped around both.

The WebAssembly choice is worth noting. Akamai is not the only isolation model in town — it name-checks microVMs with snapshot and fork capability and policy-enforced containers as alternatives — but WebAssembly isolation is lightweight, fast to spin up, and fits the serverless, edge-shaped workloads Akamai is built for. For short-lived agent code, that is a sensible default. For long-running, stateful, heavily privileged workloads, look hard at the microVM and container options Akamai also offers.

What Inference gives developers, practically

• No rewrite to switch. OpenAI-compatible APIs mean code written against OpenAI-style endpoints can point at Akamai Inference without a refactor. The real cost is testing behaviour, latency, and output quality — not plumbing.
• Models plus your data, in one place. Akamai Cloud provides managed databases and object storage and connects to private and public clouds, so models can draw on enterprise data. Requests run on Akamai's global network — more than 4,350 edge locations — which Akamai says reduces latency and keeps performance consistent.
• A genuinely wide model range. 8 billion to 2.8 trillion parameters, plus embedding models, means the small end covers cheap high-volume work, the large end covers heavy reasoning, and retrieval pipelines do not need a second provider for search.

What Akamai has not published in this announcement: pricing. No per-token rates, no sandbox pricing, no serverless unit costs. Do not budget on this announcement alone.

The GPU fleet underneath it

Akamai also expanded its dedicated GPU fleet to NVIDIA Blackwell Ultra clusters, and says it is preparing for NVIDIA Vera Rubin in 2027. Each eight-GPU Blackwell Ultra node carries 288 GB of HBM3e memory per GPU — 2.3 TB in total — aimed at test-time scaling, chain-of-thought reasoning, and long-context agentic work.

The practical point: dedicated clusters give you control over model versions and deprecation timelines, and run without rate limits or shared-tenancy queueing, according to Akamai. Managed inference is convenient; dedicated GPUs are control. Akamai is now selling both, on the same platform, which is the whole pitch: build, run, and protect AI in one place instead of assembling serving, execution, and security from three vendors.

Akamai says this AI infrastructure push has already secured multiyear contracts collectively worth more than $14 billion. That is a vendor claim about its cloud business, not a benchmark — but it tells you this is not a side experiment.

Where this fits — and where it doesn't

• Use Akamai Inference to evaluate if: you want OpenAI-compatible serving of open-weight models without operating your own GPU stack, you care about edge latency, or you want inference, data, and security on one platform.
• Use Akamai Agent Sandbox to evaluate if: your agents write and run code today — or will next quarter — and you currently have no hard boundary between agent code and the rest of your system. If your agents only answer questions and never execute anything, you do not need this yet.
• Do not switch on this announcement alone if: you need published pricing, independent latency benchmarks, or a production track record. Both products are in beta.

What to check before you switch

• Audit what your agents can execute today. List every place an agent's output turns into code execution, shell commands, or API calls with write access. Any item without isolation is the argument for a sandbox.
• Try the OpenAI-compatible endpoint on a non-production workload. Point a test app at Akamai Inference and compare outputs, latency, and cost once pricing is published.
• Set sandbox limits before you need them. Decide now what agent code may never touch: credentials, production databases, outbound internet, the filesystem outside a scratch directory.
• Wait for pricing and independent reports before committing. The architecture is sound and the pitch is coherent. The bill is still unknown.

FAQ