We built Memory Stack because our own AI kept forgetting

The context tax we hit building Operator Stack, and what we did about it.

We didn't set out to build a memory company. We were building Operator Stack, an automated backend for investment funds, and we'd handed a lot of the work to AI: deal research, LP updates, keeping an eye on the portfolio.

The first problem had nothing to do with agents. It was us. AI made everyone on the team faster, and that speed came with a cost we didn't see coming. Someone would settle a question on Monday, and by Wednesday someone else was asking it again, because the answer didn't live anywhere the rest of us could find. Work one person did in the morning was invisible to the team by the afternoon. We were small and moving fast, and we kept stepping on each other.

Even then, when it was just people, a shared memory would have helped.

Then we put more agents on the work, and the problem went from annoying to expensive. Two agents on the same project don't split it. They repeat it. One works out how a portfolio company is structured, and an hour later another works out the same thing from scratch, with no idea the first one ran. A supervisor signs off on a decision and the worker reopens it. Nobody's doing anything wrong. They just can't see each other.

That's what we started calling the context tax: everyone, person or agent, paying to rebuild what someone already knew.

We went looking for a fix. Everything we found lived inside one tool, or one person's editor, or a document that was out of date by the time anyone opened it. None of it treated memory as something a whole team, people and agents both, could share across whatever tools they used. So we built that. It's Memory Stack.

What the tax actually looked like

A few of the ways it hit us:

Decisions didn't travel. We'd decide something and move on, and the decision just stayed where it was made. The next person, or the next agent, had no way to know, so they decided it again. Sometimes differently.

Whatever someone learned, they kept. Not on purpose. There was nowhere to put it. When a teammate moved on or a session ended, the understanding left with them and the next one started from zero.

Sharing meant writing it down. That meant a doc, which was stale a week later and trusted by no one. And we still paid, on every prompt, to hand that context back to the model ourselves.

Every tool remembered on its own. What we told Claude, ChatGPT didn't know. What the coding agent learned stayed in the coding agent. A dozen small memories, never one.

"It remembers" was something you had to take on trust. We couldn't see what had carried over, so we couldn't lean on it. Agents redid work because they had no way to check whether it was already done.

Good ideas didn't spread. Someone would find a better way to do something, and it stayed with them. Everyone else kept hitting the wall they'd already gotten past.

What we built

Memory Stack is one place your context lives, under all the AI you use. Private by default, shared when you want it to be, and the same whether you're in Claude, ChatGPT, or an agent you wrote yourself.

It pulls in only what matters for the task in front of you, instead of making you paste in whole documents. In our own work, that cut the tokens we spend re-feeding context by 60 to 80 percent.

What one agent learns is there for the next one, so two agents on the same project stop redoing each other's work. And the decisions and patterns that keep coming up across your team turn into shared principles and best practices on their own. The way your best person solved something quietly becomes the way everyone does it.

It doesn't make things up. It answers from what was actually saved, and nothing else. For a memory product that's the whole job, so it's the one place we don't cut corners.

And it shows its work. You can see what carried over, where it came from, and what an agent actually used. Not "trust me." Here it is.

Where this goes

We built Memory Stack to stop our own AI from forgetting and our own team from tripping over itself. The problem turned out to be bigger than funds, or engineering, or any single tool. It shows up the moment more than one person, or more than one agent, is in the work.

The good part is that it compounds. Every session adds to something the next one stands on. The more you use it, the less you redo.

We're a team that ran into this building something real, and built the thing we wished existed. If your AI keeps forgetting what you already told it, that's the tax. This is how you stop paying it.

Next: how mycivicduty.org ran a multi-agent build on Memory Stack.