Knowledge System for
Agent Teams
Shared, persistent memory —
across sessions, projects, and scopes.
OpenClaw · Claude Code — local, crash-safe, open source.
What you can do with palaia.
Your AI agents are powerful — but they forget everything between sessions. palaia changes that.
Your agents learn and remember
Every conversation builds knowledge. Your agents remember decisions, preferences, and context — across sessions, across projects. You stop repeating yourself. They start getting smarter.
Your agent team works as a team
One agent discovers a bug fix. The others know about it immediately. No duplicate work, no conflicting changes, no lost context. Your agents share knowledge like a real team — with structure, not chaos.
Your data never leaves your machine
No cloud. No external APIs for storage. Everything stays on your filesystem. Your code, your client data, your business logic — under your control, always. No surprise bills, no vendor lock-in.
Works with your tools
Claude Desktop, Cursor, OpenClaw — or any MCP-capable tool. One pip install and a config line is all it takes. No account needed, no Docker, no database to set up. Under 2 minutes from zero to persistent memory.
Your agents know what matters
Not all memories are equal. palaia lets each agent control which knowledge gets injected — per agent, per project. High-noise entries from one agent don't pollute another's context.
Migration without the mess
Hundreds of accumulated entries? palaia curate clusters them thematically, finds duplicates, and lets you decide per cluster — not per entry. Edit a Markdown report, apply it, done.
Gets faster, not slower
Native vector search via sqlite-vec — not Python cosine similarity. Background embed server keeps the model in RAM. Sub-second queries even with thousands of entries.
From memory to knowledge.
Agent A writes a fix. Agent B doesn't know and works on the same issue. Duplicate work, merge conflicts, wasted tokens.
Project locking prevents parallel work on the same repo. Team-scoped entries visible to all agents. Inter-agent memos for direct coordination.
Everything stored as flat text. "Customer prefers CSV" lives next to "deploy runs on port 3000" — no types, no priority, no status tracking.
Memory, Process, Task — typed entries with status, priority, and assignee. Your agent knows the difference between a fact and an open task.
Your agent needs constant reminders to save context. You prompt it every time: "remember this", "write that down". Manual, fragile, forgotten.
Adaptive nudging trains your agents to self-document. Reminders fade as behavior is learned. The longer you use it, the smarter it gets.
Agent A's noisy debug logs flood Agent B's carefully curated project knowledge. No way to filter.
Each agent has injection priorities. Block entries, weight types, set score thresholds — per agent, per project. The orchestrator sees strategy docs, the coder sees API specs.
What sets palaia apart.
Multi-Agent Coordination
Inter-agent memos, project locking to prevent parallel work on the same repo, and scope isolation (private / team / public). Built for teams, not solo agents.
Zero-Cloud
Everything local. Knowledge stored as plain text files on your filesystem — SQLite holds the search index and vectors. No API keys, no data ever leaves your machine. Zero-config after install.
Crash-Safe (WAL)
Write-Ahead Logging like a production database. No data loss on crashes or restarts — production-grade crash safety that few local memory systems can match.
Structured Knowledge Types
Memory, Process, Task — with status, priority, and assignee. Decisions and workflows are first-class citizens, not text blobs.
Session Continuity
Auto-briefing loads your last session summary on startup. Auto-summaries are saved at session end via LLM or rule-based capture. Your agent always knows where you left off — no manual context-setting.
Adaptive Nudging
Trains your agents to self-document. Nudges are shown until the behavior is learned — then they stop. The longer you use palaia, the more efficient it gets.
Injection Priorities
Per-agent, per-project control over what gets injected. Block entries, adjust type weights, set minimum scores. Your orchestrator doesn't need your debugger's logs.
Automatic Tiering
HOT / WARM / COLD — frequently accessed knowledge stays fast, old entries are archived, never deleted. Active context always surfaces first.
Knowledge Curation
Cluster, deduplicate, and clean accumulated knowledge. Markdown report as interface — edit 20 cluster decisions instead of 500 individual entries. Export as portable package.
Native Vector Search
sqlite-vec for local SIMD-accelerated search, pgvector for PostgreSQL teams. ~30x faster than Python cosine similarity on large stores. Scales with your knowledge, not against it.
Sub-Second Queries
Background embed server keeps the model in RAM. No more 5-second cold starts per query. Your agent gets answers in under 500ms — memory access that doesn't break the flow.
Document Ingestion
Ingest files, URLs, and directories. Automatic chunking and embedding, stored as regular entries. PDF support with source attribution per chunk.
Memory Source Footnotes
Agent responses show where knowledge came from — your user sees which memories influenced the answer. Builds trust and transparency.
OpenClaw Plugin
Deep lifecycle integration via ContextEngine: 7 hooks from bootstrap to subagent management. Auto-capture after every turn, auto-recall before every prompt.
MCP Server
Standalone memory server for Claude Desktop, Cursor, and any MCP-capable tool. 7 tools: search, store, read, edit, list, status, gc. Read-only mode for untrusted hosts. pip install and one config line.
ContextEngine Integration
Seven lifecycle hooks for deep OpenClaw integration: bootstrap, ingest, assemble, compact, afterTurn, prepareSubagentSpawn, onSubagentEnded. Goes beyond simple prompt injection.
Not just memory. Not a cloud service. Not a RAG pipeline.
palaia is the knowledge system for agent teams — crash-safe, local, instantly ready.
How palaia compares.
Verified facts only. No marketing claims.
| Feature | palaia | MemPalace | Mem0 | Graphiti | Cognee | Letta | claude-mem | OpenClaw (native) | Claude (native) |
|---|---|---|---|---|---|---|---|---|---|
| Local-first | ~ | ~ | ~ | ||||||
| MCP Server | ~ | ~ | |||||||
| Crash-Safe (WAL) | ~ | ~ | ~ | ~ | ~ | ~ | |||
| Native Vector Search | ~ | ||||||||
| Sub-Second Queries | ~ | ~ | ~ | ~ | |||||
| SQLite Backend | ~ | ~ | |||||||
| PostgreSQL Backend | |||||||||
| Structured Types | |||||||||
| Multi-Agent Scopes | ~ | ||||||||
| Per-Agent Priorities | |||||||||
| Knowledge Curation | ~ | ~ | ~ | ||||||
| Auto-Capture | ~ | ~ | |||||||
| Adaptive Nudging | |||||||||
| MIT License | |||||||||
| Knowledge Graph | ~ | ||||||||
| Bi-temporal Queries | ~ | ||||||||
| Hybrid Search | ~ | ~ | ~ | ~ | ~ |
v2.8 — verified May 2026 from GitHub repos + official docs. ~ = partial: Mem0 local-first defaults to cloud LLM, requires Ollama for full local; Mem0 WAL is transactional, not journal mode; Mem0 SQLite is history/audit only. Graphiti runs against external graph DBs (Neo4j / FalkorDB / Kuzu / Neptune) — no SQLite/PostgreSQL native. Cognee auto-capture via Claude Code plugin hooks. Letta is cloud-first with Docker self-host option (PostgreSQL primary). claude-mem vector search uses ChromaDB (separate process); multi-agent is session-isolation only. OpenClaw (native) and Claude (native) are baselines — no third-party install, minimal feature coverage. Licenses: palaia MIT, MemPalace MIT, Mem0 / Graphiti / Cognee / Letta / claude-mem Apache 2.0, OpenClaw MIT, Claude proprietary.
Running in under 2 minutes.
Pick your tool, install
palaia works as an MCP server for Claude Desktop, Cursor — or as an OpenClaw plugin. Choose your path.
agent prompt
agent prompt
Add to your MCP config:
{
"mcpServers": {
"palaia": {
"command": "palaia-mcp"
}
}
}These tools require manual agent instruction — palaia provides the memory tools, but the agent doesn't learn proactive usage automatically.
Your agent writes knowledge
Not just text — typed entries (memory, process, task) with tags, scopes, and automatic tiering. Crash-safe via WAL.
Your agent recalls and coordinates
Native vector search across your entire knowledge base. Sub-second results. Project locking prevents conflicts. Memos enable agent-to-agent communication.
Or install standalone
Works without MCP or OpenClaw too. Full CLI access, same features.
Built for reliability.
Give your agent team a shared memory.
Fully autonomous on OpenClaw and Claude Code. MCP-compatible with any other tool.
Fully autonomous — paste and go
or standalone: pip install "palaia[fastembed]" — see docs