On October 27, 2026, Akamai answered one of the most practical questions in enterprise AI: where do AI agents actually run, and what stops the code they write from going too far? The company announced two new pieces of its AI Cloud platform, Akamai Inference and Akamai Agent Sandbox, alongside expanded access to NVIDIA Blackwell Ultra graphics processors. Together, they turn Akamai from a company known mainly for content delivery and security into a fuller AI stack provider, one that wants to serve models, run agents, and police the boundary between the two on the same platform.

That framing matters because the hardest part of shipping AI in a business is no longer getting a model to answer a question. It is running that model reliably near your users and your data, and then letting an agent act on its answers without handing it the keys to everything. Akamai’s bet is that companies will pay for a platform that handles both problems together, rather than stitching a model provider, a sandbox vendor, a cloud host, and a security layer into a fragile chain of their own.

This article explains what Akamai actually launched, what is still in beta, and what a business owner or technology lead should do with it this week. It is not a review: both products are in beta, and independent performance testing has not yet had time to appear. What follows is what the announcement says, what independent coverage confirms, and where the gaps remain.

What Akamai announced on October 27

Akamai, headquartered in Cambridge, Massachusetts, introduced Akamai Inference and Akamai Agent Sandbox as what it calls foundational products for its AI stack. In the company’s announcement, chief operating officer Adam Karon said customers want to build, run, and protect AI on the same platform, and that the two new services add the inference and execution layers that turn Akamai’s AI infrastructure into a full stack. Akamai’s official announcement is the primary source for the details below, and SiliconANGLE’s launch-day coverage independently confirms the same core facts.

The announcement also carries a commercial claim worth noting with care: Akamai says its cloud platform has already secured multiyear contracts collectively worth more than $14 billion. That figure covers the broader Akamai Cloud business, not these two new products. It does explain Akamai’s scale claim: the platform already runs across more than 4,350 edge locations.

Both new services are available in beta. Akamai Inference’s beta includes serverless deployment options, and Akamai Agent Sandbox is available through the Spin software development kit. Treat everything below as a beta assessment, not a production guarantee.

Akamai Inference: model access without running the model stack

Akamai Inference is a managed service that gives businesses access to open-weight and custom AI models through OpenAI-compatible application programming interfaces. In plain terms, if your application already talks to an OpenAI-style API, the idea is that you can point it at Akamai’s service without rewriting your code. That compatibility is the product’s most important practical feature, because rewriting integrations is where many AI migrations stall.

At launch, the catalogue includes 12 open-weight models ranging from 8 billion to 2.8 trillion parameters, plus embedding models for retrieval-augmented generation. The named models span three providers: NVIDIA’s Nemotron 3 Ultra, OpenAI’s gpt-oss-120b, and Google’s Gemma 4. Embedding models matter because they turn your documents into searchable representations, so a model can pull in the right passage before answering instead of guessing.

Customers can choose serverless, pay-per-use inference or dedicated deployments. A team shipping a new feature, or handling spiky traffic, will usually prefer serverless: no capacity to provision, no idle servers to pay for. A team running a model continuously, or one that needs control over exactly which model version is running and when it changes, will usually prefer a dedicated deployment, where Akamai says teams avoid rate limits and shared-tenancy queueing. Akamai also connects Inference to its managed databases and object storage, and to private and public clouds, so models can draw on enterprise data close to users.

Akamai Agent Sandbox: the launch’s most important idea

If Inference is about getting answers, Agent Sandbox is about what happens next. Modern AI agents do not just answer questions; they write code, run it, call tools, and take actions on a user’s behalf. That code is generated in seconds, and nobody reviews it before it executes. A system-prompt instruction cannot reliably stop it, because a model can ignore instructions or follow ones hidden in content it reads. Hence the strongest argument for the product: a sandbox enforces limits the agent cannot override.

Here is how Akamai structures that boundary. Agents run on Akamai Functions, and the code they write runs in its own isolated environment, sequestered from the agent’s runtime. The isolation uses WebAssembly, delivered as an open-source component of the Spin framework, with limits on compute, memory, outbound connections, and system capabilities. Akamai’s Agent Sandbox product page adds the details that matter most to a security review: outbound access is blocked by default, the agent-written code runs in a restricted JavaScript or Python runtime nested inside the WebAssembly sandbox, and execution limits are enforced by the runtime itself, so neither the agent nor its code can raise them.

That nested design is worth understanding. Most sandbox approaches wrap an agent in a container or a small virtual machine. Akamai instead isolates directly into the runtime with WebAssembly, which it says avoids the overhead and startup latency of spinning up custom microVMs or container wrappers. The company also says developers can choose other architectures where they fit, and plans to add controls governing what agents can reach and what can reach them. Superpower Daily’s analysis of the launch makes the same distinction clearly: Inference and Sandbox solve different problems, one serving models and one bounding agents, and the value is in having both on one platform.

There is also a multi-tenant angle that matters for agencies and software companies. If you run agents on behalf of many customers, one customer’s agent-generated code must never touch another customer’s data or workloads. Akamai says each agent runs in its own sandbox with strict runtime-enforced limits, so one tenant’s runaway code cannot consume another tenant’s resources or reach another tenant’s data. That is a claim to test, but it is exactly the right question to ask any sandbox vendor.

How the three pieces compare

