Local adaptive memory for AI coding agents through a five-tool MCP lifecycle.
io.github.slowave-ai/slowave β MCP Server
The io.github.slowave-ai/slowave Model Context Protocol (MCP) server provides local adaptive memory for AI coding agents. It operates through a five-tool MCP lifecycle, enabling coding agents to manage and use locally stored context during their interactions.
π οΈ Key Features
Local adaptive memory
Five-tool MCP lifecycle for agent workflows
π Use Cases
AI coding agents that require local, adaptive memory
Agent workflows that follow a five-tool MCP lifecycle
β‘ Developer Benefits
Clear lifecycle structure based on five MCP tools
Local memory behavior aligned to coding-agent needs
β οΈ Limitations
Description only specifies βlocal adaptive memoryβ and a βfive-tool lifecycleβ; no additional capabilities are stated
Slowave is a local MCP memory server that carries your decisions, constraints, and procedures across your coding sessions and AI tools.
Slowave adapts as you use it, building reusable context over time so your agent can learn from past experience.
It runs on your machine and requires no LLM API key for memory maintenance. The local dashboard lets you inspect what your agent remembers and which memories it finds valuable.
At the core Slowave is built around a simple concept:
Reasoning and memory feed each other in a continuous loop.
graph LR
LLM["Reasoning<br/>(Claude, Codex, Copilot, etc.)"]
MEM["Memory<br/>(Slowave)"]
LLM -->|Feedback| MEM
MEM -->|Retrieve| LLM
MEM -->|Adapt| MEM
Slowave retains what helps agents achieve their goals, weakens what does not, and continuously adapts based on use. It does this through a continuous feedback loop between your agent and its memory. It works on 5 simple MCP endpoints:
If you are in the middle of a coding client session while upgrading you might have to close the session and re-open it (via /resume command or similar, depending on client).
IMPORTANT
Upgrading with existing memories?slowave setup rebuilds the vectors that
search reads. To rebuild every vector (consolidation, cue matching and graph
views) and reclaim unused space, run the migration in
Rebuilding embeddings.
Workflow
You keep working with your agent as usual.
You can switch agents or start new sessions.
Slowave enriches your agents context with relevant memories and procedures. Your agent feedbacks Slowave on what was useful. Slowave keeps building relevant context for your agents in the background.
sequenceDiagram
actor User as You
participant Agent as Your Agent<br/>(Claude Code, Codex, etc.)
participant Slowave
participant Worker as Slowave Worker
User->>Agent: Prompt
Agent->>Slowave: Activate: Start task (set goal)
Slowave-->>Agent: Relevant memories and procedures
opt
Agent->>Slowave: Remember: Save new knowledge
end
opt
Agent->>Slowave: Recall: Look up more context
Slowave-->>Agent: Matching memories and procedures
end
Agent->>Agent: Reason upon enriched context, work on the task
Agent->>Slowave: Feedback: Assess retrieved context
Agent->>Slowave: Commit: Record outcome
Slowave-->>Agent: Task outcome saved, session closed
Agent-->>User: Deliver the result
Worker->>Slowave: Consolidate, reinforce, decay memories
Dashboard
The local dashboard shows what Slowave is actually doing with your agent's memory over time: what it remembers, what it retrieves, and what your agent reports using.
As your history grows, you can follow a memory from where it came from to the tasks where it was later retrieved and used. You can inspect learned procedures, see when retrieved context was useful or irrelevant, and understand whether Slowave is helping your agent reuse past work rather than simply accumulating memories.
Start the dashboard with:
bash
slowave dashboard
From the dashboard you can:
Inspect memories: see what was saved, where it came from, its current state, and when it was later retrieved or used.
Inspect procedures: review reusable methods captured from previous work and see when they are retrieved and reused.
Trace retrievals: see the request, the context Slowave actually returned, and the feedback reported by the agent.
Follow sessions: open the session behind any memory, procedure, or retrieval and step through its ordered Slowave calls, feedback, and linked memories.
Explore memory connections: browse relationships and associations between memories.
Check system health: inspect the database, background maintenance, backups, and local services.
The overview also helps answer whether the memory loop is working: how many memories and procedures exist, how often retrieved context is reported as used, how much is marked irrelevant, whether feedback is being recorded, and how creation, retrieval, and use change over time.
Slowave also shows a rough estimate of the context returned through all MCP endpoints, so you can keep an eye on memory overhead.
Supported clients
Client coverage is actively expanding. Suggest more integrations or report broken ones with setup details.
β = supported. Copilot validation limits are listed below.
Copilot support targets local CLI execution. Automated integration tests pass, and
native configuration discovery is verified on macOS. A user also confirmed memory
reads and writes through Copilot CLI on macOS. Full model-driven lifecycle and native
Windows/Linux qualification remain pending. IDE, desktop, and hosted/cloud
Copilot support is deferred.
IMPORTANT
The default embedding model downloads from Hugging Face on first use (~45 MB, cached locally). Subsequent runs work offline.
Memory is stored in plaintext in the current OS user's application-data directory. Slowave does not send it to a hosted memory service. See runtime data location.
How Slowave memory works
Slowave works through 5 simple MCP tools:
Activate: start a task and load relevant memory.
Remember: save a fact, decision, preference, or instruction.
Recall: search memory during a task.
Feedback: assess retrieved memories as used, not_used, unassessable, irrelevant, already_known, or stale.
Commit: save the task outcome and any reusable procedure.
A background worker consolidates relevant memories and procedures.
Slowave MCP lifecycle
flowchart LR
A[Agent task] --> B[1. <i>activate</i><br/>start session]
B --> C[Scoped retrieval<br/>and session]
C --> D[Agent reasoning]
D --> E[2. <i>remember</i><br/>durable claims]
D --> F[3. <i>recall</i><br/>mid-task lookup]
C --> G[4. <i>feedback</i><br/>target assessments]
F --> G
E --> H[5. <i>commit</i><br/>outcome and verification]
G --> H
H --> I[(Local SQLite<br/>raw events and evidence)]
I --> J[Offline consolidation]
J --> K[(Episodes, prototypes,<br/>schemas, relations)]
K --> C
Slowave is a memory layer, not a reasoning engine.
It cannot recall information that was never recorded.
Memory quality depends on the client agent and the feedback it provides.
Slowave adds token overhead from tool calls and retrieved context.
The local SQLite database is plaintext by default; protect it with OS permissions or full-disk encryption.
IMPORTANT
Slowave is public beta software. APIs, configuration, and storage schema may change, and migrations are not guaranteed before stable release.
Evaluation
The current evaluation notes report preliminary retrieval-evidence results,
methodology and limitations. They do not claim end-to-end agent accuracy or a
comparison against other memory systems. See benchmarks.md
before treating any result as a production-quality claim.