Why I built a proactive context curator instead of a compactor — and what I got wrong for three months

July 6, 2026

1:04

Why I built a proactive context curator instead of a compactor — and what I got wrong for three months

Here's something surprising — building a proactive context system actually works better than waiting to compress everything after it’s full. Most AI agents react only when the context window is packed, but /u/Reasonable_Craft_425 spent months experimenting with a different approach. The idea was to prioritize what gets added at each turn, so noise never piles up. Turns out, early semantic recall was quietly broken — using a placeholder embedder that injected noise, making irrelevant info float to the top. It looked fine but was wrong for weeks until a switch to keyword-only recall fixed it. Also, measuring success was another challenge — without proper telemetry, ‘feels better’ isn’t proof. As /u/Reasonable_Craft_425 explains, transparency about limits isn’t just ethical, it’s strategic. The ultimate plan? Four domain-agnostic systems that adapt and recall efficiently, with the coding agent proving the concept. If this pattern holds, future AI tools will be those that truly understand what matters — before noise ever accumulates.

Two ways to handle a context window that's filling up.

Reactive: wait until it's full, then compact everything. Proactive: be picky about what gets added every turn so noise never piles up in the first place.

Most coding agents take the reactive path. I spent months building the proactive one, and I want to be honest about what actually worked and what didn't.

What held up

A decision your agent made on turn 3 is worth more tokens than tool output from turn 15 that's already resolved. Treat them the same and you get context rot. PRAANA's compiler splits working memory into active, soft, and hard tiers. It scores context units by information density, then uses BM25 plus semantic similarity (Transformers.js, running in-process) to decide what gets pulled back into the active window.

What I got wrong — semantic recall was quietly broken for weeks

I threw together a hash-based embedder early on as a placeholder. The problem was it was injecting noise into recall ranking. Memories came back in the wrong order, irrelevant items floated above relevant ones. The worst part: it looked plausible. No errors, just wrong answers. Took three weeks to even notice. I fixed it by switching to Transformers.js with keyword-only full-text search as the fallback. New rule: if there's no real semantic embedder available, you get keyword-only recall. No fake vectors, ever.

The measurement gap

For most of the project, I couldn't actually prove the context engine beat a plain transcript agent. "Feels better" doesn't count as evidence. A telemetry scorecard landed a few weeks ago — session-level signals like context pressure, memory recall percentage, skill load and decay, per-section token accounting. The A/B evaluation harness is next. Lesson learned: build the measurement before you build the thing you're trying to measure.

The honesty problem in agent marketing

PRAANA's memory stores and recalls with time decay. The reinforcement path — boosting confidence when a session succeeds — is wired up, but the signal that actually triggers it hasn't shipped yet. So I call it "stores and recalls" until that loop closes and I can show it working. A user who sees memory surface a stale belief at high confidence loses trust in the whole system. Publishing your limits before your benchmarks isn't just an ethics call — it's a product decision.

The larger plan

Four systems: Adaptive Context, Cognitive Memory, Background Consolidation, Intelligent Router. All domain-agnostic. Nothing in the system knows anything about code specifically. The coding agent is just the proving ground because outcomes are easy to measure: did the code work, how many turns did it take, did it avoid repeating the same mistake from last session. Phase 2 is extracting the runtime so other developers can build domain agents on top of it. I'm not touching that extraction until Phase 1 validates the architecture. That discipline has been the hardest part of the whole project.

GitHub: amitkumardubey/praana — MIT, TypeScript, Bun.

submitted by /u/Reasonable_Craft_425
[link] [comments]

Audio Transcript