The table hides one important asymmetry: Inference and the GPU fleet are about capacity and control over models, while the Sandbox is about restraint. Most AI failures that make headlines are failures of restraint, not capacity: a slow model is an annoyance, while an agent that deletes files or exfiltrates data is an incident. That is why the Sandbox deserves more scrutiny than the model catalogue.

The GPU layer: Blackwell Ultra today, Vera Rubin next year

Alongside the two services, Akamai expanded its dedicated GPU fleet to include NVIDIA Blackwell Ultra GPU clusters, and says it is preparing its infrastructure to support the NVIDIA Vera Rubin platform in 2027. The fleet also includes NVIDIA RTX PRO 6000 Blackwell Server Edition GPUs for low-latency inference. Each eight-GPU Blackwell Ultra node carries 288 GB of HBM3e memory per GPU, 2.3 TB in total, which Akamai says is enough to hold frontier-class models and to support test-time scaling, chain-of-thought reasoning, and long-context agentic work. Morningstar’s syndication of the announcement confirms that the hardware expansion is part of the same launch rather than a separate roadmap item.

For a non-specialist reader, the point is simple: bigger, faster memory per GPU means larger models and longer conversations can run without splitting work awkwardly across many machines. Dedicated hardware earns its keep only when you run a large model continuously or tune it yourself; for a simple chatbot, managed serverless inference will almost always be cheaper.

What is not proven yet: read the beta carefully

Several limits stated openly on Akamai’s own product page define the real scope of the product today.

• Tech preview, intermittent agents: each step completes in about a minute, then the agent stops until it receives its next instruction. Stateful components for agents that stay alive for days or weeks are promised later, not delivered now.
• Two languages for agent-written code: the nested runtime supports JavaScript and Python. Teams whose agents generate other languages will need to check whether that constraint fits.
• Beta inference, not a price list: the announcement does not publish beta pricing, service-level terms, or independent benchmark results. Any cost or performance comparison should wait for those numbers, or come from your own tests.
• Roadmap, not delivery, for Vera Rubin: Vera Rubin support is a 2027 preparation item, not part of what you can buy today.
• Security claims need testing: deny-by-default outbound access and runtime-enforced limits are strong design choices, but they are vendor claims until your team tests them against your own threat model, including prompt-injection and resource-exhaustion attempts.

These limits make it a beta worth evaluating, not a platform worth migrating to sight unseen.

A practical checklist for your business

1. Do your agents write and run code? If yes, you need a sandbox, from Akamai or elsewhere, before you scale. If your agents only call tools you wrote yourself, the risk is lower, but Akamai still recommends a sandbox whenever an agent reaches any external resource.
2. What should your agents never reach? Write it down before evaluating any vendor, then test whether the sandbox blocks everything on it by default.
3. Which model do you actually need? Check whether your workload runs well on one of the 12 launch models. A good sandbox around the wrong model is still the wrong purchase.
4. Serverless or dedicated? If your traffic is spiky or your feature is new, start serverless. Move to dedicated GPUs only when continuous usage, version control, or latency makes the dedicated cost clearly cheaper.
5. What is your exit plan? Because Akamai uses OpenAI-compatible APIs and an open-source Spin foundation, ask how you would move elsewhere if needed.

For smaller teams, the advice is simpler. If you do not build agents, this launch changes little for you directly, but it is worth asking your vendors whether their agents run in a sandbox at all. That question matters more as websites increasingly block AI agents they cannot control or verify. Our guide to free AI tools for students and WebReOn Tools remain useful starting points for everyday AI work, while WebReOn Chat is where we track multi-model AI assistants as they evolve.

What to watch next

Three milestones will show whether this launch becomes a real platform or remains an interesting beta. First, general availability: when Akamai removes the beta label, and what pricing and service levels accompany that step. Second, stateful agents: whether the promised long-running agent support arrives, and whether it preserves the same deny-by-default guarantees. Third, independent evidence: benchmarks, security assessments, and customer stories that are not written by Akamai. Until those appear, the honest summary is that Akamai has shipped a coherent beta design for a real problem.

Frequently asked questions

What is Akamai Inference?

A managed service providing access to open-weight and custom AI models through OpenAI-compatible APIs, with serverless or dedicated deployment. At launch it offers 12 open-weight models, from 8 billion to 2.8 trillion parameters, plus embedding models.

What is Akamai Agent Sandbox?

An isolated environment for AI agents and the code they write. Agents run on Akamai Functions; their code runs in a WebAssembly sandbox managed by the open-source Spin framework, with outbound access blocked by default.

Is Akamai Agent Sandbox available now?

It is in beta through the Spin SDK, as a tech preview for intermittent agents: each step completes in about a minute, then the agent stops until its next instruction. Long-running, stateful support is planned, not delivered.

Should my business switch to Akamai now?

Not on a beta announcement alone. Pilot it against your own workload, test the sandbox against your own block list, and wait for general-availability pricing and independent benchmarks before moving a customer-facing process.

Conclusion

Akamai’s October 27 launch is best understood as a statement about where enterprise AI is heading: away from which model is smartest, and toward which platform can run models and agents safely, close to users, under controls a business can actually audit. For most businesses, the right response this week is not a migration but a pilot and a policy: pilot the sandbox if your agents write code, write down what your agents must never reach, and ask every AI vendor you rely on where its agents run, and what stops them from going further than intended.