SAGE v11.19.19 · governed local memory · controlled agent collaboration

Your AI's memory, visible as a living brain

SAGE gives Claude Code, Codex, Cursor, Windsurf, and any MCP-capable agent one local memory node: semantic recall, attributed memory, encrypted storage, and a CEREBRUM dashboard built around the 3D MRI brain.

Local-firstBadgerDB/SQLite + optional AES-256
Semantic recallOllama + managed reranker
FederationLAN / VPN / internet
Download SAGE
macOS Windows Linux
Latest: v11.19.19 — signed release assets
Package downloads: 8,312
Last known count · Sep 10, 2026, 01:26 UTC
Public release installers and archives, including prereleases. Counts repeat and automated downloads, not unique installs.
Install in minutes

Download it, open CEREBRUM, connect your AI.

v11 is dashboard-first. The onboarding flow handles semantic memory, AI-tool connection, and setup recovery without making users edit config files by hand.

Or tell your AI to connect itself

Click to copy the MCP bootstrap prompt and paste it into any agent session that can edit its project folder.

Connect to SAGE persistent memory: fetch http://localhost:8080/v1/mcp-config and save the response as .mcp.json in this project root. Then restart your session and initialize SAGE memory.
CEREBRUM MRI brain
MRI Brain
Recall Engine
Recall Engine
Overview dashboard
Overview
Federation dashboard showing LAN and internet SAGE-to-SAGE links
Built through v11.19.19

Keep agents connected, governed, and safely up to date.

CEREBRUM is the local control plane for memory, agent access, recovery, and sharing. Existing nodes upgrade in place; memory history stays attributable while current access remains explicit and reviewable.

  • A dedicated local CEREBRUM Root governs roles, ownership, recovery, and handover without rewriting historical authorship.
  • Trusted peers running v11.19.16 or later can discover and message eligible agents automatically. Memory domains stay private until you explicitly share them.
  • Explore connected nodes in a live federation map, find agents in the searchable directory, and prepare Read or Copy permissions before saving them.
  • Updates verify release assets and bring compatible chains forward automatically; recovery isolates a bad historical record instead of taking the node offline.
Install v11

Local by Default

No required cloud account or telemetry. Memories stay under ~/.sage/ unless you explicitly enable federation, sync, or a connector.

AES-256 Encrypted

Optional encryption at rest. If your laptop is stolen or synced to the cloud, nothing is readable.

Tamper-Evident

Every memory is digitally signed. Full audit trail — verify nothing has been altered or injected.

Works With Any MCP Client

Claude, Cursor, Cline, DeepSeek, Gemini, LM Studio, Ollama — any model, any provider.

Open Source · Apache 2.0

Get started

Give your AI memory that persists across sessions, validates what it learns, and improves measurably over time.

Download SAGE

macOS · Windows · Linux · Source on GitHub

Capabilities

Memory infrastructure for AI agents

Governed institutional memory — validated by BFT consensus, scored by confidence, and decay-aware over time.

What's new in v11.19.19

The latest release updates gRPC-Go to v1.83.2 for a security fix. It builds on recent improvements to trusted-node messaging, the federation connectome, and memory cleanup. Existing nodes upgrade in place with no consensus or storage migration. Read the release notes →

Security update

v11.19.19 includes the gRPC-Go fix for CVE-2026-84445. macOS installers are signed and notarized, and release downloads include checksums.

See your federation

Explore connected nodes and agent clusters in a searchable map or List view. Live transport activity and visible agent orbits make the network easier to follow, with pause and reduced-motion controls.

Connect nodes, find agents

Trusted peers running v11.19.16 or later automatically expose eligible agents for discovery and messaging. Root identities stay excluded; memory sharing still needs an explicit Read or Copy grant.

Review cleanup before it runs

Memory cleanup scans the full inventory, previews eligible records, and processes changes through consensus. Open tasks and internal records are protected, with progress shown through observed outcomes.

Persistent Memory

Memories persist across every conversation — projects, preferences, decisions, prior outcomes. Nothing is lost between sessions.

Governed Knowledge

Memories are validated before being committed. Spurious data is filtered out; corroborated data is reinforced.

Confidence Scoring

Memories strengthen with corroboration and decay without reinforcement — analogous to human episodic memory.

Semantic Search + Reranker

Recall by meaning with local embeddings, then re-score with a self-installing local reranker. Everything on your machine.

Learns From Outcomes

Stores what worked and what failed. Published research shows agents with this feedback loop improve measurably over time.

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.

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.

Fully Inspectable

