Async IO builds Atmosphere, the open-source framework that streams one
@Agent to browsers and apps over WebSocket, SSE or WebTransport, on any of
twelve AI runtimes. We keep it running in production for the teams that depend on it.
On top of the same real-time transport that has run in production for years, Atmosphere carries everything an AI agent needs to be safe, durable and accountable in production — here is what that includes.
The Atmosphere Console ships inside the starter and serves every sample: chat, sessions, workspace, checkpoints, rooms, observability, policies, decisions, OWASP posture and lineage — up to fifteen tabs, each shown when its feature is present, no frontend to write.
Set atmosphere.durable-runs.enabled=true (quarkus.atmosphere.durable-runs.enabled on Quarkus) and durable runs journal every tool call, and on the Built-in runtime every LLM round, then replay them deterministically. Kill the JVM mid-turn; once the crashed process's run lease expires (lease-ttl, 5 minutes by default), the client reconnects with its run id and the agent picks up where it stopped. The journal is SQLite with atmosphere-checkpoint and the SQLite JDBC driver on the classpath, otherwise in-memory and lost on restart. Off by default.
Declare a @Coordinator and its fleet is real: the Console renders the runtime-truth roster from the admin API and streams each agent's step as the coordination fans out.
Mark a tool @RequiresApproval and the call parks at a human gate — the agent suspends until a reviewer approves (optionally editing the arguments), denies, or it times out, then resumes without running what it should not.
Install a governance policy and it runs before the model does — a denial blocks the call. That "a deny blocks execution" rule is pinned by a contract test every one of the twelve runtimes inherits.
Put the agent in plan-mode and it emits a plan instead of calling tools. A static verifier checks that plan against your policy — taint, allowlist, capability, structure — and only a verified plan is allowed to execute.
Control-to-primitive matrices for the OWASP Agentic Top 10, the EU AI Act, HIPAA and SOC 2 ship in-tree and are pinned by a test that breaks the build on drift — an artifact your auditors can read, not a slide deck.
Every @Agent and @Coordinator comes with long-term memory, a write_todos planner, and a bounded sandboxed filesystem by default; a coordinator can spawn isolated subagents for sub-tasks. Turn any of it off per class or app-wide.
An agent's persona and guardrails live in a plain SKILL.md, resolved from a jar, a local cache, or a GitHub skills repo with SHA-256 integrity checking — a portable artifact you drop in a dependency or fetch by name.
Point Atmosphere at an OpenClaw workspace — AGENTS.md plus its extension files — and it reads them with no conversion: the persona augments the prompt, and RUNTIME, PERMISSIONS, SKILLS, CHANNELS and MCP drive config, policy and tools.
Turn on the tape and every typed event on a session is recorded durably. Replay a whole run — or a multi-agent coordination tree — with no model in the loop, then fold the tape into training data. Off by default.
With the Spring Boot starters or the Quarkus extension, each AI turn is recorded by default: which agent configuration answered (runtime, requested model, system-prompt and tool-set hashes) and which tools it called, with no prompt or tool-result text. Read it from the admin API or the Console's Lineage tab, both behind the admin content-read gate. The default recorder is in-memory and is lost on restart.
Your Workflow<S> runs on a built-in step engine out of the box. Add atmosphere-checkpoint-temporal and, with a Temporal server, the same steps run as Temporal activities — the workflow code does not change.
Build once with @Agent — deliver over any transport and any protocol.
Three distinct layers, each independently extensible.
Your application code declares what it does. Atmosphere handles how it is delivered — and falls back automatically when a transport is unavailable.
Add the dependency to your classpath and your agent speaks the protocol. No manual endpoint wiring, no boilerplate.
The backends Atmosphere runs on are SPI seams, not hard-wired dependencies. Ship on the in-tree defaults, or plug in the platform you already operate — no code change.
You are not shopping between Spring AI and LangChain4j — you want an
agent stack that does not lock you into one framework, one LLM
provider, or one vendor. Atmosphere bridges nine third-party agent
frameworks (one of them, CrewAI, a Python sidecar) and two native model
APIs: each is moving fast, each has its own release cadence, and each
could change direction tomorrow. Atmosphere is the
runtime-abstraction layer that makes your
@Agent, @AiEndpoint, and @AiTool
code portable across all of them — twelve total runtimes counting
Atmosphere's own Built-in OpenAI-compatible client. Swap the
dependency, keep the code. Async IO maintains the abstraction and every
bridge on this page, and has been selling Atmosphere support since
2013.
Spring's official AI framework. ChatClient, advisors, RAG, VectorStore, and full auto-configuration.
Java port of the LangChain ecosystem. Chains, AI services, streaming chat models, and tool bridging.
Agent Development Kit. Multi-agent orchestration, sessions, and the Runner execution engine.
Kotlin-native AI framework. Structured concurrency, typed tools, multi-agent orchestration, Bedrock cache control.
Microsoft's enterprise-grade AI orchestration SDK. ChatCompletionService, kernel plugins, memory, planners.
Multi-agent framework from Alibaba. Structured output, conversation memory, and token usage; @AiTool calls are bridged into its toolkit and run through Atmosphere's approval gate.
Goal-driven agent framework from the creator of Spring. Declarative goals, planned execution, native PromptRunner.
Spring AI Alibaba ReactAgent. Structured output and conversation memory through the Spring AI ChatClient surface.
Native Anthropic Messages API client. No third-party SDK — direct HTTP+SSE with prompt-caching hints, tool loop, and Helicone-style header passthrough.
Native Cohere v2 Chat API client. HTTP+SSE against POST /v2/chat with `content-delta`, `tool-call-*`, and `citation-start` events surfaced verbatim. Sovereign-endpoint override via `cohere.base.url`.
The first non-Java runtime — Java owns transport and `@AiTool` execution, an out-of-process Python sidecar (FastAPI + crewai 1.14) owns the multi-agent crew graph. HTTP+SSE in, tool-RPC callback out.
Atmosphere's zero-dependency OpenAI-compatible client. Built for tests and local dev without pulling in a framework — works with OpenAI, Gemini, Ollama, and any compatible endpoint.
Atmosphere runs on top of each framework and its
ecosystem — Spring AI, LangChain4j, Google ADK, Microsoft
Semantic Kernel, JetBrains Koog, Alibaba AgentScope, Embabel's
planning engine, Spring AI Alibaba's ReactAgent, and CrewAI through
a Python sidecar — and calls the Anthropic Messages and Cohere v2
Chat APIs directly. The
Built-in runtime is a zero-dependency
OpenAI-compatible client for tests and local dev. Whichever you
pick, you code against one surface — @Agent,
@AiEndpoint, @AiTool — and you get
more than any framework ships on its own.
Every runtime provides these, except where an item names its limits. Atmosphere normalizes them behind one annotation surface, so your agent code is identical whether you run on Spring AI, Koog, AgentScope, or anything in between — and the capability matrix is CI-pinned so the adapter rows can't drift from the running code.
The wider JVM ecosystem has pieces of some of these —
Spring has WebSocket and Kafka, Spring Integration has channel
adapters, there are community MCP clients. Atmosphere is what
wires every item below directly to your
@Agent / @AiTool code, shipped as one
coherent stack and covered by one SLA — instead of half a
dozen separate libraries your team glues together.
Everything you need to build, deploy, and operate AI agents in production. Spring Boot 4.1, Spring Boot 3.5 (atmosphere-spring-boot3-starter) and Quarkus 3.39.5+ auto-configuration included.
One class, one annotation. Endpoints, commands, tools, skill files, conversation memory, and protocol exposure are all auto-wired.
Manage fleets of agents with parallel fan-out, sequential pipelines, conditional routing, and result evaluation.
CheckpointStore persists workflow state as parent-chained snapshots. Pause workflows without holding a thread; resume via REST.
@RequiresApproval pauses tool execution for human approval. The virtual thread parks cheaply until the client responds.
Slack, Telegram, Discord, WhatsApp, Messenger — alongside the default browser endpoint. Set a bot token and the same @Command + AI pipeline works on every channel.
Real-time dashboard, REST API for governance, runtimes, agents, A2A tasks, and flow graphs, WebSocket event stream, and MCP tools for managing agents.
OpenTelemetry tracing, Micrometer metrics, and AI token usage tracking. Auto-configured with Spring Boot.
atmosphere.js with React, Vue, Svelte, and React Native hooks. Streaming, offline queues, auth token refresh; a page reloaded mid-answer reattaches to its running answer within the server's reattach grace (30 s by default).
Get direct access to the core engineering team. We wrote the framework, we maintain it, and we stand behind it. Meet your production schedule and compliance requirements with guaranteed response times.
OWASP Agentic Top 10, EU AI Act, HIPAA, and SOC 2 evidence matrices ship in-tree and are CI-pinned. Your auditors get a build artifact, not a slide deck.
atmosphere-verifier refuses unsafe LLM-emitted
workflows before any tool fires — Meijer
Guardians of the Agents (CACM, Jan 2026).
Microsoft's YAML rule schema parsed verbatim, same
audit_entry JSON shape, same agt verify
semantics — drop-in for shops standardising on MS Agent OS.
Atmosphere ships the released spec. Pre-1.0 method names are aliased server-side so your existing A2A clients keep working through the migration.
policyDeny is a build-time
invariant for every adapter — you can't add a runtime
without proving it honours your governance chain.
A production system is unusable — agents not responding, transport dead, data at risk. Response means an engineer who can act, not an autoresponder.
Production is running but impaired — a transport falling back, a runtime failing intermittently, elevated errors under load. A workaround may exist.
An incident is one reported problem, worked until it is resolved or until we agree a workaround — not one email, and not one hour of engineering.
Free open source, forever
Everyone. Apache-2.0, public issue tracker, and the same framework we support.
$2,000 / org / year
Dev, staging and evaluation. Get the team unblocked without a production promise.
$9,000 / org / year
Atmosphere on the critical path. A four-hour answer during your working day.
from $25,000 / org / year · quoted
Revenue depends on it around the clock. 24×7 cover on a named contact.
Still running Atmosphere 2.x or 3.x in production? We provide long-term support, security patches, and migration guidance for legacy deployments. Includes a migration path to current Atmosphere when you are ready.
