Durable event-sourced memory
Subscribe to memory
Agents can subscribe to any event or changes in memory using Akka Streaming, enabling adaptive behavior in response to real-time environmental changes.
Akka Memory tracks state with an event-driven architecture, recording every change as an immutable fact. These events can be replayed for recovery, replicated for resilience, broadcast for real-time updates, or projected into custom read models.
Developers can create multi-memory queries using Views that optimize read access or define custom subscriptions to memory change events through Akka Streaming.
Sharded and in-memory for <10ms writes
Data sharding
App data is partitioned across in-memory, durable nodes.
Akka routes user requests to the correct instance.
Data rebalancing
Data shards are re-balanced as the
number of runtime nodes changes.
Memory that supports real-world intelligence
Short-term (session) memory
Akka agents access their working memory instantly. Ideal for responsive behavior, short-lived context, and low-latency reasoning.
- Colocated memory and logic: Memory lives with the agent, eliminating distributed coordination and enabling consistent, low-latency decisions. As agents scale, memory scales naturally with the agent.
- Immediate write visibility: Updates to memory are available within the same execution flow, allowing agents to reason and act on freshly written state without delay.
- Streaming-native architecture: Akka Memory treats state as a series of events, not isolated reads and writes. This makes it ideal for agents that ingest and act on high-throughput, real-time inputs such as video, chat tokens, or sensor data.
Long-term (shared) memory
Summarize or project agent history into stable facts, preferences, or goals that persist across sessions. Critical for personalization, user modeling, or strategy.
- Replication and recovery: State is replicated across nodes, regions, and clusters for high availability and fault tolerance. Automatic snapshotting accelerates recovery.
- Queryable views: Project historical memory into structured, retrievable forms for coordination, analytics, or behavior adaptation.
- Compaction and summarization: Condense event history into persistent summaries or facts to reduce storage and build durable long-term knowledge.
- Automatic state capture: Agents persist state changes automatically with no manual logging or external coordination.
- Replayable history: Agents can be restored, audited, or inspected at any point in their timeline.
Traceable and auditable
Capture, review, and replay every memory interaction. For agents, trace user, tool, and LLM conversations. For workflows, trace transitions, and call stacks for long-running processes. Akka stores memory events in an encrypted, tamper-evident record for audit, compliance, and deep system analysis.
Intrinsic to agents
Agents, workflows, and streams get memory automatically, without requiring developers to program state or persistence logic. Developers can also create their own memory objects that are shared across users, sessions, agents, and systems.
Part of the platform
Akka Memory is part of the Akka Agentic Platform, which provides everything needed to build, run, and evaluate agentic systems. This includes structured, goal-directed agents with Akka Agents, durable execution with Akka Orchestration, and real-time data handling with Akka Streaming.
Akka Memory is high-performance, durable, and accessible both locally and across regions.
Durable, exactly-once workflow engine
Akka Orchestration’s workflow engine executes one command at a time with strong consistency guarantees, ensuring exactly-once side effects without external coordination. State changes are persisted using event sourcing, with periodic snapshots to accelerate recovery. On failure, workflows restore their state from the latest snapshot and replay only recent events. Execution is transactional, and failed steps can be rolled back automatically to maintain correctness.
Visual workflow monitoring and observability
Akka Orchestration provides built-in tools to inspect workflow state, trace execution paths, and debug failures in real time in both a local and cloud console. Visualize active and completed workflows, drill into individual steps, and understand the system’s behavior at a glance. All telemetry — including metrics, logs, and traces — can be exported to existing observability stacks for end-to-end visibility across the agentic system.
Integrate with external APIs and tools
Akka Orchestration can manage calls to external APIs and tools as first-class steps, with integrated support for retries, flow control, and error handling.
Multi-region replication
Akka Orchestration supports active-active deployments across cloud regions or data centers with strong consistency guarantees. Workflows can be transparently distributed, recovered, or fail over across zones without losing progress or duplicating side effects. This enables high availability and geographic resilience for globally distributed agentic systems.
Error handling and compensation
Workflows in Akka Orchestration can define timeouts, retries, and recovery strategies directly in their logic. Compensation handlers can be attached to reverse the effects of partially completed steps, ensuring that failed workflows leave the system in a consistent state. Failure modes are modeled explicitly, so workflows behave predictably even under adverse conditions.
Building a real-time video AI service with Google Gemini
A blueprint for agentic AI services
