The short answer: The bottleneck isn’t model intelligence — it’s context. You’re paying to send the same 3,000 tokens of background facts on every turn, 90% of which the agent doesn’t need. PLUR injects only what’s relevant. Haiku + PLUR now outperforms Opus without memory at 1/10th the cost.
Every AI team eventually hits the same wall. Your agent knows how to code, write, and reason. But it doesn’t know your things: your deployment servers, your tag conventions, which of your hundred tools handles which task, the decision you made six months ago and why.
The instinct is to put all of it in the system prompt. A CLAUDE.md or
AGENTS.md file that grows to 3,000 words. You send it on every turn — most
of it irrelevant to what the agent is doing right now.
At $15 per million tokens for Opus, that’s $0.045 per turn just for the system prompt. Multiply by a team of 5 developers, 200 turns a day each, and you’re spending $45/day on context the agent mostly ignores.
The deeper problem: it doesn’t even work. An agent asked to “deploy the trading module” doesn’t need the 400-word section on Zettelkasten conventions. It needs the 5 lines about your deploy target. Burying those 5 lines in 3,000 tokens of noise is how you get agents that apply the wrong server or skip the smoke test.
Human experts don’t memorize everything before starting a task. They pull from memory on demand, surfacing only what’s relevant to right now. An agent should work the same way.
PLUR stores knowledge as engrams — small, typed assertions that strengthen with use and decay when irrelevant, modeled on human memory (ACT-R activation). Each turn, a fast local search (BM25 + BGE embeddings, no API calls) selects the 5–10 most relevant engrams for the current task and injects only those into context.
Instead of 3,000 tokens of background, you send 200–400 tokens of targeted memory. The agent has exactly what it needs. Nothing it doesn’t.
# Task: "deploy the trading module to production"
# Injected automatically (5 engrams, ~280 tokens):
deploy target: nightshift (not prod) — SSH alias: nightshift
trading module lives in 0-personal/trading/
deployment: git pull + systemctl restart plur-trading
never push to main directly — PR required
smoke test: python test/smoke.py --env nightshiftNo Zettelkasten conventions. No email conventions. No 40 other things that aren’t relevant right now.
We ran head-to-head tests: the same task, the same agent, with and without PLUR memory. 28 scenarios across Haiku 4.5, Sonnet 4.6, and Opus 4.5. The question was whether PLUR memory changes which model wins.
Result: 31 wins, 4 losses — 89% win rate across all models.
The clearest result was house rules — tasks that require applying organization-specific knowledge (tag conventions, file routing, deployment procedures). Without PLUR, agents got these right 10–38% of the time depending on model:
| Config | House rules | Win rate |
|---|---|---|
| Opus (no memory) | 38% | baseline |
| Sonnet (no memory) | 22% | — |
| Haiku (no memory) | 10% | — |
| Haiku + PLUR | 12–0 | 89% |
Haiku with PLUR memory beat Opus without memory in 89% of decisive contests. The model didn’t get smarter — it got the right context instead of noise.
On LongMemEval (retrieval benchmark), PLUR scores 97.6% Hit@5 on the 500-question suite using hybrid BM25 + embedding search. Zero API calls. All local.
| Config | Cost per turn | Quality | |
|---|---|---|---|
| Before | Opus + 3k-token system prompt | ~$0.045 | House rules: 38% |
| After | Haiku + PLUR injection (~300 tokens) | ~$0.002 | House rules: 100% |
That’s a 95% cost reduction with a 2.6× improvement in the tasks that actually require knowing how your organization works.
The math holds at any scale. At 1,000 turns/day (a small team), the before/after is ~$45/day vs ~$2/day — $43/day saved while the agent performs better.
PLUR hooks into your session lifecycle. When you correct your agent, it learns:
# You say: "no, deploy goes to nightshift, not prod"
# PLUR captures automatically:
plur_learn("deploy target: nightshift (not prod) — SSH alias: nightshift")When the agent discovers a convention or makes a decision, same thing. Over time, it accumulates a model of how your world works — not as a static document, but as a searchable, weighted knowledge graph.
Engrams decay. A convention from a codebase you refactored six months ago stops appearing in context on its own. No manual curation needed.
You could. But “smaller” has a ceiling — you’ll always need more context than a curated static file can hold without growing unwieldy again. And a static file can’t learn. It can’t prioritize. It sends the same facts regardless of what task the agent is doing.
PLUR’s injection is task-aware. The same knowledge base surfaces different engrams for “deploy trading module” vs “write a blog post” vs “review this PR.” The agent sees its world through the lens of what it’s doing right now.
npx @plur-ai/mcp initSets up storage (~/.plur/), MCP config, and Claude Code hooks in one step.
Restart your editor. Memory works from the next session.
For Cursor, Windsurf, or any MCP-compatible client:
{
"mcpServers": {
"plur": {
"command": "npx",
"args": ["-y", "@plur-ai/mcp"]
}
}
}Memory lives in ~/.plur/ — plain YAML files, human-readable, zero cloud
dependency. Sync across machines with plur_sync (git-based).
Open source. Apache 2.0. Works with Claude Code, Cursor, Windsurf, and any MCP
client. Python agents: pip install plur-hermes.