Atmosphere: A JVM Runtime That Puts AI Agents Behind Real-Time Transports

What Atmosphere Actually Solves

Atmosphere targets a specific gap in the Java AI ecosystem: most frameworks give you a way to call an LLM, but few treat the agent as a long-lived, network-facing service. The README positions it as a real-time engine where tokens flow from the LLM runtime to the client through a broadcaster you can filter, gate, and observe. That means you are not just getting a chat completion wrapper. You get a runtime that handles reconnects, authorization, and governance as first-class concerns. The intended user is a team running agents inside an existing JVM stack, likely Spring Boot or Quarkus, that needs to expose those agents over real transports like WebSocket or SSE, not just a REST endpoint. The project explicitly says it is not an agent-hosting platform; the host owns compute and scheduling. So if you need managed infrastructure, this is not it. If you need a library that turns a plain Java class into a deep agent with memory, planning, and sub-agent delegation, this is the pitch.

How the Runtime Is Structured: One SPI, Many Adapters

The core abstraction is the AgentRuntime SPI, which sits behind twelve runtime adapters. The README lists Spring AI, LangChain4j, and Anthropic explicitly, and says there are nine more behind the same interface. Each adapter is contract-tested with capability flags, meaning you can check at runtime what a given adapter supports rather than assuming feature parity. This is a pragmatic design because AI frameworks differ wildly in what they expose: tool calling, streaming, and structured output are not uniform. The runtime dispatch layer is in the atmosphere-ai module, while the transport layer lives in atmosphere-runtime. That separation means you can swap the AI provider without touching the endpoint code, which is the portability promise. The trade-off is that you are bound to the lowest common denominator unless you inspect the capability flags. The README does not enumerate those flags, so you would need to read the adapter documentation to know if, say, Anthropic's adapter supports the same tool-call gating as Spring AI.

Real Transports, Not Just HTTP Polling

The transport story is the strongest differentiator. Atmosphere runs WebSocket, SSE, and long-polling as always-on defaults, with gRPC also included. WebTransport over HTTP/3 is optional and requires adding jetty-http3-server or reactor-netty-http to the classpath plus a development certificate. That is a concrete constraint: HTTP/3 is not a drop-in default, and you need to manage certs. The broadcaster pipeline is central: tokens flow from the LLM to the client through it, and you can filter, gate, and observe that stream. This is not a simple pub-sub. The README mentions reconnect-safe continuation with durable sessions, run IDs, replay buffers, and checkpoints. For a production agent that loses a connection mid-stream, that is the difference between a broken client and a recoverable session. The documentation also claims long-polling as an always-on default, which is useful for environments where WebSocket is blocked. The presence of a JavaScript SDK, atmosphere.js, indicates the client side is a first-class concern, not an afterthought.

Governance on the Critical Path

Governance is where Atmosphere goes beyond most open-source agent frameworks. The README lists policy admission, @AgentScope, human approval, plan-and-verify, cost ceilings, PII rewriting, and admin kill switches. The key phrase is that policy admission sits on the critical path, meaning every tool call is checked before execution. That is a serious commitment. The durable HITL approvals are designed to hibernate without holding a thread, persist workflow state, and resume through REST approval surfaces. This is a concrete mechanism for long-running approvals that do not block a server thread. There is also an opt-in session tape that records session-boundary AI events, durable in SQLite, so you can reconstruct a run without making a model call. That is a practical feature for debugging and for distilling a smaller model from recorded traces. The governance module is separate, so you can likely use the transport without it, but the value proposition is the combination.

Protocol Surface: MCP, A2A, AG-UI, and Chat Channels

Atmosphere does not force you to expose a proprietary endpoint. It speaks MCP, A2A, and AG-UI, which are emerging interoperability protocols for AI agents. The README notes that MCP support is stateless on the 2026-07-28 spec, with sessions back to the 2024-11-05 spec. That is a specific compatibility detail that matters if you rely on stateful MCP sessions. There are also channel adapters for Slack, Telegram, Discord, WhatsApp, and Messenger, which means you can expose the same agent to chat platforms without rewriting logic. The coordinator module adds @Coordinator, AgentFleet, handoffs, and conditional routing, with an event-sourced coordination journal that tracks causal lineage. This is not just a single agent; it is a multi-agent orchestration layer. The documentation mentions durable hibernating Workflow<S> over a CheckpointStore, with Temporal-backed storage if you add atmosphere-checkpoint-temporal. That is a real integration choice: you get durable workflows out of the box, but for Temporal you need an extra dependency.

