Every session, your AI agents reload the same context from scratch — burning thousands of tokens just to know who they're talking to. Hippo Core gives agents persistent, shared memory so they start every session already knowing everything.
AI agents are burning your money on context they've already seen.
Without memory, every session starts from zero. Your agent has to reload everything — or ask you to re-explain everything. That costs tokens. That costs time. That costs money.
Without Hippo Core — Every Session
Session 1: "Tell me about my project" → agent asks 6 clarifying questions
Session 2: "Continue where we left off" → agent asks the same 6 questions
Session 3: "You already know this project..." → agent has no idea
Every session reloads your entire codebase, specs, and preferences just to get to where you left off.
~5,000–50,000
tokens burned on context every single session
With Hippo Core — Every Session
Session 1: Agent learns your project, stack, preferences, decisions
Session 2: Agent already knows — "Continuing the OpenClaw landing page. You're using React + Tailwind, preferred dark theme, last added pricing section."
Session 3+: Agent builds on everything it's ever learned. No re-explaining.
~100–500
tokens of targeted context — only what's relevant
★ Industry First
Cross-agent shared memory
Your entire AI workforce shares the same memory.
No other memory layer does this. Claude Code builds your app. Paperclip manages your company. OpenClaw handles your customers. They all share one memory store — so every agent knows what every other agent has learned.
Claude Code
builds your landing page
🦞
OpenClaw
handles customer support
Paperclip
runs your company ops
Cursor
codes your features
⟷
🦛
Shared Memory Store
~/.hippo-core/memory.db
1
Database
∞
Agents
0
Infrastructure
Local
Your machine
🔗 Agent Namespacing
Each agent has its own namespace — but can also read shared org-wide memory. Claude Code's learnings are available to Paperclip and vice versa.
🔒 Local & Private
Everything stays on your machine. One SQLite file. No cloud account, no Docker, no servers. Works fully offline with Ollama.
⚡ Real-Time Sync
All agents read from the same file in real time. The moment Claude Code stores a memory, Paperclip can recall it in the next session.
How it works
Four steps. Automatic.
Hippo Core sits between your agents and your users. Agents call it automatically — no user intervention needed.
01
Task starts
Agent calls hippo_recall automatically. Gets the most relevant memories for this exact task — not everything, just what's needed.
→
02
Context injected
Top memories injected into the system prompt. Token budget enforced. Agent starts the task already knowing the full context.
→
03
Task completes
Agent calls hippo_remember automatically. Stores what it learned, decided, and built. All other agents can now access this.
→
04
Gets smarter
Importance scores updated by access patterns. Noise compressed daily. The more agents work, the better the memory gets.
Real-time monitoring
Watch your agents save tokens in real time.
Every memory recall logged. Every token counted. Open the dashboard and watch the numbers move as your agents work.
🦛 Hippo Core Dashboard v0.6.0 — localhost:4444
712
Tokens Injected
5
Total Recalls
102
Avg Tokens / Recall
153ms
Avg Recall Time
UserAgentFrameworkQueryMemoriesTokensLatency
defaultdefaultmcpOpenClaw landing page dark mode...22752965ms
defaultdefaultmcpOpenClaw landing page2275153ms
defaultdefaultmcppage I was working on, web design1162947ms
Connect in one click
🤖 Claude Code
🦞 OpenClaw
📎 Paperclip
🖱️ Cursor
⚡ Hermes
🧠 Codex
💬 Claude Desktop
+ any MCP framework
Features
Everything you need. Nothing you don't.
🔗
Cross-Agent Shared Memory
Industry first. All your agents share one memory store. What Claude Code learns, Paperclip can recall. No other tool does this.
📦
Zero Infrastructure
Single SQLite file. No Docker, no Postgres, no cloud. Works on any machine with one npm install. Your data stays on your machine.
🧠
Semantic Retrieval
Vector embeddings with cosine similarity. Memories ranked by relevance + importance. Only the most relevant context gets injected.
⚡
Token-Aware Injection
Hard token budget enforced on every recall. Highest-ranked memories in first. Never blows up your context window.
📊
Real-Time Dashboard
Built-in monitoring at localhost:4444. Watch tokens, recalls, and memory growth update live as your agents work.
🔒
Local First
All memory stays on your machine. Works fully offline with Ollama. No data sent anywhere except your configured LLM calls.
🏷️
Agent Namespacing
user_id, agent_id, org_id. Scope memory to a user, an agent, or your entire org. Mix and match for the right level of sharing.
📉
Auto Compression
Old memories compressed into profiles. Noise pruned automatically. Importance scores decay. Gets smarter the more you use it.
🔌
MCP Native
Built-in MCP server. Connect to any MCP-compatible framework with one command. No plugins, no wrappers, no code changes.
Works with any AI provider
Ollama ★ free & localOpenAIOpenRouterGroqLM Studio ★ free & localAzure OpenAIAny OpenAI-compatible API
Quick start
Up and running in 2 minutes.
# Step 1 — Install
npm install -g @hippo-core/core
# Step 2 — Run the setup wizard
npx @hippo-core/core setup
# Choose your provider: OpenAI, Ollama, OpenRouter, Groq, LM Studio
# Step 3 — Open the dashboard
npx @hippo-core/core dashboard
# → http://localhost:4444
# Step 4 — Connect your frameworks
# Click "Connect" next to Claude Code, OpenClaw, Paperclip, Cursor...
# Done. Your agents now have shared persistent memory.
# Claude Code integration (one command)
claude mcp add hippo-core node ~/.hippo-core/mcp-server.js mcp
# Or let the dashboard do it:
npx @hippo-core/core dashboard
# → Connections tab → Click "Connect" next to Claude Code
# Add to ~/.claude/CLAUDE.md for automatic memory:
## Memory (Hippo Core)
At the START of every task, call hippo_recall with the task description.
At the END of every task, call hippo_remember to store what was learned.
Never ask the user — call these automatically, every time.
// Any framework — 2 lines
import { createMemory } from '@hippo-core/core';
const memory = createMemory({
apiKey: process.env.OPENAI_API_KEY,
agentId: 'my-agent', // namespace this agent's memories
orgId: 'my-company', // share memory across all company agents
});
async function runAgent(userId, userMessage) {
// Before — retrieve relevant memories, inject into prompt
const { systemPrompt } = await memory.before(
userId, userMessage, 'You are a helpful assistant.'
);
// Run your agent with memory context already injected
const response = await yourAgent(systemPrompt, userMessage);
// After — store what was learned
await memory.after(userId, userMessage, response);
return response;
}
