@agentxagi Both, actually it's a bit tricky process I will probably make another long read post about the process and how i came into current state in a bit later :)
A memory can match the query and still be useless. We built a second stage for that.
Useful decisions, failed approaches, project rules. Things the next agent should be able to find without me explaining everything again.
Here is how we built it.
Agents save durable records. An extraction step connects eligible records to entities and relationships. Each machine keeps its own store; the agents can reach the other machines through the mesh.
Search combines keywords with embeddings. Plans, tasks and the history of the work are indexed too, so the reasoning behind a decision can be found alongside the decision itself.
Then there is the part I find particularly useful: Jev can sit after retrieval and rank the candidate memories by how much they actually help answer this question. Being semantically similar is only the start.
Memory also needs maintenance. Duplicate records can be consolidated, superseded knowledge archived, and useful material promoted. The history is retained, so cleaning up does not mean losing the trail.
The video illustrates this cycle: records arrive, connections form, the graph is maintained, and a useful decision comes back into an agent's next task.
I am building this in the open. Next I want to show the retrieval and the memory's night-time housekeeping in more detail.
@Jazzen_Chen Agreed. The recheck should be a new entry with its own commit SHA and result, keeping the original finding intact. That would make the review history much clearer.
we spent years teaching engineers "no single point of failure".
then we wired our entire workday into one AI vendor and called it productivity.
think about it for a second. one region loses power. one bad config push. one capacity crunch. and suddenly a huge chunk of the industry can't write code, can't review, can't ship. at the same time. for days.
we'd never accept that from a database. we accept it from the thing that now writes half our code.
and outages aren't even the real risk. the real risk is boring:
your limits get cut,
your price goes up,
your account gets suspended by an automated system,
your favourite model gets retired.
you can't negotiate any of that.
so I stopped treating models like favourites. a model is a tool. any decent one can be specialised for a job.
my setup now:
Claude Code, Codex and OpenCode with DeepSeek running side by side,
the orchestrator on a VPS,
local Qwen MoE on my own GPU for whatever I can run at home,
every role swappable in a couple of clicks.
Domios is the open source thing I built for this. ask its main agent how to add another provider or a local model and it walks you through it: official keys only, no resold tokens, no shady routers.
redundancy isn't paranoia. it's just engineering we forgot to do.
@macro8n I’m building around work continuity: plans, tasks and searchable memory live outside the provider. A switch preserves the task/attempt and passes recent context plus an archive reference. That doesn’t make tool support, context limits or data policies identical.
@Jazzen_Chen The implementation report carries the commit SHA. Review notes stay in the task history, indexed for keyword + semantic search. The next agent can retrieve that context and check the current code. There’s no automatic “this finding is stale” flag yet, good point
@pmitu Try https://t.co/bJT1byGNcv you will make 10 apps in the same amount of time! Still have to pay for claude/codex/deepseek with your own tokens though
@Jazzen_Chen The worktree + handoff note are the core. Domios also keeps the task in a shared plan, with its brief, status, review findings and artifacts. The next agent gets that context; it doesn’t automatically inherit the previous agent’s full conversation.
@Bob66188 Definitely! Domios could support even more harnesses, deepseek + gemini + mimo + kimi all of them in one team under one orchestrator like opus 5.5 high!