Getting Started: CLI, Scaffolding, and Adapter Swapping

The quick start is concrete. You can install the CLI via Homebrew with brew install Atmosphere/tap/atmosphere, or with a curl script that pipes to sh. Then you run a sample with atmosphere run spring-boot-multi-agent-startup-team. To create your own app, you use atmosphere new my-agent --template ai-chat, then cd into the directory and run LLM_API_KEY=your-key ./mvnw spring-boot:run. That is a standard Spring Boot flow. To swap the AI runtime, the CLI has a --runtime flag. The README shows --runtime spring-ai scaffolds against the Spring AI adapter, and mentions that a CLI overlay injects Maven dependencies. This is a practical way to avoid manual pom edits. The template name ai-chat suggests a chat-oriented default, but the framework is broader. The CLI is not just a project generator; it also runs samples, which lowers the barrier to seeing the streaming in action. One caveat: the README is truncated, so the full command set and template list are not visible here.

Limitations and Wrong-Tool Cases

The README is honest about scope. Atmosphere is not a hosting platform, so you must bring your own Tomcat, Jetty, Netty, Undertow, Quarkus, Spring Boot, or servlet container. That means you handle scaling, scheduling, and infrastructure. For stateless, bursty, autonomous agents that should hibernate when idle, the README itself recommends a serverless agent platform instead. That is a clear boundary. Another limitation is that WebTransport over HTTP/3 is optional and requires extra dependencies and a dev cert, so the always-on defaults are WebSocket, SSE, long-polling, and gRPC. Also, the session tape is opt-in, so you must enable it if you want replay. The code execution story is limited to a SandboxProvider SPI with a DockerSandboxProvider default; browser automation is explicitly out of scope. If you need headless Chromium, you must integrate it yourself. The README also mentions payment rails and commerce primitives are out of scope, so do not expect e-commerce features.

Alternatives and How They Differ

The README compares Atmosphere to agent-platform stacks like Cloudflare Agents, AWS Bedrock Agents, and Vertex AI Agents. The difference is architectural. Those platforms are managed services where the host owns compute, scheduling, and often the model hosting. Atmosphere is a library that runs inside your JVM process and gives you control over transports and governance. If you need a serverless, stateless agent that hibernates when idle, those platforms are a better fit. On the JVM side, the closest alternative might be using Spring AI or LangChain4j directly without Atmosphere. Those frameworks give you model access and some orchestration, but they do not provide the same real-time broadcaster pipeline, durable HITL approvals, or multi-protocol exposure out of the box. You would have to build WebSocket handling, policy checks, and MCP adapters yourself. Atmosphere bundles those as reusable modules. The trade-off is that you are adopting a larger framework with its own abstractions, whereas a direct Spring AI integration might be lighter if you only need a simple REST endpoint.

Maintenance, Licensing, and Upgrade Cost

Atmosphere is licensed under Apache-2.0, which is permissive for commercial use. The repository is active, with releases 4.0.68 through 4.0.70 in August and September 2026, indicating a steady release cadence. Maintenance cost comes from the number of moving parts: twelve AI adapters, multiple transport protocols, and optional modules like durable sessions and checkpointing. Each adapter must track upstream changes in Spring AI or LangChain4j, so you should expect periodic updates. The capability flags are contract-tested, which helps but does not eliminate the need to verify behavior after an upgrade. The README mentions a Maven Central artifact org.atmosphere:atmosphere-runtime and an npm package atmosphere.js, so dependency management is standard. There is no mention of a commercial support offering, so you rely on community and documentation. The documentation site is at atmosphere.github.io, but the README is truncated, so the full upgrade guide is not visible. Before adopting, check the changelog for 4.0.70 and the migration notes for any breaking changes in the SPI or configuration keys.

Editorial conclusion

Adopt Atmosphere if you are a JVM team building stateful, human-in-the-loop agents that must stream over WebSocket, SSE, or gRPC and need policy checks before every tool call. It is a poor fit for stateless, bursty, autonomous workloads where a serverless platform would hibernate idle agents. Before committing, verify that the adapter for your chosen AI framework has the capability flags you need, and confirm your transport choice: WebTransport over HTTP/3 requires adding jetty-http3-server or reactor-netty-http plus a dev cert. If you need Temporal-backed checkpoints, you must add atmosphere-checkpoint-temporal. The project is actively released with 4.0.70 as of September 2026, so check the latest changelog for breaking changes before upgrading.

Official sources

1. Atmosphere/atmosphere on GitHub
2. License: Apache-2.0
3. Project website
4. README
5. Releases