VicroCode
Make Code Create Value
VicroCode is a lightweight online platform for publishing, running, sharing, and monetizing code projects. Launch HTML, Python, SQLite, AI agents, management tools, games, and more without server setup.
Please wait while VicroCode loads. You can also explore the AI programming guide
Loading...

AI MARKET GUIDE

One Memory Store, Every Coding Agent: Building a Hosted vault_search / vault_remember

A developer juggling many AI coding tools keeps re-explaining preferences and bugs. Here's how to turn that pain into a hosted, agent-callable lesson store, and where it stops.

What keeps getting rebuilt by hand?

If you read the share-your-work boards lately, one complaint shows up over and over: people run several AI coding tools side by side, and each one forgets everything the others learned. One developer laid it out cleanly in a post about a tool called aivault. They bounce between Claude Code, Codex, opencode, and Kimi Code, and every tool keeps its own rule files, its own skills folder, its own memory. Say "remember I use pnpm" in one, open another, and you're explaining it again.

Their fix was a shared local folder of plain Markdown wired into the AI coding tools on their machine, 21 of them by their count, plus two tool calls for the ones that speak MCP: `vault_search` to look up what you've told the AI before, and `vault_remember` to store something new. The feature they wanted most: you report a bug, the AI finds the root cause, fixes every place that cause touches, then writes the lesson into a `mistakes.md` that every tool reads, so the same mistake doesn't come back when you switch harnesses.

That last part is the real signal, and it's bigger than one tool. Another post described a 20-year backend engineer running cheap flash models with a memory plugin and a global system prompt, treating accumulated context as the thing that makes a cheap model behave. A solo developer shipping an open-source desktop assistant listed "project memory" as one of the pieces they spent six months hardening. Different people, same conclusion: the durable asset isn't the model, it's the pile of preferences and hard-won lessons, and it's currently trapped per-tool and per-machine.

Why reframe the folder as a service?

The Markdown-in-a-folder approach is a good start and syncs fine over iCloud or Git. But it ties the memory to a filesystem and a machine. If you want the same lessons available to an agent running in a CI job, a teammate's laptop, or a hosted endpoint, a shared folder gets awkward fast.

The alternative is to host the store once and expose it as tool calls any harness can hit. This is a clean fit for what VicroCode actually offers. A semantic lessons-and-preferences store maps directly onto a LanceDB knowledge base: you embed each remembered item and retrieve by meaning, so "why did the auth redirect break" surfaces the lesson you wrote as "OAuth callback fails when the state param is dropped," even with different wording. Structured bits that aren't really semantic, like a flat list of preferences (`uses pnpm`, `no database writes without confirmation`) or metadata about which project and tool a lesson came from, sit better in a SQLite database alongside it.

The two verbs become two hosted endpoints. `vault_search(query, project)` runs a similarity search over the knowledge base and returns the top matching lessons and preferences. `vault_remember(text, tags, project)` embeds and writes a new entry, dedupes against near-identical ones, and timestamps it. The retrieval and write logic is ordinary glue code you can run Python online on the platform, and you publish it through API Endpoint Hosting so the functions are reachable as in-platform tool calls. If you're assembling a fuller workflow around it rather than two bare endpoints, the same primitives support AI agent development on top.

How would an agent actually use it?

The pattern the aivault author wanted translates into two hooks in your own prompt or harness config.

Before acting on a task, the agent calls `vault_search` with the task description and the current project, and you fold the returned lessons and preferences into context. So when it's about to touch the auth flow, it pulls back the state-param lesson and your "always confirm before DB writes" rule before it writes a line.

After a fix lands, you instruct the agent to call `vault_remember` with the root cause and the correction, not just a note that something broke. That's the `mistakes.md` idea, except the file is a hosted store every tool reads from the same copy, so there's no folder to sync and no per-machine drift.

Whether this actually stops a class of bug from recurring is unverified. Nobody in the evidence has measured that, and I wouldn't claim it. What you can say honestly is that the lesson stops being stranded in one tool's local memory.

Where are the boundaries?

Here's where I'd stop you before you oversell this to yourself. VicroCode can host the store and the two endpoints. It cannot reach into your 21 local CLIs and wire itself in. Each tool still needs you to register these as tool calls or point its MCP config at your hosted endpoints, by hand, per tool, on each machine. If a given harness has no way to call an external tool, it simply won't use the vault, and you're back to pasting context for that one. The hosted version trades the folder's offline simplicity for reach: it needs a network and an auth token on every call, which is a real cost for something your agent hits constantly.

I'd also keep the scope tight at first. Embedding the model calls behind your endpoints depends on which models you have available through the platform's Model Center; don't design around a model you can't actually reach there. And none of this touches account bans, model routing, or the quantization-and-latency differences people argue about between an official API and third-party deployments. Those are separate problems, and the store won't solve them.

Is it worth building, and what should you watch?

The reason this is worth doing is that the memory is the part you keep re-earning. Start with `vault_remember` and `vault_search` over a knowledge base and a small SQLite preferences table, wire it into the two or three tools you actually use most, and see whether the retrieved lessons are landing in context at the right moment. If they are, you've got one store feeding every harness that can call it, which is the part the folder approach gets right and the part worth making portable. Keep the claims modest until you've watched it run on your own work for a while.

FAQ

Why do coding agents keep losing context?

Because memory lives inside each tool's local folder. Every new agent starts from zero and rebuilds the same index.

What is the minimal hosted memory shape?

Two endpoints: search and remember. Store each item with source, timestamp and a short hash so duplicates collapse.

What is the main risk?

Stale or contradictory memories. Versioning and a delete path matter more than embedding quality.

Further reading