Home

I've been building a memory system for my coding agents.

Not because anyone asked me to. Because I needed one. When you run opencode, Claude Code, and Codex across a handful of projects, you start noticing the same pattern. Every session begins the same way. The agent knows nothing. You re-explain the project, the conventions, the decisions you made last week. It's like talking to someone who keeps forgetting you.

So I built Recollect. A library. Postgres plus pgvector. Store a memory, search for it later, scoped by project. Nothing fancy. It's been running quietly in the background of my projects for months now, and it works.

This week I went looking for something better. I'd been watching cognee for a while. Knowledge graphs, structured extraction, the whole thing. I finally sat down and ran it against my own data, compared the results to what Recollect was already giving me.

The results weren't better.

Not dramatically worse either, just not better enough to justify the complexity. And that's when I had the obvious thought I should have had earlier. I already have a memory system. It works. I should stop looking for someone else's and start using my own properly.

What I actually wanted

The problem wasn't the library. Recollect works fine as a library. The problem was that it wasn't running anywhere central. Every project that wanted memory had to wire it up itself. I wanted one place. One server. Any agent, any project, talks to the same memory store over HTTP or MCP.

That's what Home is.

It's a Phoenix app that sits on my machine. One Postgres database. No external dependencies beyond the LLM providers I configure. It gives me:

• Agent Memory. Recollect, running centrally. opencode talks to it through a plugin. Claude Code and Codex talk to it through MCP. One shared memory store, scoped per project. An importer picks up session history from all three agents on a schedule, so things you learned in one tool are available in the next one.
• LLM Router. An OpenAI-compatible proxy that sits in front of whatever providers I'm using. Tracks cost and latency per project and model. Enforces quotas. Lets me pin a model to a project without touching config files across three different tools.
• Tactical Overview. A dashboard that merges LLM usage, git activity, and memory signals into "what was I actually working on this week" focus areas. Plus personal goals, because I'm that kind of person.
• Crypto Keys. An encrypted store for API keys and tokens, so I'm not scattering secrets across .env files on six machines.

Everything is local-first. One database. No SaaS. No telemetry. No one else's cloud in the middle.

The memory part

The part I care about most is the memory. Here's how it works now.

When I start a coding session in opencode, the plugin automatically searches memory for the current project. Whatever Recollect finds gets injected as context. When I learn something worth keeping, I call recollect_remember. Not automatic. Explicit. That's a deliberate choice. Auto-capture sounds good until you realise your agent is filling a database with noise.

Claude Code does the same thing through MCP. A session-start hook searches memory, injects results. At any point the agent can call memory_remember to store something. Codex too, same MCP endpoint, same data.

The importer runs on a schedule. It reads session history from all three agents and feeds it through Recollect's distillation pipeline. One scope per project, deduped. So if I spend the morning in Claude Code learning something about the MarkMesh backend, that shows up when I open opencode in the afternoon.

It's still early. The importer is rough. The dashboard is functional but not pretty. But the core loop works: agents remember, agents recall, and the memory lives in one place I control.

Why home

I called it Home because that's what it is. It's where my agents come from and where they come back to. Not a platform. Not a product. A tool that lives on my machine and does what I tell it to.

It runs on localhost:4070. Docker compose up, create an account, done. There's an installer that handles the setup if you want it. If you'd rather do it manually, the README has every step.

I've open-sourced it because I know I'm not the only one wrestling with this. If you're running multiple coding agents across multiple projects, you've felt the same "start from zero every session" problem. Maybe this is useful. Maybe it's a starting point for something better.

It's heavily work in progress. I'm shipping it now because I'd rather get feedback on something real than polish something in private forever. If you want to have a play, the repo is at github.com/norbu09/home. Issues, feedback, complaints, all welcome.