Akamai Just Launched Managed AI Inference and an Agent Sandbox — What It Means for Developers Shipping AI at the Edge (October 2026)
I have known Akamai for most of my working life as the company that makes websites load fast. If you have shipped a site behind a CDN, Akamai's network has probably sat between your server and your user. So when Akamai announced on Tuesday, October 27, 2026, that it was launching a managed AI inference service and an agent execution sandbox, I paid attention — because this is not a CDN company dabbling in AI. This is a company with more than 4,350 edge locations and multiyear cloud contracts worth over $14 billion deciding that the next thing it wants to own is where your AI actually runs.
The two new products are called Akamai Inference and Akamai Agent Sandbox, and both are in beta now. They tell a story about where AI deployment is heading: closer to users, and toward a world where the hard problem is not the model but the sandbox around agent-written code.
What Akamai actually announced
The announcement, made from Cambridge, Massachusetts, introduces two foundational products for Akamai Cloud. Akamai Inference is a managed model-serving service: you call models through APIs, and Akamai handles orchestration, execution, and authentication. Akamai Agent Sandbox is a secure, isolated place to run AI agents and, crucially, the code those agents write.
They sit on infrastructure Akamai has built for years: GPU/CPU clusters, edge functions, storage, networking, and its security portfolio. The pitch, in the words of Adam Karon, Akamai's Chief Operating Officer and General Manager of Akamai Cloud, is that "AI inference will represent the majority of enterprise focus and investment," and that customers pushed the company to turn its AI infrastructure into a full stack: build, run, and protect AI on one platform.
That framing is honest about the shift in this industry. Training is a one-time event a few companies do; inference is what every company does, every day, millions of times. And agents that write and execute code are the newest, least solved part of the stack.
Akamai Inference: the part most developers will touch first
Start with the piece you would actually use on day one. Akamai Inference gives you managed access to open-weight and custom models through OpenAI-compatible APIs. That detail matters most in practice: if your application already talks to an OpenAI-compatible endpoint, you can point it at Akamai's service without rewriting your integration. For a developer with a working app, "no rewrite required" is worth more than any benchmark number.
At launch, the catalog includes 12 open-weight models ranging from 8 billion to 2.8 trillion parameters. The named ones are NVIDIA's Nemotron 3 Ultra, OpenAI's gpt-oss-120b, and Google's Gemma 4, plus embedding models for retrieval-augmented generation (RAG). You can also bring your own models and tune them rather than being limited to the catalog.
There are two ways to run them. Serverless, pay-per-use inference is for teams that want to ship a feature this quarter without provisioning anything. Dedicated deployments are for teams that want control: their own capacity, their own model versions, no shared-tenancy queues, no surprise rate limits.
On the data side, Akamai Cloud provides managed databases and object storage, and the service connects to private and public cloud platforms, so models can draw on enterprise data where it already lives. Requests run on Akamai's global network, which should cut latency for users spread around the world.
For a WordPress or web developer, this is the part I would test first. Many of us are adding AI features to sites now — search that understands intent, content summarization, support chat that knows your docs. Most need a decent open model, served reliably and close to the user — exactly this product's shape.
Akamai Agent Sandbox: the part that matters more than it sounds
Now the piece that sounds boring and is actually the most important announcement of the two. AI agents are increasingly doing real work: taking actions on a user's behalf, and writing and running their own code to do it. That last part is where things get dangerous. Code an agent writes is code you did not review, running with whatever permissions the agent has. Unlimited reach into your database, internal APIs, or the internet is a problem no prompt engineering fixes.
Akamai Agent Sandbox gives agents a place to execute with hard boundaries. 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 language: the agent's code gets a small, sealed room with a defined budget and reach list — nothing else.
I like two things about this design. First, it is open source, as a component of Spin, so you can inspect what the boundary actually is instead of trusting a marketing page. Second, Akamai is not pretending WebAssembly is the only answer: agent isolation is converging on several models — microVMs, policy-enforced containers, WebAssembly-isolated functions — and developers can choose the architecture that fits their workload.
If you are building with agents, the sandbox question is the question. Models keep getting better on their own; what decides whether you can safely ship an agent is the boundary around what it can do.
The hardware underneath: Blackwell Ultra today, Vera Rubin next
Under the services sits hardware worth knowing, because it shapes price and performance. Akamai expanded its dedicated GPU fleet to include NVIDIA Blackwell Ultra GPU clusters, and it is preparing its infrastructure for the NVIDIA Vera Rubin platform in 2027.
The fleet now spans NVIDIA RTX PRO 6000 Blackwell Server Edition GPUs for low-latency inference and Blackwell Ultra clusters for enterprises that want to build, tune, and self-host models on infrastructure they control. Each eight-GPU Blackwell Ultra node carries 288 GB of HBM3e memory per GPU — 2.3 TB in total — enough to hold frontier-class models. That memory targets test-time scaling, chain-of-thought reasoning, and long-context agentic work.
GPU clusters, Akamai notes, give enterprises control over model versions and deprecation timelines, and run without rate limits or shared-tenancy queueing. As Jon Alexander, Akamai's Senior Vice President of Cloud Technology, put it: "Enterprises should not have to choose between speed and control when they put AI into production."
One caveat, stated plainly: the dedicated B300 GPU clusters are not a click-to-buy item — Akamai says to contact its sales team for availability — and both new services are in beta. Beta means things can change, so test before committing anything critical; the Inference beta does include serverless options, a low-friction way to try it.
Why Akamai, and why now
Why does a CDN company get to play in this space? The honest answer has three parts.
First, inference is a distribution problem, and distribution is what Akamai has always done. Serving a model worldwide with low latency is not so different from serving a website or video, and Akamai already operates the network, edge locations, and security stack.
Second, enterprises are tired of assembling this stack from separate providers. Most teams stitch together serving, data access, routing, governance, and security from separate vendors, then secure the joints themselves; a single platform covering the whole path is an appealing pitch.
Third, the agent wave makes the sandbox a selling point in its own right. A year ago, the conversation was about which model to use; now it is about what the model is allowed to do, and companies that answer that credibly have something genuinely different to offer.
None of this makes Akamai the obvious default — the hyperscalers have deeper catalogs, and specialist inference providers have optimized this exact problem for years. But it does make Akamai a serious option, especially for teams that already live on its network.
What this means for your next project
If you are planning a project with AI features, here is how I would use this news.
Start with the API compatibility. If Akamai Inference speaks the OpenAI-compatible API your code already uses, trying it costs you an afternoon, not a rewrite. Test the model that fits your latency and cost budget, measured from where your users are.
Take the sandbox seriously before the agent: if your roadmap includes agents that run code, evaluate the sandbox first. Ask what the code can reach, its compute and memory limits, and what happens when it exceeds them — those answers are your production risk assessment.
Keep the beta label in mind. Do not migrate a critical feature to a beta service without a fallback: run it alongside your current provider, compare latency and cost over real traffic, and keep the switch reversible. And watch the Vera Rubin timeline — preparing for next year's GPU platform signals intent to stay in this game.
Conclusion
Akamai's October 27, 2026 announcement is easy to skim past, but it marks something real: the company that built its name on delivering the web fast now wants to deliver AI inference fast and own the sandbox where agents run code. Akamai Inference offers 12 open-weight models from 8 billion to 2.8 trillion parameters through OpenAI-compatible APIs, with serverless or dedicated deployment, and Akamai Agent Sandbox offers WebAssembly-isolated, open source execution for agent-written code on the Spin framework, all running on a network of more than 4,350 edge locations backed by Blackwell Ultra hardware.
For developers, the takeaway is practical. Inference is where the money and daily work now live, the agent sandbox is where the production risk lives, and a provider that credibly handles both — close to your users, with APIs your code already speaks — deserves a place on your shortlist. Both services are in beta, so test them like one: measure, compare, keep your fallback. The winners of the inference era may not have the best models, but the ones that run models closest to users, cheapest, and safest.
FAQ
What did Akamai announce on October 27, 2026?
Akamai announced two new products for Akamai Cloud: Akamai Inference, a managed AI model-serving service, and Akamai Agent Sandbox, a secure isolated environment for running AI agents and the code they write. Both are available in beta.
What is Akamai Inference?
A managed service giving enterprises access to open-weight and custom AI models through OpenAI-compatible APIs, so existing applications can use it without rewrites. Customers choose serverless, pay-per-use inference or dedicated deployments. At launch the catalog includes 12 open-weight models 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.
What is Akamai Agent Sandbox?
A secure place to run AI agents and their code. Agents run on Akamai Functions; the code they write runs in its own isolated environment, sequestered from the agent runtime. An open source Spin framework component, it uses WebAssembly isolation to limit compute, memory, outbound connections, and system capabilities.
How is Akamai's offering different from other AI cloud providers?
Its main differentiators are distribution and the agent boundary: inference on a global network of more than 4,350 edge locations, and an open source, inspectable sandbox model. Dedicated GPU clusters also give enterprises control over model versions without rate limits or shared-tenancy queueing.
Are Akamai Inference and Akamai Agent Sandbox generally available?
No — both are in beta as of the October 27, 2026 announcement. Akamai Inference beta includes serverless deployment options, while NVIDIA B300 GPU cluster availability is through Akamai Sales. As with any beta, test before committing critical workloads.
Should developers switch to Akamai Inference now?
Not blindly. If your code already uses an OpenAI-compatible API, trying it is low-cost: test the model you need, measure latency from your users' locations, and keep your current provider as a fallback while the services are in beta.
