Atmosphere

Async IO is the company behind Atmosphere — the open-source real-time framework the JVM has trusted in production for years, and now the platform Java teams build governed, durable AI agents on. We provide the engineering, the support, and the long-term commitment that production systems require.

Talk to Us Support Plans
5 Transports WebSocket, SSE, HTTP Streaming, Long-Polling, WebTransport/HTTP3
3 Agent Protocols MCP, A2A, AG-UI
12 AI Runtimes one SPI — swap by dependency, keep your code
13 Years in production
What shipped

A full agent platform on the transport you trust

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.

shipped

One Console for every agent

The Atmosphere Console ships inside the starter and serves every sample: chat, sessions, workspace, checkpoints, rooms, observability, policies, decisions and OWASP posture — fourteen tabs, no frontend to write.

shipped

Agents that survive a restart

Durable runs record each step and replay deterministically. Kill the JVM mid-turn; the client reconnects with its run id and the agent picks up where it stopped. Snapshots persist to in-memory, SQLite or Postgres.

shipped

Multi-agent fleets, visible live

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.

shipped

Human approval, built in

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 policy

Governance every runtime honors

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 all twelve runtimes must pass, so none can quietly skip it.

opt-in

Verify the plan before it runs

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.

CI-pinned evidence

Compliance evidence, in the build

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.

default-on

A deep-agent harness, batteries in

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.

shipped

Skills — an agent you can share

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.

shipped

Bring an agent you already have

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.

opt-in

Session tape + replay

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.

add a dependency

Workflows on Temporal

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.

The Platform

Transports. Protocols. Extensions.

Build once with @Agent — deliver over any transport and any protocol. Three distinct layers, each independently extensible.

Transports

5 transports, one API

Your application code declares what it does. Atmosphere handles how it is delivered — and falls back automatically when a transport is unavailable.

  • WebSocket Full-duplex communication over a single TCP connection.
  • SSE Server-Sent Events.
  • WebTransport/HTTP3 Multiplexed, low-latency transport over QUIC with native WebTransport support — auto-detected via AsyncSupport with zero-config Jetty 12 QUIC or Reactor Netty sidecar.
  • Long-Polling HTTP long-polling with automatic reconnection.
  • gRPC High-performance RPC framework with bidirectional streaming over HTTP/2.
Auto-fallbackReconnection with jitterHeartbeatsMessage caching
Agent Protocols

3 protocols, zero configuration

Add the dependency to your classpath and your agent speaks the protocol. No manual endpoint wiring, no boilerplate.

  • MCP Model Context Protocol.
  • A2A Agent-to-Agent protocol, originally launched by Google and now stewarded by the Linux Foundation.
  • AG-UI Agent-User Interaction protocol.
Auto-registered from classpathMulti-channel: Slack, Telegram, Discord, WhatsApp, Messenger
Extensions

Pluggable by design

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.

  • Durable execution Workflows run on a built-in, dependency-free step engine out of the box.
  • Checkpoint stores Snapshot a paused agent's whole conversation and resume it later, even in a different JVM.
  • Session stores A durable session token re-attaches a dropped client to its rooms and broadcasters.
  • Agent import Point Atmosphere at an OpenClaw workspace — AGENTS.
  • Broadcast backplane When one node is not enough, a Redis or Kafka backplane relays an agent's streams across the cluster, so a session opened on one JVM is reachable from any of them.
ServiceLoader seamsIn-tree defaults, zero configNo vendor lock-in
Framework Support

One support contract. Every Java AI framework.

The Java AI ecosystem has eleven third-party agent frameworks. Each one is moving fast, each one has its own release cadence, and each one 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 the bridges; our support contract is the insurance policy against vendor lock-in.

Spring AI

Spring / VMware

Spring's official AI framework. ChatClient, advisors, RAG, VectorStore, and full auto-configuration.

atmosphere-spring-ai Bridged

LangChain4j

Community

Java port of the LangChain ecosystem. Chains, AI services, streaming chat models, and tool bridging.

atmosphere-langchain4j Bridged

Google ADK

Google

Agent Development Kit. Multi-agent orchestration, sessions, and the Runner execution engine.

atmosphere-adk Bridged

JetBrains Koog

JetBrains

Kotlin-native AI framework. Structured concurrency, typed tools, multi-agent orchestration, Bedrock cache control.