Local BadgerDB/SQLite stores under your home directory. Inspect, query, back up, and move your data.

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.

Auto-Journal

Pipeline exchanges are summarised as memories automatically. Full audit trail of inter-agent work without storing bulky payloads.

Agent coordination

Durable work.
Explicit ownership.

Available in v11.19.19: 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 do not 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 cannot 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

CEREBRUM MRI brain
MRI Brain
Federation
Federation
Recall Engine
Recall Engine
FAQ

Questions before you install

What is SAGE?

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.

Is this just a vector database?

No. SAGE stores memories with signatures, consensus validation, confidence scoring, decay, clearance, domain permissions, full-text search, semantic recall, and optional local reranking.

Where does my data live?

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.

Which AI tools can use it?

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.

What changed in v11?

v11 adds CEREBRUM, guided setup, semantic recall, controlled federation, and in-place upgrades. Recent releases add automatic trusted-node agent messaging, a live federation connectome, explicit sharing drafts, and safer memory cleanup. v11.19.19 brings the latest gRPC security patch.

What does federation mean?

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 cannot gain local write, ownership, role, or Root authority through federation.

Getting Started

Three steps to get started

Install SAGE, paste the config into your AI client, and start working. Memory builds automatically across 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

Your AI uses memory tools automatically. Projects, preferences, decisions — persisted across every session.

Interactive Setup Wizard →
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.

ChatGPT setup instructions →
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.

  1. 1Settings → Data Controls → Export
  2. 2Download the ZIP from OpenAI’s email
  3. 3CEREBRUM → Import → drop ZIP

From Claude

Export Claude.ai conversations and import them.

  1. 1Settings → Privacy → Export
  2. 2Download Anthropic’s export file
  3. 3CEREBRUM → Import → drop file

From Gemini

Export via Google Takeout and import.

  1. 1Takeout → Gemini Apps
  2. 2Download the archive
  3. 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

Agents that learn from
experience, not instructions

AI agents with persistent memory get measurably better over time. Without memory, they show essentially zero improvement no matter how many sessions you run.

Retrieval benchmarks. SAGE on LongMemEval-S (Wu et al., ICLR 2025, 500 questions): R@5 = 0.8927, R@10 = 0.9461, MRR = 0.8842. On LoCoMo (Maharana et al., ACL 2024, 1986 questions): R@5 = 0.6394, Hit@5 = 0.6954; scored via mem0's published LLM-judge harness: 0.7656. Every write goes through BFT consensus; the local semantic recall and reranking stack ships in v11. Reproducers live in bench/.
IV

Longitudinal Learning — the core finding

AI agents with memory get better over time. Without memory, they don't learn at all.

→ II

Consensus-Validated Memory

50-vs-50 controlled study: agents with governed memory outperform memoryless agents on complex tasks

→ III

Institutional Memory as Organizational Knowledge

Agents that learn their jobs from experience, not instructions — the “new hire” problem solved

→ I

Agent Memory Infrastructure

The full architecture: BFT consensus, multi-validator, RBAC, federation — for teams and enterprises

→
For Developers

Local memory infrastructure
with real developer hooks

Run SAGE as a local memory server, then connect through MCP, REST, or the Python SDK. The dashboard handles setup; the APIs stay available when you need automation.

terminal
# Clone and build
$ git clone https://github.com/l33tdawg/sage.git && cd sage
$ go build -o sage-gui ./cmd/sage-gui/
 
# Setup wizard (opens browser, generates MCP config)
$ ./sage-gui setup
 
# Start SAGE
$ ./sage-gui serve
SAGE ready
  Dashboard: http://localhost:8080/ui/
 
# Or use the Python SDK
$ pip install "sage-agent-sdk>=11.19.19"
Go 1.25.13+
Python SDK
BadgerDB + SQLite
MCP protocol
REST API
Apache 2.0
Privacy & Security

Your data stays
under your control

SAGE runs locally, with memories stored in BadgerDB/SQLite under your home directory. Only data you explicitly authorize for federation, synchronization, or a connector leaves the node; relays carry ciphertext while still observing connection metadata.

CEREBRUM MRI - active brain scan

Local by Default

No required cloud account or telemetry. Memories stay in ~/.sage/ unless you explicitly choose to share them.

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

Optional encryption for the memory vault. If your machine is stolen, the on-disk memories remain unreadable.

Scales to enterprise. SAGE is the single-node edition. Add agents from the dashboard for multi-agent networks, or deploy full multi-validator BFT consensus. Same codebase, same API. See the Architecture Guide.