scritty

Shared, searchable memory for every AI coding agent

Productivity

Developer Tools

Artificial Intelligence

Visit WebsiteSee on Product Hunt

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.

finally a way to stop losing track of what claude told me in that one terminal two weeks ago, the local index feels snappy and the mcp handoff back to my agents actually worked on the first try

this is the exact workflow i have, burning through Claude then hopping to Codex mid problem. one thing that worries me: terminal sessions end up full of API keys, .env dumps, stack traces with internal urls. if you're capturing and indexing everything by default, is there any redaction before it hits the searchable corpus, or is that on me to be careful about what i paste

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 👌

If I'm working across multiple client projects that shouldn't ever mix, is the corpus scoped per project/repo by default, or is it one global memory that I'd have to manually wall off? Worried about an agent on project A accidentally surfacing something it learned while I was working on project B.

the piece i keep waiting for. every agent has its own memory silo which means every session gets rebuilt from scratch. cross-tool memory should be a standard everyone shares. also the fact that it stays local instead of getting phoned home makes this ok to leave running.

question for v2: does the index know when two conversations are about the same thing but happened in different tools, or is it just full text search? that dedupe is where this gets scary useful.

The context loss when you switch from Claude Code to another agent mid problem is exactly what kills me, so pulling it all into one searchable memory over MCP is a great idea. Does it keep the full transcript searchable or summarize once a session gets big? Congrats on shipping.

how does it actually capture the conversation from agents like Codex and Copilot, do you have to wrap the calls or does it hook into the terminal session itself?