Hippo Core works quietly behind Codex, Claude Code, Cursor, and any MCP agent. It recalls what matters, remembers what lasts, and shows you the context tokens it avoids. No separate AI model required.
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 explain it again. 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 to 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 to 500
tokens of targeted context, with only what is 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 and 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.
Install it once. Hippo Core connects to supported agents and supplies the background memory policy automatically. No prompts, buttons, or daily upkeep.
01
Task starts
Agent calls hippo_recall automatically. It gets the most relevant memories for this exact task, not everything.
→
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
Every recall records the full eligible context, what was actually injected, and the difference. The dashboard makes the value visible.
Real-time monitoring
Watch your agents save tokens in real time.
Every recall compares the context your agent could have reloaded with the focused memory Hippo Core actually supplied. The result is a transparent context estimate, not a made-up billing claim.
defaultdefaultmcpContinue the product roadmap...3,9407103,230
defaultdefaultmcpUpdate the index page...2,6764282,248
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. Compare context without Hippo Core against what was injected, with savings updated every 15 seconds.
🔒
Local First
All memory stays on your machine. The default memory engine works offline without an account, API key, or separate AI model.
🏷️
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.
No model required · optionally add your preferred provider
Built-in offline mode ★ defaultOllama ★ free & localOpenAIOpenRouterGroqLM Studio ★ free & localAzure OpenAIAny OpenAI-compatible API
Quick start
One install. Then it disappears.
# Install Hippo Core and connect detected AI agents
npx @hippo-core/core install
# No model, API key, account, or cloud service required.
# Hippo Core now recalls and remembers automatically.
# Open the local dashboard whenever you want proof
npx @hippo-core/core dashboard
# → http://localhost:4444
# Done. Keep using your agents normally.
# 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 and inject them into the 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;
}
