Statewave Review: A Governance-First Memory Runtime for Production AI Agents

Overview

Statewave is an open-source memory runtime designed specifically for production AI agents. Unlike traditional solutions that treat memory as a simple vector store, Statewave governs memory as auditable state. It provides access policies, sensitivity labels, and tamper-evident audit receipts, all self-hosted on Postgres.

Key Specifications:*License:Apache 2.0 (Open Source)*Cost:Free (No paid tiers, no cloud upsells)*Rating:7.5/10*Best For:Engineering teams shipping agents into regulated or audited environments (e.g., healthcare, finance, legal).

Core Functionality

Statewave operates on the core abstraction of the "episode" rather than dumping embeddings into a bucket. This approach ensures that every stored memory traces back to its source, allowing teams to reconstruct not just what an agent remembered, but the exact path by which it came to remember it. This provenance is critical for debugging hallucinations or identifying poisoned retrievals.

Key Features

1. Provenance on Every Memory:Each memory item is traceable to its origin document, providing a complete audit trail.
2. Access Policies and Sensitivity Labels:Memories carry labels that determine who can read what. This enables proper multi-tenant thinking, allowing one memory store to serve multiple agents with different trust levels without cross-contamination.
3. Tamper-Evident Audit Receipts:Every read and write operation generates a receipt designed to be resistant to quiet editing. This ensures that logs are records rather than recollections, which is essential for answering auditor questions about what a model knew and when.
4. One-Command Local Boot:Statewave can be launched entirely offline using a single command:npx @statewavedev/statewave. This brings up the API, admin console, and Postgres database together without requiring an account, API key, or network dependency.
5. MCP Compatibility:Statewave integrates natively with Model Context Protocol (MCP) clients, including Claude Code, Cursor, and VS Code Copilot. This eliminates the need for bespoke adapters and ensures the runtime survives changes in agent frameworks.

Pricing and Licensing

Statewave is entirely free under the Apache 2.0 license. There is no paid tier, no seat count limit, and no commercial upsell. The only costs associated with Statewave are the infrastructure required to run the Postgres instance and the engineering hours needed to manage it.

Comparison with Competitors:*Mem0:Free up to 10,000 memories, then $19/month (Starter) or $249/month (Pro). While easier to start, it lacks the access policies and audit receipts found in Statewave.*Zep:Credit-based pricing starting around $25/month (Flex plan at $125/month). Strong on temporal knowledge graphs but weaker on access control.*Letta:Free to self-host or $20/month for Pro. Offers a full agent runtime rather than just a memory layer.

Statewave competes on a different axis than these tools: it prioritizes governance, sensitivity labels, and tamper-evident receipts over ease of use or managed hosting.

Setup and Integration

Setting up Statewave is straightforward. The one-command boot allows developers to have a governed memory store running on a laptop before their coffee is cold. Because it is offline by default, it can be evaluated on machines with no outbound network access.

Integration Steps:1.Boot:Runnpx @statewavedev/statewaveto start the API, console, and database.2.Connect:Wire an agent to Statewave using the MCP step. For supported clients (Claude Code, Cursor, VS Code Copilot), this involves adding a server entry rather than writing a custom adapter.3.Configure Policies:The primary work required is designing the policy taxonomy. Teams must decide what sensitivity labels mean and which agents get which access levels. This governance overhead is a necessary trade-off for security and compliance.

Production Considerations

While the software is free, running it in production involves standard database operations: backups, migrations, upgrades, and monitoring. Since Statewave requires self-hosting on Postgres, teams must own the database, handle upgrades, and manage availability (including "3am pages").

Support Model:As an open-source project, there is no commercial support tier. Assistance is provided via GitHub issues. The project currently has 10 contributors, 384 commits, and 14 releases. While a serious project, it is younger than some alternatives.

Pros and Cons

What We Like

• Full Provenance:Every memory carries a traceable source, enabling deep debugging.
• Granular Control:Access policies and sensitivity labels prevent one agent from recalling another agent's context.
• Audit Trail:Tamper-evident receipts on reads and writes are a feature not led by paid competitors.
• Developer Experience:One-command boot allows for rapid, offline evaluation.
• Framework Agnostic:MCP compatibility reduces the need for custom adapters.

What Could Be Better

• No Hosted Option:Users must self-host the Postgres instance and manage all infrastructure.
• Support Limitations:No commercial support tickets; reliance on GitHub issues.
• Project Maturity:With only 10 contributors, it may not be suitable for teams with low tolerance for reading source code or managing young projects.
• Governance Overhead:The complexity of setting up policies may be wasted effort during early prototyping phases.

Target Audience

Statewave is best suited for:*Regulated Industries:Teams in healthcare, finance, or legal where agents touch data that must be explained to an auditor.*Multi-Agent Environments:Teams running multiple agents against a single memory store that require strict per-agent read permissions.*Self-Hosting Mandates:Organizations where data must remain entirely within their perimeter with no phone-home capabilities.

Statewave isnotrecommended for:*Prototyping:If you are still working out whether an agent should exist, the governance overhead is unnecessary. Tools like Mem0's free tier offer faster setup.*Managed Service Seekers:If you require a hosted solution with a support team, Statewave is not the right fit.*Large Ecosystem Needs:If your team requires a mature ecosystem with extensive third-party integrations beyond MCP, a more established tool might be preferable.

Final Verdict

Statewave addresses a critical gap in the AI memory market by treating memory as governed state with an owner, sensitivity level, and audit trail. While it trades off some maturity and support compared to managed competitors, it offers the most serious answer currently available for teams that must answer for what their agents know and when. For engineering teams shipping agents into regulated environments, Statewave is a free, powerful, and necessary tool.

Installation Command:npx @statewavedev/statewave

Creator:Saber MaramCurrent Contributors:10