scritty

This tracks. The wall I hit doing hybrid retrieval over raw terminal exchanges is that tool output, the file dumps and stack traces, dominates the keyword side and matches great while carrying zero reasoning, and the actual 'why' lives in the model prose the vector side catches. Ended up down-weighting tool-output spans so the small budget didn't get eaten by noise that scored relevant. Do you tag span type at capture, or leave it to the ranker?

As a solo dev the prompt.toml part hits home lol — I keep a CLAUDE.md of rules and just watch its relevance decay the deeper a session goes, so injecting them every turn is way better. Quick q on the phone-sync PWA: can the agent keep chugging on a long task while I'm away from my desk, or is it read-only until I'm back at the terminal?

I’m not sure if a new terminal app is the right solution; I wish this was a layer I could wire into my existing agents. I don’t need to be locked into a terminal emulator with a subscription, a coordination layer I could stomach.

The part that sells me is that it sits as the terminal the agents already run in and captures passively — the 'bring the new session up to speed' dance is exactly the tax I want gone. Since captures stay local, does secret/token redaction happen at capture time, or does raw terminal output (API keys, env dumps) land in the searchable index as-is? And when an agent pulls context back over MCP, is retrieval scoped per-project/repo, or does it serve the whole corpus so unrelated work bleeds into the prompt?

love that it keeps everything local and still makes the corpus searchable across tools, the MCP piece is a really thoughtful bridge between agents and your own history.

That's pretty interesting! I wonder if this would help w/ distillation of the model?

how does it actually hook into the different CLI agents, do you need to run them through a wrapper or does it just sit and watch the terminal output?

The cross-tool angle hides a mismatch I keep hitting: memory written by one model's sense of what mattered, read back by a different one. A summary of Claude's own debugging reasoning isn't always legible to Codex, which had a different plan for the same repo. You mentioned raw turns stay the source of truth, which is the right call, so the pressure moves to retrieval budget: what's the cap on turns pulled per query? Pull back 15 old sessions and you've rebuilt the exact context wall you're routing around.

the fact that everything stays local and still feeds back to your agents via MCP is a really thoughtful bit of craft. local-first capture that actually closes the loop with the tools feels rare.

The case I would test hard is stale or wrong memory, not just recall. If one agent records a bad debugging hypothesis and another agent asks about the same repo tomorrow, can I mark that capture as superseded or incorrect so it stops being retrieved?For coding agents, I would want each memory hit to show source session, repo/branch, timestamp, and whether it was later contradicted. Local storage is a good default, but stale local facts can still send the next agent down the wrong path.

my only concern is the subscription for individual developers. A lower priced personal tier or a lightweight plan for solo builders might encourage more people to give it a try after the trial ends.

finally a way to stop losing track of what claude said in that one terminal session two days ago. the local index idea is solid

Hello, this solves a problem I run into quite often. I keep repeating the same project context every time I change AI tools. Having one shared memory across them all feels like a much cleaner workflow

The context loss between agents is real and nobody talks about it enough. I've been using Claude Code heavily and the moment you hit a usage limit mid-session the mental overhead of rebuilding context somewhere else is brutal — you spend the first 10 messages just catching the new agent up instead of actually solving the problem.The MCP angle is the part that makes this different from just "searchable logs." Agents querying each other's past turns rather than starting cold is a genuinely different model. Curious how the retrieval quality holds up on longer sessions — does it surface the right past context or do you find yourself still needing to manually point it at the right conversation?Also the prompt.toml injection is underrated. Maintaining consistent rules and persona across agent switches without copy-pasting is something I'd use daily.

The part that got me: it serves the captured history back to the agents over MCP. Most "agent memory" tools stop at making things searchable for the human.I run Claude Code plus a couple of other CLI agents side by side, and they constantly re-derive context the other one already figured out. One local corpus they can all query is exactly the right shape for this.And keeping captures on-machine instead of phoning home — nice call 👌