Attributable author and principal
Agent identity and content hash bind a memory to the exact agent and principal that wrote it. A relayed or shared write is never mistaken for a local one.
Sovereign Agent Governed Experience
Memory your agents
can be held to.
SAGE is a governed memory and messaging layer for AI agents. Every memory is signed by an agent, admitted through a reviewable process, scoped by permissions you set, and kept with an audit trail you can inspect.
Claude Code · Codex · Cursor · Any MCP-capable client
Free and open source. Runs on your machine.
Governance
Memory that has to
earn its place.
A memory is a claim, not a fact. SAGE records who made it, how it was admitted, and how much weight it still carries.
Signed admission
Agents sign what they write. Validation votes decide what commits: on a personal node you cast your own vote, on a network admission needs a quorum.
Challenge and corroboration
A committed memory can be challenged, corroborated or reinstated. The disagreement stays in the record instead of disappearing from it.
Decay without reinforcement
Confidence fades when nothing reinforces a claim, so stale context stops crowding out what your agents actually need.
LifecycleIllustrative example
Proposed, signed
The vendor API times out under load; the retry wrapper is a workaround, not a fix.
Challenged, then corroborated
A second agent disagrees, a third supplies evidence, confidence settles and the contested history stays on the record.
Auditability
Every memory
has a history.
The record around a memory is the point: who wrote it, under which principal, how it was admitted, and what has happened to it since.
Reviewable lifecycle
Proposed, committed, challenged, deprecated or reinstated: each transition is recorded with its reason, so the current state is explainable rather than just asserted.
Read how memory changesInspectable storage
Local BadgerDB and SQLite stores under your home directory. Query them, back them up, move them, or read the source that writes them.
Deprecation is not deletion
Retiring a memory removes it from recall while the audit history stays intact, so later readers can still see that it existed and why it was withdrawn.
Security and privacy
Sovereign
by default.
Keep the node on your machine, encrypt what it holds, and decide which agents may reach it. Nothing is shared unless you grant it.
SAGE supplies context to your model; it does not change the model's weights. Recall depends on the memories recorded, your configuration and the agent's use of its tools. Open source under Apache 2.0, with published research and benchmark scripts available to inspect.
Composes with AgenTrust. SAGE ships a verified bridge, sage-agenttrust, that gates memory submission on a verified execution attestation, so a committed memory can carry the attested identity that authored it. AgenTrust proves the runtime; SAGE proves the consensus record. The bridge is optional and additive, stock SAGE runs without it, and it establishes provenance rather than the truth of the content.
Local by default
Memories live under ~/.sage/. Optional federation, connectors and remote model providers can send data beyond your machine, but only when you configure them.
Vault encryption
Enable the vault to encrypt memory contents at rest with AES-256-GCM. Keep the recovery key somewhere safe.
Read the setup guideClassification and clearance
Records carry a classification and agents an enrollment clearance. A write is checked against the caller's clearance, and recall only returns what that caller is entitled to see.
Explicit, revocable access
Roles, domains, access groups and per-agent visibility are explicit policy rather than assumptions. Revoking access takes effect without rewriting the underlying record.
Examine the researchNetworked agents
Sovereign nodes.
Shared memory.
SAGE nodes federate under policy you write. Nothing is shared by default, and every peer grant is directional, scoped and revocable.
Human-verified pairing
A join ceremony pins the peer's identity and certificate before any agreement exists. Connections are established deliberately, not discovered and trusted.
Per-domain, per-direction grants
Each peer agreement grants read, copy or write per domain, in one direction. A peer that can read a domain does not thereby gain the right to write to it.
Agent-level exposure
Choose which local agents are discoverable to a peer, and which of your agents may reach a peer's exported domains. Visibility is not memory access, and neither is delivery authority.
Revocable at any time
Pausing or revoking a connection invalidates the frozen agreement binding, so previously issued plans stop being usable rather than lingering as standing authority.
Agent communication
Durable messages.
Explicit ownership.
Agents coordinate through an inbox with claims, receipts and consent, rather than by trusting whatever text arrives in them.
Exact identities
Messages route between exact agent identities. A reply never lands on a same-named stranger, and federated work stays chain-qualified.
Claims, not guesses
Inspection is passive. Work is only taken when an agent explicitly claims a specific request, so two runtimes cannot silently duplicate the same task.
Consent before contact
Receiver-local consent governs whether a remote agent may message you at all, separately from whether it can read your memory.
Receipts are not read evidence
Delivery, read acknowledgement and results stay distinct states, so an agent never treats "it arrived" as "it was understood" or as permission to act on the contents.
Why SAGE
Memory you can trace,
control and share.
SAGE uses retrieval too. Its focus is the record around a memory: who contributed it, how it was admitted, and which agents may use it.
Retrieve source material
Find relevant information in documents and other data sources, then give it to a model as context. A useful foundation for answering questions about a corpus.
Read the retrieval overview →Reuse earlier context
Keep facts, conversation context or agent state across sessions. Systems such as Mem0, Zep and Letta take different approaches to that work.
Read the source docs →Govern a shared memory
Combine agent-signed writes, validation before commit, confidence and decay, and explicit access controls in a local memory node your tools can share.
Inspect the memory lifecycle →On a personal install, your node casts its own signed validation vote. On a multi-validator network, admission requires a quorum. These checks govern what gets committed; they do not guarantee that every remembered claim is true.
How this comparison is grounded
RAG describes a retrieval pattern, not a fixed product feature set. Mem0 extracts and stores reusable memories, Zep builds temporal context graphs, and Letta preserves stateful agents. Local deployment, sharing and governance are available in other systems too. SAGE brings its particular combination together around a consensus-backed memory record. Choose based on the controls and workflow you need.
Inside the product
See what your agents remember.
CEREBRUM is SAGE's local dashboard. Explore project memories, inspect records and manage agent access.
CEREBRUM v11.23.14 with synthetic sample data. Appearance varies by release and configuration.
Explore SAGE's capabilities →Get started
Put SAGE to work.
Install SAGE, connect your AI client, and let the agent use its memory tools as you work.
01
Install SAGE
Download for macOS, Windows or Linux. Open the local dashboard and set up the memory engine.
02
Connect your agent
Use CEREBRUM to prepare the connection for your MCP-capable client. Follow the connection guide for your tool.
03
Keep useful experience
Your agent can record lessons and recall relevant memories in later sessions. Inspect what it keeps from the dashboard.
Connect an agent.
Set up Claude, Codex or another MCP client with SAGE's memory tools.
Open the connection guide →Build memory into your app.
Start with the Python SDK or signed REST API. Choose how your agent records and retrieves experience.
Open the developer quickstart →Use SAGE when your agents return to ongoing work. Project decisions, failed approaches and lessons from previous sessions are useful inputs. If you only need a one-off search through a set of documents, a RAG pipeline may already cover the job.
Governed memory for AI agents
Give every agent
something it can answer for.
Signed, admitted, scoped and auditable: memory your agents can keep working from, and you can account for.
macOS · Windows · Linux · Free · Apache 2.0Capabilities
Memory infrastructure for AI agents
Governed institutional memory: a BFT quorum on a network, your node's own signed vote on a personal install. Confidence-scored, and decay-aware.
Release notes: changes introduced in v11.23.14
v11.23.14 improves MCP responsiveness, protects AMID restarts, and adds optional local memory judging with source evidence. The judge is experimental and off by default. This release keeps the existing consensus version and chain data in place. Read the release notes →
Responsive MCP calls
A slow tool call can run alongside independent requests. Clients can cancel pending calls, and bounded concurrency keeps the bridge responsive. Cancellation does not undo a committed write.
Optional local memory judge
An experimental model can check whether proposed memories are lasting knowledge. It is off by default; uncertain or unavailable verdicts wait for operator review. Read the memory-gate guide.
Source evidence stays local
Attach a quote, log line or document excerpt through MCP or signed REST. An enabled memory gate checks whether it supports the claim. The source text stays on your node and never enters the chain.
Safer fleet restarts
AMID restores pending transaction fences before serving requests. A restart keeps signing blocked until the pending transaction is resolved. A malformed or unreadable fence ledger refuses startup until the problem is resolved.
Governed Knowledge
Memories pass admission checks before commit. Signed votes, challenges and corroboration provide a reviewable lifecycle for the record.
Federation
Connect SAGE nodes over LAN, VPN, or configured internet routes with a human-verified join ceremony. Discover eligible agents and choose which memory domains to share, revocable any time.
Agent Messages
Route durable work between exact agent identities, reply idempotently, and inspect passive history without turning delivery, read evidence, or results into the same state.
Fully Inspectable
Local BadgerDB/SQLite stores under your home directory. Inspect, query, back up, and move your data.
Confidence Scoring
Corroboration can reinforce a memory. Confidence can decay without reinforcement, helping recall favor useful context.
Persistent Memory
Recorded memories remain available across sessions, subject to their lifecycle and your access permissions. Keep project decisions, preferences and lessons from previous work.
Semantic Search + Reranker
Recall by meaning with embeddings, then re-score the results with a reranker. Choose local providers to keep that processing on your machine.
Learns From Outcomes
Record what worked and what failed, then supply those lessons to later sessions. Published experiments examine the effects of this feedback loop.
Auto-Journal
Pipeline exchanges are summarised as memories automatically. Full audit trail of inter-agent work without storing bulky payloads.
CEREBRUM Dashboard
A 3D MRI brain of your memories: domains as lobes, consolidation as depth. Search, curate, and drill into a memory’s train of thought.
Chat History Import
Import from ChatGPT, Claude, or Gemini. Seed your AI’s memory from existing conversation history.
One-Click Updates
Built-in auto-updater checks releases, downloads, and replaces, all from the dashboard.
Agent coordination
Durable work.
Explicit ownership.
Available in v11: persistent task backlogs, a unified inbox, and deliberate handoff between runtimes, with assignment, delivery, and replies kept distinct.
Persistent task backlog
sage_task creates durable tasks and tracks planned, in-progress, done, or dropped status. Open tasks don't decay. sage_backlog returns work assigned to your exact agent identity, subject to current access permissions.
One unified agent inbox
sage_inbox brings local and federated requests, task assignment notices, and replies into one bounded surface. Requests are claimed; notices point to the backlog for assignment verification; returned answers stay separate from new work.
Explicit runtime handoff
sage_message_handoff transfers claimed message work between runtimes sharing the same signed agent identity. Exact session and revision checks prevent concurrent takeovers; a stale runtime can't reply after ownership moves. There is no age-based automatic takeover.
Recover without duplicate work
Retained claim history distinguishes your unfinished work from work claimed by another session. Idempotent send and reply operations recover lost responses; durable claimant identities preserve ordinary restart continuity without merging concurrent runtimes.
Threaded answers and wake hints
sage_message_reply returns results to the original sender; sage_message_replies pages through those answers. The signed local wake stream lets supervisors wait for inbox changes, but a wake is never a delivery receipt, read receipt, or claim.
Governed collaboration
Agent identity, live permissions, and explicit task assignment remain authoritative. Message payloads and replies are untrusted data, not permission to execute instructions. Federated collaboration never grants local write or administrative authority by itself.
Read the MCP task and messaging reference, reply lifecycle, and wake-stream contract.
Dashboard
See it in action
Current CEREBRUM UI, captured with synthetic sample data.
Brain · sample data
Federation · sample data
Recall settings · sample data
Overview · sample data
FAQ
Questions before you install
SAGE is local memory infrastructure for AI agents. It gives tools like Claude Code, Codex, Cursor, Windsurf, and Claude Desktop a persistent memory server they can use through MCP or REST.
No. SAGE stores memories with signatures, consensus validation (a network quorum, or your node's own vote), confidence scoring, decay, clearance, domain permissions, full-text search, semantic recall, and optional local reranking.
On your machine by default. Memories live under ~/.sage/ in local BadgerDB/SQLite stores, with optional AES-256 encryption at rest. There is no required cloud account.
Any AI tool that can run an MCP server or call a local REST API. The dashboard can write config for common clients, and the Python package is sage-agent-sdk.
v11 adds CEREBRUM, guided setup, semantic recall, controlled federation, and in-place upgrades. Recent releases add encrypted agent working state, a deliberate upgrade path with an explicit vote, automatic trusted-node agent messaging, an amid operator surface for fleets without CEREBRUM, and the app-v28 public-memory commitment. v11.23.14 improves MCP responsiveness and AMID restart safety, and adds an optional local memory judge with source-evidence checks. The judge is experimental and off by default.
Federation links separate SAGE nodes through a human-verified ceremony. Trusted peers running v11.19.16 or later can discover and message eligible agents automatically. Pairing alone shares no memory domains: the local owner chooses specific domains and a bounded Read or Copy policy. A remote agent can't gain local write, ownership, role, or Root authority through federation.
SAGE is Apache 2.0 and runs on your machine without a SAGE account or a metered tier. The app does not collect product usage analytics. Optional third-party services can have their own account requirements, costs and privacy policies. See the privacy details and connection guide.
One binary, plus an embedding provider. Setup points it at Ollama on the same machine; SAGE_EMBEDDING_PROVIDER, SAGE_EMBEDDING_BASE_URL and SAGE_EMBEDDING_MODEL point it somewhere else instead. The reranker installs itself on first use, and macOS, Linux and Windows builds ship from every release.
After setup, storage and the dashboard run locally. Recall can work offline with local embedding and reranking providers. Downloads, updates, federation, a tunnel for ChatGPT and any remote providers need a connection.
sage-gui backup --full writes a complete stopped-node archive and restore --from restores it on this machine or another one. Check the backup type before sharing it: a CEREBRUM JSON export is unencrypted even when the source ledger uses the vault. See the backup and recovery reference.
You can deprecate one with sage_forget or from the dashboard, and it stops appearing in recall. It is not erased from the chain: the audit trail is the point, so a forgotten memory is recorded as forgotten rather than quietly dropped.
Getting Started
Three steps to get started
Install SAGE, connect your AI client, and start recording the project context you want to carry into later sessions.
01
Install SAGE
Download for macOS, Windows, or Linux. Install the signed release asset and open the local dashboard.
02
Connect Your AI
The setup wizard generates MCP config for Claude Code, Codex, Cursor, Windsurf, Claude Desktop, and other MCP-capable tools.
03
Use Your AI
Once connected, your agent can use SAGE memory tools to record useful context and recall it in later sessions.
ChatGPT
Connecting ChatGPT
MCP-native tools connect locally. ChatGPT uses a separate OAuth connector path, so SAGE includes a guided setup flow for the tunnel, OAuth exchange, and token issuance. A browser-extension path is available for users who prefer not to expose SAGE over a tunnel.
Switching Providers?
Take your memories
with you
Changing AI providers shouldn't mean starting from zero. SAGE is model-agnostic. Your data belongs to you.
From ChatGPT
Export conversations from OpenAI, then import into SAGE.
- 1Settings → Data Controls → Export
- 2Download the ZIP from OpenAI’s email
- 3CEREBRUM → Import → drop ZIP
From Claude
Export Claude.ai conversations and import them.
- 1Settings → Privacy → Export
- 2Download Anthropic’s export file
- 3CEREBRUM → Import → drop file
From Gemini
Export via Google Takeout and import.
- 1Takeout → Gemini Apps
- 2Download the archive
- 3CEREBRUM → Import → drop JSON
Your data stays yours. The import runs entirely on your machine. Nothing is uploaded anywhere.
Multi-Agent Networks
Build your private
AI network
SAGE starts as one local brain. When you need a team across projects, machines, or an organization, add agents from the dashboard.
Agent Management
Add, configure, and manage agents from the dashboard. Each gets its own signing keys, identity, role, and permissions.
Access Groups
Grant explicit Read, Read+Write, or Read+Write+Modify authority to reviewed local members. Roles, clearance, ownership, and security-profile hard denies remain separate controls.
Per-Project Identity
Each project folder receives its own Ed25519 keypair automatically. No shared keys, no manual setup. One CLI command claims a pre-configured identity.
Key Rotation
Rotate active credentials without rewriting historical memory authorship. Retired credentials cannot return as a new messaging, task, or federation identity.
Controlled Federation
Pair nodes through a human-verified trust ceremony to discover and message eligible agents. Grant chosen memory domains separately for live Read or receiver-controlled Copy; pairing alone shares no memory domains.
Agent Attribution
Every memory retains the exact agent that created it. CEREBRUM shows current ownership and authority separately from immutable authorship.
Agent Onboarding
One command.
Fully configured.
Create an agent in CEREBRUM with a reviewed role, security profile, clearance, and owned home domain. Get a one-liner, run it in the project folder, and redeem that exact pre-configured identity.
01
Create in Dashboard
Add an agent with a role, security profile, clearance, and home domain. CEREBRUM generates a short-lived claim token for that exact enrollment.
02
Run the Install
sage-gui mcp install --token XXXX
Run this in the project folder where your AI works.
03
Identity Claimed
The agent connects with the correct identity, role, and RBAC on its next session. Everything goes through the chain.
Dashboard-driven control. Generate signing keys, configure permissions, and rotate credentials from CEREBRUM. The only terminal step is the generated claim command an agent runs inside its project folder.
Research
Examine the evidence
The papers describe SAGE's architecture and experiments with persistent memory. Retrieval benchmarks measure how well a particular configuration finds relevant context; they do not guarantee the quality of every agent's answer.
Retrieval benchmarks. The committed LongMemEval-S run scored 499 questions: R@5 = 0.8927, R@10 = 0.9461, MRR = 0.8842. The LoCoMo run scored 1,986 questions: R@5 = 0.6394, R@10 = 0.7324, MRR = 0.5790. Both used
text-embedding-3-small, expansion of 3 and bge-reranker-v2-m3 at revision 8d77afe. These are retrieval results for those runs, not a general speed or answer-quality guarantee. Inspect the LongMemEval run data, LoCoMo run data and benchmark reproducers.
IV
→
II
→
III
→
I
→
Longitudinal Learning, the core finding
Reported experiments on repeated tasks with and without persistent memory.
Consensus-Validated Memory
A reported controlled comparison of agents with governed memory and agents without it.
Institutional Memory as Organizational Knowledge
A study of persistent institutional knowledge in multi-agent work.
Agent Memory Infrastructure
The full architecture: BFT consensus, multi-validator, RBAC, federation, for teams and enterprises
For Developers
Give your agents
a memory API.
Record useful experience, retrieve it in later sessions and inspect its origin. Connect through MCP, use the Python SDK, or call the signed REST API from your own application.
Developer quickstart
Start with a running local node.
01
Open SAGE
Download the desktop app and complete its setup in CEREBRUM. Check the node before starting another server.
curl http://127.0.0.1:8080/healthA healthy node returns {"status":"healthy"}.
02
Choose an integration
Use MCP for an existing AI client. Use Python or REST when you're building an application. All three connect to your SAGE node.
Compare the integration paths ↓03
Confirm agent access
Complete agent enrollment and review its domain permissions in CEREBRUM. SDK and REST requests use that agent's identity to determine access.
Read the agent access guide →Three ways to connect
Choose the path that fits your project.
MCP over stdio
Connect a compatible AI client to memory, recall and coordination tools. CEREBRUM helps prepare its connection. Start with sage_inception and follow the returned memory mode.
Python SDK
Use sync or async clients in your own agent workflow. The SDK signs authenticated requests for you and provides typed responses for memories, tasks and agent operations.
Try the Python quickstart ↓Signed REST API
Integrate from another language using HTTP. Agent API calls require Ed25519 request signatures, timestamps and nonces. The REST reference covers authentication, endpoints and examples.
Read the REST API reference →Python quickstart
Read memories from your application.
Requires Python 3.10+, a running SAGE node and an enrolled agent. Set SAGE_IDENTITY_PATH to its existing key file and SAGE_DOMAIN to a domain it can read. The example loads that identity and lists committed memories.
python -m pip install sage-agent-sdkquickstart.py
import os
from sage_sdk import AgentIdentity, SageClient
identity = AgentIdentity.from_file(os.environ["SAGE_IDENTITY_PATH"])
domain = os.environ["SAGE_DOMAIN"]
with SageClient(
base_url="http://127.0.0.1:8080",
identity=identity,
trust_env=False,
) as client:
page = client.list_memories(
domain=domain, status="committed", limit=3,
)
for memory in page.memories:
print(memory.memory_id, memory.content)Run with python quickstart.py. An empty list means there are no committed memories visible to this agent in that domain. Review enrollment and domain permissions in CEREBRUM if access is denied.
Next: record and recall experience.
Use propose() in a domain your agent can write to and set the memory's classification explicitly. A submitted memory starts as proposed; it becomes available to normal recall after SAGE's admission process commits it. Use hybrid() for keyword and vector retrieval with a matching embedding.
Prefer to build from source?
The source setup guide covers Go requirements, building the binary and running a node. The architecture guide explains the consensus state and memory API.
Operations
The same binary runs ops.
Backups, restores, snapshots and the app-version ladder are CLI verbs, so a deploy script can drive them without a UI.
$ sage-gui backup --full # complete stopped-node archive
$ sage-gui restore --from <archive.tar.gz>
$ sage-gui snapshot list # scheduled encrypted snapshots
$ sage-gui upgrade status # app-version ladder and pending plan
$ sage-gui status # node health
Privacy & Security
Your data stays
under your control
State lives under ~/.sage/: BadgerDB for consensus, SQLite for the serving projection, AES-256-GCM at rest when the vault is enabled. Nothing leaves the node unless you configure federation, a connector, a tunnel or a remote embedding provider, and a relay still sees connection metadata even though the payload is ciphertext.
data/badger/ # consensus state
data/sage.db # serving projection
data/snapshots/ # scheduled, encrypted
data/cometbft/ # block store and state
agents/ # per-project Ed25519 keys
vault.key # recovery key, never uploaded
config.yaml
Local by Default
No required SAGE cloud account or app usage analytics. Memories are stored in ~/.sage/. Optional connections can send data to configured destinations.
Fully Inspectable
Local data stores under ~/.sage/. Inspect them, query them, back them up, move them.
Tamper-Evident
Every memory is digitally signed with your local key. Full audit trail.
AES-256 Encrypted at Rest
When enabled, the vault encrypts memory contents at rest with AES-256-GCM. Protect the passphrase and recovery key.
Single node by default, quorum when you want it. A personal install runs one validator, so the quorum is its own signed vote. Add validators and the same state machine runs under real BFT: identical transaction paths, identical AppHash rules, a different validator set. See the Architecture Guide.