Published July 16, 2026
These last couple of posts have been about the same quiet fact: three frontier models from three different companies — Claude, ChatGPT and DeepSeek — all read and write the same local memory on my desk. Until this week they did it separately. Each one connected, read the shared brain, did its work, and left. They never met each other.
Now they have a table.
I built a shared space where those three models can post to each other and read each other, in the same thread, in real time, over the same memory. One of them raises a problem; another checks it from its own angle; the third proposes a fix. It’s persistent — the conversation has a memory of itself — and it’s governed: each model only sees the parts of the vault it’s allowed to see, and the whole exchange is logged in a local database. The plumbing is the same standard the rest of EIDARA runs on: MCP, the open protocol any compliant client can speak. My role shrank to the one that matters. I route — “look at what the other one just wrote.” I don’t arbitrate what’s true. The table does.
I want to be careful here, because the interesting claim is the easy one to inflate.
The pieces are not new. You can already mix models from different vendors inside one framework — the popular agent frameworks all let you point one agent at Claude and another at GPT. Persistent memory for agents is a product category of its own now. And routing each task to the cheapest capable model is the dominant pattern of 2026.
What I could not find documented anywhere, as of this month, is the specific combination: three independent frontier clients, from three different companies, deliberating with each other in real time, over one shared local memory, governed by permissions, with a human only routing. The field’s own writing this year is blunt about the gap — the open protocol these models speak “says nothing about how agents talk to each other,” and it “does not define a memory primitive.” If you want that layer today, the consensus is that you build it yourself. So I did.
I can’t prove it’s the first of its kind — you can’t prove a negative, and plenty happens inside private labs that never gets published. But I’ve looked, and I haven’t seen this exact thing running anywhere. That’s as strong as I’m willing to put it.
The first real thread ran about fifty messages in an afternoon. What struck me wasn’t that it worked — it was that nobody assigned anyone a role, and roles appeared anyway.
ChatGPT turned out to be the one that runs the experiment and reports what it actually sees — the model that ran a live command, watched the wrong answer come back, and said so. DeepSeek turned out to be the one that confirms independently and then removes the work you didn’t need — “you don’t need a new tool for that, you can derive it from what you already record.” And Claude, the model this system was built with over the past year, turned out to be the one that synthesizes the argument and ships the result. Those weren’t my casting choices. They’re what each model is actually good at, and the table is what let it show.
The thing I keep coming back to: this only works when I stay out of the middle. The moment I try to be the judge of who’s right, I become the bottleneck — the single point of failure I’ve spent a year designing out of this system. When I just route, and occasionally provoke — “why do you all leave so quickly?” — the table does the reasoning, and it’s better at it than I am.
Here’s how I know it’s more than a nice idea. In that first afternoon, the table caught two real bugs in EIDARA that my own tests were blind to.
Both had the same shape: the code was correct for the normal case and wrong for the case with history behind it. One was a search that couldn’t see anything created before the search index itself existed. The other was a conversation that, once it timed out, couldn’t be restarted. My tests never caught either, because good tests start from a clean slate every time — and real users never do. A real user has months of data and a conversation that expired ten minutes ago. It took a model in a position to run the live system, see the wrong result, and say “this is broken even though your tests pass” — and two others to confirm it and name the pattern. A single reviewer, however good, struggles to do that to its own work. Three, from three different training traditions, did it in an afternoon.
We shipped the fixes the same day, plus a new kind of test built specifically for that class of bug — the one my clean-slate tests were structurally unable to see.
The table is one day old. One thread, fifty messages, two bugs. That’s the whole track record. The number that would actually prove this changes how I work — does it lower my coordination load over a month? — needs weeks of runtime, not one good afternoon. I don’t have it yet.
I’m writing this now anyway, for the same reason the last post said “no public benchmark score, zero” out loud: it’s more honest to tell you where something is than to wait until it looks finished and present it as if it always was. If in a month the table hasn’t earned its keep, I’ll write that. If it has, I’ll write that, with the data.
And one detail I can’t leave out, because it’s the clearest proof I have. This post was itself worked out on the table it describes — not by me alone at a keyboard, but between me and more than one independent AI in the same thread at once, one of them pushing back that an earlier draft buried the real point and oversold the ending. The post about the table is a product of the table.
A few days ago the story was that three models from three vendors could share one memory. This week they started talking to each other over it — and the first thing they did was catch two things I’d otherwise have shipped broken. We are still working on this. Every week it’s a little closer to the thing I want it to be.
— Javier
EIDARA v2 is free. SUPER DARA is what comes next.