Every quarter produces a handful of Show HN posts that describe not a new model but a complaint about models. Between August and October 2026 a striking number of them were the same complaint, phrased differently: the intelligence is fine, the context around it is not. Agents forget between sessions. Tool schemas eat the window. Nobody can say why a quota emptied out overnight.
What follows is not a ranking and not a buyer's guide. It is a set of projects from Hacker News that each tackle one slice of the context problem, with enough detail about what they actually do that you can tell which slice you have.
Why memory became the first-class problem
An agent starts a session by reading. It reads your instructions, your repository layout, the files you mentioned, the conversation so far. All of that is a guess about what matters, and all of it is paid for a second time on the next turn, because the model does not remember the previous turn. At some point the ratio of re-read material to new work becomes the dominant cost of the whole tool.
Two projects in this batch attack that directly from opposite directions.
OKF Agent Memory stores agent memory in git. It implements Google's OKF v0.2 specification, does its recall with in-memory BM25 search measured in the sub-300-microsecond range, and ships an embedded MCP server so a client can query it without a bespoke integration. Being written in pure Go with no external database dependency is the detail that matters operationally: the whole persistence story is a repository you already know how to diff, review and back up.
MCP Memory takes the same specification and wraps it as a Model Context Protocol server backed by SQLite FTS5. The trade-off is explicit. You lose the vector-database style semantic matching, and you gain a single file and a keyword search that behaves predictably. For teams whose memory is mostly short factual notes rather than fuzzy prose, this is the cheaper and more debuggable choice.
Neither tool makes an agent smarter. They change the arithmetic of how much it has to re-derive every session, which is where most of the felt cost lives.
Trimming what goes into the window
A second family of tools in this batch is not about storage at all. It is about reducing the volume of what reaches the model in the first place, which turns out to be easier than improving what the model does with it.
Mcptoon is the most aggressive example. It is a zero-dependency Python CLI that sits between an MCP client and the MCP servers and skills that client would otherwise load. Its claim is that full tool schemas are what eat a context window, so it keeps them out and offers a compact index the agent searches only when it needs a specific tool. One configuration covers Claude Code, Codex and Cursor, which turns out to be the reason people try it: not the compression, but the fact that they can maintain one config instead of three.
Ctrlb Decompose applies the same idea to a different input. Raw logs are enormous and mostly repetition, and pasting them into a model is both expensive and unreliable. It builds what the project calls an LLM-ready reasoning surface over logs, collapsing the noise so only the signal reaches the prompt. The risk with any compression step is dropping a line that later turns out to be the one that mattered, and that is a real trade-off rather than a solved problem.
AxiomCode Graph goes further upstream and replaces retrieval with structure. It turns a codebase into a knowledge graph grounded in formal methods, so structural questions such as what a signature change actually touches are answered by lookup rather than by probabilistic recall. The appeal is specifically for codebases large enough that grep-based agent loops visibly stall, which is the same population that is complaining about tokens.
Making the money legible
The third theme in this batch is boring and overdue: accounting.
Tare answers a question several agent CLIs still do not. You hit a limit, you know a quota was consumed, and you have no idea by what. Tare performs token audit, limit diagnosis and usage forensics from the session logs already sitting on your machine, and nothing leaves it. For anyone who has tried to answer this by scrolling a transcript, the appeal is immediate.
Pacer moves the same signal somewhere you actually look. It is a macOS menu-bar monitor for Claude Code, Codex, Antigravity and Cursor that estimates whether current burn will last until the reset window. Covering several subscriptions in one place matters more than it sounds, because the practical failure mode is not one quota emptying but four of them emptying at inconveniently different times.
The softer end of this family is Claude Thermos, which does something almost trivial: it keeps an idle session alive. That is a context-preservation move. Rebuilding a large context window that took twenty turns to assemble is one of the most expensive accidental actions a developer can take, and a small tool that prevents it is disproportionately valuable.
Shape of the output
The last pair of tools in this batch changes what the agent hands back, on the theory that unreadable answers waste more attention than wrong ones.
Vomit routes verbose model output through a separate, cheaper LLM so a condensed version lands in the main conversation instead of the raw stream. It is a narrow idea, but it addresses the single most common failure of agentic coding: a correct five-line answer buried in five hundred lines of narration that then cost you context to store.
I Have ADHD is even narrower and more direct. It is a skill that forces the agent to lead with the answer rather than burying it after an explanation. It costs almost nothing to adopt, which is why it spread the way it did on Hacker News.
Choosing between these
The honest summary is that these ten tools are not competing. They occupy a pipeline: memory at the bottom, then compression, then structural lookup, then accounting, then presentation. A team that adopts only one of them will feel a smaller effect than one that takes one from each layer.
The practical order is accounting first, because it is free to try and tells you which other layers are worth the effort. Install Tare or Pacer, find out where your tokens actually go, then decide whether you need OKF Agent Memory or Mcptoon. Engineering experience from this batch suggests that the teams who skipped the step of measuring usually adopted the wrong tool for their actual bottleneck.
What unites all ten is a shift in where the leverage is. The models kept improving and got cheaper per unit of capability. The cost moved to everything around them, and these projects are the first generation of tools that treat that as the problem worth solving.