atmosphere-koog Bridged

Semantic Kernel

Microsoft

Microsoft's enterprise-grade AI orchestration SDK. ChatCompletionService, kernel plugins, memory, planners.

atmosphere-semantic-kernel Bridged

Alibaba AgentScope

Alibaba

Multi-agent framework from Alibaba. Structured output, conversation memory, and token usage on top of explicit tool dispatch managed in your code.

atmosphere-agentscope Bridged

Embabel

Embabel

Goal-driven agent framework from the creator of Spring. Declarative goals, planned execution, native PromptRunner.

atmosphere-embabel Bridged

Spring AI Alibaba

Alibaba

Spring AI Alibaba ReactAgent. Structured output and conversation memory through the Spring AI ChatClient surface.

atmosphere-spring-ai-alibaba Bridged

Anthropic

Anthropic

Native Anthropic Messages API client. No third-party SDK — direct HTTP+SSE with prompt-caching hints, tool loop, and Helicone-style header passthrough.

atmosphere-anthropic Bridged

Cohere

Cohere

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`.

atmosphere-cohere Bridged

CrewAI

CrewAI Inc.

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-crewai Bridged

Built-in

Async IO

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-ai Bridged

Abstracted, portable, and then some

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, and Spring AI Alibaba's ReactAgent. 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.

Abstracted through the @Agent API

Portable across all 12 runtimes

Every framework provides these. 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.

  • Streaming text to any client
  • Tool calling with @AiTool and JSON-schema parameters
  • Human-in-the-loop approval gates via @RequiresApproval
  • Structured output with response schemas
  • Conversation memory across turns
  • Vision and multi-modal input on any framework that supports it
  • Token-usage accounting on every response
  • Per-request retry policy and prompt caching
Only with Atmosphere

Wired to your agent, not to your infra team

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.

  • Cross-framework @Agent portability — one codebase, twelve runtimes
  • Real-time streaming transport: WebSocket, SSE, WebTransport/HTTP3, gRPC, long-poll with automatic fallback
  • @Coordinator + @Fleet multi-agent orchestration over A2A v1.0.0 (released spec)
  • Durable HITL workflows — agent state survives JVM restart via CheckpointStore
  • @Command routing to Slack, Telegram, Discord, WhatsApp, Messenger
  • Rooms, presence, and broadcaster clustering over Kafka or Redis
  • MCP server — expose @AiTool to Claude, Copilot, Cursor, any MCP client
  • atmosphere.js client SDK with React, Vue, Svelte, and React Native hooks
  • Compliance evidence pinned in CI — OWASP Agentic Top 10, EU AI Act, HIPAA, SOC 2
  • Plan-and-verify — refuse unsafe LLM-emitted workflows before any tool fires
  • MS Agent Governance Toolkit YAML interop — same schema, same audit_entry shape
  • Enterprise support since 2013

No vendor lock-in. One support contract.

You are not shopping between Spring AI and LangChain4j — you already want an agent stack that does not lock you into one framework, one LLM provider, or one vendor. Atmosphere is that stack. Async IO has been selling the support contract that covers the abstraction and the swap since 2013.

Without Atmosphere

Locked in

  • One framework, chosen up front.
  • One LLM provider, locked into its pricing and SLA.
  • Rewrite the agent when the framework changes direction, goes EOL, or gets acquired.
  • Separate support contracts with each vendor. No one owns the integration.
  • No escape hatch if the bet goes wrong.
With Atmosphere + Async IO support

Portable, covered

  • Twelve runtimes — Built-in plus eleven framework adapters (Spring AI, LangChain4j, Google ADK, Embabel, Koog, Semantic Kernel, AgentScope, Spring AI Alibaba, Anthropic, Cohere, CrewAI). Swap the dependency when the winner changes.
  • Any LLM provider supported by any of the twelve runtimes. Move when pricing shifts, rate limits bite, or a new model lands.
  • The abstraction holds. Your @Agent, @AiEndpoint, and @AiTool code do not move.
  • One support contract with Async IO. We have been shipping Atmosphere and writing every bridge on this page since 2013.
  • The escape hatch is the product. The swap is what you are paying us to maintain.
Talk to Us Support Tiers
What We Deliver

Production-grade agent infrastructure

Everything you need to build, deploy, and operate AI agents in production. Spring Boot 4.0 and Quarkus 3.36.0+ auto-configuration included.

@Agent Annotation

One class, one annotation. Endpoints, commands, tools, skill files, conversation memory, and protocol exposure are all auto-wired.

@Coordinator Orchestration

Manage fleets of agents with parallel fan-out, sequential pipelines, conditional routing, and result evaluation.

Durable Workflows

CheckpointStore persists workflow state as parent-chained snapshots. Pause workflows without holding a thread; resume via REST.

Human-in-the-Loop

@RequiresApproval pauses tool execution for human approval. The virtual thread parks cheaply until the client responds.

5 Channels

Slack, Telegram, Discord, WhatsApp, Messenger — alongside the default browser endpoint. Set a bot token and the same @Command + AI pipeline works on every channel.

Admin Control Plane

Real-time dashboard, REST API for governance, runtimes, agents, A2A tasks, and flow graphs, WebSocket event stream, and MCP tools for managing agents.

Observability

OpenTelemetry tracing, Micrometer metrics, and AI token usage tracking. Auto-configured with Spring Boot.

Client SDKs

atmosphere.js with React, Vue, Svelte, and React Native hooks. Streaming, offline queues, auth token refresh.

Who we are

Built by the people who wrote the spec

Atmosphere has been in continuous production since 2013 — powering trading floors, healthcare systems, collaboration tools, and AI applications at companies from startups to the Fortune 500. The team brings over 30 years of experience in real-time systems, JVM internals, and AI infrastructure.

We contributed to Java NIO/AIO and have been shipping real-time Java infrastructure since before WebSocket was standardized. Atmosphere itself has been open source since day one, and the project is backed by a team of Java Champions and Apache Committers who have been active in the JVM ecosystem for decades.

♦ Java Champions ◆ Apache Committers ◆ JVM NIO/AIO contributors ◆ Open source since 2008
3.7k+ GitHub stars
18 Years in production
253 Versions on Maven Central
Apache 2.0 License
Enterprise Support

Backed by the team that built it

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.

  • Compliance, audited

    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.

  • Plan-and-verify

    atmosphere-verifier refuses unsafe LLM-emitted workflows before any tool fires — Meijer Guardians of the Agents (CACM, Jan 2026).

  • MS Agent Governance Toolkit ↗

    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.

  • A2A v1.0.0

    Atmosphere ships the released spec. Pre-1.0 method names are aliased server-side so your existing A2A clients keep working through the migration.

  • One contract, twelve runtimes

    policyDenyBlocksRuntimeExecute is a build-time invariant for every adapter — you can't add a runtime without proving it honours your governance chain.

S1
Production down

A production system is unusable — agents not responding, transport dead, data at risk. Response means an engineer who can act, not an autoresponder.

S2
Production degraded

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.

Community

Free open source, forever

Everyone. Apache-2.0, public issue tracker, and the same framework we support.

  • Coverage Community
  • Response (S1) Best effort
  • Response (S2) Best effort
  • Incidents GitHub issues
  • Phone Support —
  • Email Support —
  • Emergency Patches —
View on GitHub

Developer

$2,000 / org / year

Dev, staging and evaluation. Get the team unblocked without a production promise.

  • Coverage Business Hours
  • Response (S1) Next business day
  • Response (S2) 2 Business Days
  • Incidents 5 / year
  • Phone Support —
  • Email Support ✓
  • Emergency Patches —
Get Started

Production

$9,000 / org / year

Atmosphere on the critical path. A four-hour answer during your working day.

  • Coverage Business Hours
  • Response (S1) 4 Business Hours
  • Response (S2) 1 Business Day
  • Incidents Unlimited
  • Phone Support ✓
  • Email Support ✓
  • Emergency Patches ✓
Get Started

Mission-Critical

from $25,000 / org / year · quoted

Revenue depends on it around the clock. 24×7 cover on a named contact.

  • Coverage 24×7 (S1 / S2)
  • Response (S1) 1 Hour · 24×7
  • Response (S2) 4 Hours · 24×7
  • Incidents Unlimited
  • Phone Support ✓
  • Email Support ✓
  • Emergency Patches ✓
Get a Quote
Legacy

Atmosphere 2.x / 3.x Support

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.

Talk to Us

Need professional services on a per-hour basis? Talk to us for a custom quote.

Morty Proxy This is a proxified and sanitized view of the page, visit original site.