Akka SDK

Akka SDK is the component model for building agentic systems. You write each part of a system as a component: an agent that calls a model, a workflow that supervises agents, an entity that holds state, an endpoint that exposes it. The Akka runtime runs every component with durable state, recovery from failure and elastic scale, so you do not add a separate message broker, cache, job scheduler or state store.

You write components in Java, or have the Akka Specify Plugin generate them from a specification. See Akka Specify.

Agents

An agent calls an AI model for one task. It holds session memory that survives restarts and that other agents can share, calls function tools and remote MCP tools, and streams its output to the caller. The model is declared, not hard-coded, so you can change provider or model without rewriting the agent.

An Autonomous Agent runs as a durable process on typed tasks. The runtime drives its decision loop, and the agent can delegate to other agents, hand off to a peer, lead a team or moderate a conversation through tools the runtime provides.

Orchestration

A workflow is a durable, multi-step process. It persists its position after each step, resumes where it stopped after a failure, retries failed steps by policy, and runs compensation steps to undo earlier work when a later step fails. A workflow can pause for hours or days while a person decides. Workflows are the usual supervisor for a fixed sequence of agent calls; an Autonomous Agent supervises when the model decides the sequence.

State and memory

Entities hold durable state in memory, sharded across the cluster, with one owner for each entity. An Event Sourced Entity stores every change as an event in a journal and rebuilds its state by replaying it. A Key Value Entity stores its current value. Views build read models across many entities and serve queries separately from the entities that write the data. Agent session memory is stored the same way and can be compacted to keep a model’s context small. Long-term memory carries knowledge across sessions, users and agents. It is built on event-sourced entities and is part of the Agent and Workflow components, so you do not program it.

Streaming and events

Consumers read streams of events from entities, workflows, other services or message broker topics, and produce events in turn. Each consumer reads at its own pace while events wait in the journal or broker, so a fast producer cannot overwhelm a slow consumer. Services exchange events without a message broker, and connect to one when you need it. Delivery to consumers is at least once.

Endpoints and protocols

HTTP, gRPC and MCP endpoints expose components to clients and to other agents. An agent can use tools from MCP servers, and any component can be exposed as an MCP tool. Agents also communicate with agents on other platforms over A2A. Timers schedule durable calls that run at least once.

Models

Agents call models from Anthropic, OpenAI, Google Gemini and Vertex AI, Amazon Bedrock, Azure OpenAI and other hosted providers, and from self-hosted and local endpoints. Each agent can use a different model. Akka Optimize routes these calls and serves your own models. See AI model provider configuration, Models and inference and Akka Optimize.

Governance in the components

The controls that Akka Verify governs are SDK features when the agent runs on Akka: guardrails, classifiers, sanitizers, evaluators and the ledger. Each model call names the agent that made it. See Controls, The ledger and evidence and Akka Verify.

Developer tooling

The akka CLI, the local console, Maven and sbt plugins, hot reload, and a TestKit for unit and integration tests. See Install the Akka CLI and Testing.

Part of the Akka Agentic AI Platform

  • Akka Specify builds Akka SDK components from a specification.

  • Akka Verify evaluates and governs the agents you build.

  • Akka Optimize routes, serves and trains the models your agents call.

  • How Akka runs covers where your services run and who operates them.