The Rise of the Agentic Server

We have let go of the wheel.

The era of agents is here, and we are long past the point of no return. We can mourn the old ways, when code was forged by the hands of the tired, the wicked, and the dangerously over-caffeinated. But agents are already writing, testing, and revising software on our behalf.

Another benchmark falls. Another ceiling shatters. A new era is on the horizon: swarms, sometimes called "agent teams."

Last September, OpenAI reported that it put ~10,000 agents to work on the Navier–Stokes problem, a famous question about fluid motion. For about 88 hours, agents explored different approaches, shared promising findings, and used tools before producing what OpenAI says is a proof. In a recent interview, Sam Altman estimated the effort cost around $10 million.

The mathematics will be scrutinized. Shouldn't the machinery be, too?

How did the agents collaborate, coordinate work, share discoveries, use tools, and stay within their guardrails? OpenAI's account offers a glimpse into a new paradigm, but no system we can run and study.

We spent years building tools that waited for us. This one doesn't. Cloud agents open workspaces, share what they find, call tools, and keep pulling on a thread long after we've left the room, so what lands is code we didn't write, based on decisions we didn't make. Whether it's ten agents or ten thousand, the work now happens past the edge of our machines, and beyond the edge of our attention.

The labs see this. Anthropic's Message threads hold context on the server; they also support server-side compaction and Managed Agents with optional memory. OpenAI's Responses API also does compaction server-side, while its Agents API runs a managed harness. If context, memory, and execution are moving behind APIs, who outside the labs can study the machinery?

That's a transparency problem. Ours is an accountability problem, if we humans are no longer the bottleneck, we need to know what our agents did while we were away, and a token stream isn't an audit log.

We debate model weights and benchmarks, but an inference engine only generates tokens. The work that needs monitoring happens around the engine: these new agents retain state, call tools, process results, and keep going. That coordination layer has been absorbed by the labs but it is still opaque.

The agentic server sits in that gap—between the harness and the inference engine. A remote harness provisions workspaces and assigns tasks; the agentic server maintains state and runs the tool loops around inference. Neither runs on your machine anymore.

Today, with no client harness at all, an agent can fix a bug in your codebase entirely from your phone. It can search your codebase, read the docs and tests, edit the code, push to git, and cut a PR on your behalf—all from the cloud.

As humans begin to operate at a higher level of abstraction we still need the optionality and auditability to inspect every consequential action: which model ran, which tool was called, and what changed? Reproducibility is critical for understanding these systems, but without strong observability and tracing, we cannot innovate on these systems.

Security can no longer be a second class citizen. In July, an OpenAI's agent escaped a sandbox through a package-registry proxy flaw during an internal cybersecurity evaluation, reached the public internet, and breached Hugging Face's production systems, apparently seeking benchmark answers. Hugging Face reconstructed roughly 17,600 actions over several days. OpenAI's account and Hugging Face's reconstruction show an experiment that crossed into the real world, and it kept going.

Every tool is a potential security risk. Code needs a sandbox; credentials, files, and network egress need hard limits. The server and the harness must enforce those limits on the tools they run. Monitoring must catch breaches early.

It'd be silly to think a prompt is an adequate sandbox. As swarms begin to rise in adoption, every weak point compounds and puts the real world at risk.

OpenAI's Open Responses gives us a shared interface for defining the shape of an agentic server. The implementation decides how state, tools, sandboxes, failures, and costs work. The open source community needs a project it can build on top of.

vLLM Agentic API is that open layer. Its gateway manages response state, tool loops, and streaming around inference. It works with vLLM, SGLang, and NVIDIA Dynamo, and can run with llm-d for inference routing. Builders can inspect and alter it.

Open weights let us study the model. They cannot tell us how frontier agents assign work, isolate code, recover from failure, or decide to spend another hour on a problem.

An open agentic server turns claims into experiments anyone can run. We can revise how agents coordinate, measure the results, reproduce failures, and pursue unexpected ideas. Closed APIs conceal the machinery. Open software empowers the open source frontier to keep innovating.

Swarms will work while we sleep, pursuing problems no human could manage alone. Their reach will exceed our attention but it shouldn't exceed our ability to question them. We must reconstruct their actions, investigate their failures, and understand the code that governs them.

I refuse to accept an age of intelligence built behind closed doors, where we can use AI systems but never understand them. Decentralizing the knowledge of these systems is too important. So, please, come join the fight for open-source AI.