How PLUR Cut Our Agent Context Costs by 90%

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.

The problem: context is expensive and mostly irrelevant

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.

The insight: inject, don't dump

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.

What this looks like in practice

# 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 nightshift

No Zettelkasten conventions. No email conventions. No 40 other things that
aren't relevant right now.

The numbers

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.

The cost math

	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.

How memory is captured

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.

Why not just use a smaller CLAUDE.md?

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.

One-command install

npx @plur-ai/mcp init

Sets 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.

GitHub → · Benchmark → · Engram spec →