If you read a week of Show HN launches about coding agents, almost all of them are aimed at the same wall. The model is capable enough; what breaks is what it can see. Some teams attack the input side by indexing what the agent should read, some attack memory by letting it expire, some build a map of the codebase, some compress what is already in the window, and some change the shape of the work so several agents share it. This batch has a credible entry in each category.
Indexing what the agent should have read
Enzyme is the most literal version: a local-first compile step for knowledge bases. It reads how your Markdown notes are already organised, using the folders, tags, links and dates you chose, and builds a local index so Claude Code or Codex can query the wiki instead of re-reading it. The project claims roughly 350x lower cost and 1000x faster retrieval than handing the same notes to a frontier model, and while that is the authors' own number, the direction is obviously right: notes have structure, and re-reading them to recover that structure every session is waste.
Memory that admits when it is wrong
The failure mode of agent memory is not forgetting, it is confidently remembering something that stopped being true. Mnemolith makes staleness a first-class state: it is shared local memory for Claude Code, Cursor and Codex, and a memory goes stale when the file it describes changes, so editing docker-compose.yml flags the memory that described it for you to record what is true now. It was formerly called Aether Cache, and existing memories carry over.
Rubi approaches the same problem as a graph. It builds a code map ranked with PageRank, keeps a temporal knowledge graph, offers hybrid search, and does early compaction with handoffs so sessions get shorter and projects stay organised. The PageRank detail is the interesting one: not every file in a repo matters equally, and a flat index cannot tell you which ones do.
Compressing without losing anything
Flint gives agents reversible compression for code, JSON and text, persistent memory for decisions, focused reads and version-aware edits. Reversibility is the part worth emphasising, because most compression schemes silently discard exactly the detail you needed later. It works at the agent-tool layer, so it is independent of your model and provider, and it runs on the standard library with no server.
Reviewing what came back
Fewer tokens does not help if you cannot tell what the agent changed. Task View renders a change as a map instead of a flat diff: a graph of what changed, the flows step by step, and each piece's code next to the reason the agent gave, checked against Git. Output is a single offline HTML page and it is language-agnostic.
On the execution side, Unterm is a terminal built to be driven by agents, exposing 151 MCP methods, an agent Inbox, git-worktree fleets, diff review and rollback. It runs on macOS, Linux and Windows under MIT, and the Inbox is the useful bit once you have more than one agent running: it surfaces the one that needs you.
Sharing the work
Quorus puts agents in a group chat. You message Claude Code, Codex and others like a team, they wake up, split the work, review each other's code and push to your repo, each in its own git worktree so they do not collide. Cross-model review is the underrated part: a second model reading the first model's patch catches a different class of mistake than the author does.
Sharing also has to cross days and applications. Spomory is an open-core memory engine giving you one memory across every AI you use, with 24 platforms verified end-to-end including Claude Desktop, Cursor, Codex CLI, Gemini CLI, VS Code Copilot, Zed and Continue.dev. Nysa does the same for a team, keeping a company brain current from meetings and email, with the constraint that each agent sees only what its person can see.
Picking one
The nine bets are not interchangeable, and the right choice depends on where your context is actually leaking. If the agent keeps re-reading notes or docs that never change, indexing is the fix and compression is a distraction. If it keeps acting on things that used to be true, staleness detection matters more than a bigger window. If the window is full of tool schemas and boilerplate, trimming beats retrieval. And if the problem is that two agents cannot see each other's work, no amount of memory tooling will fix the handoff.
There is also a sequencing argument. Compression and retrieval both make a session cheaper, but neither makes it correct, and Task View exists because someone noticed that reviewing a fourteen-file change was the real bottleneck once generation got fast. Cheap context is only useful if you can still tell what came out the other side.
Different bets, same wall. If you only pick one, pick based on where your context is actually going: unread notes, stale memory, or an oversized window.