How we
work together.
I've found that agentic systems can plateau at the demo. I aim to design systems that get more useful with age: memory-first architecture, context engineering, embedded delivery, and operational discipline for regulated environments.
I've built my practice around webdevOS and cofounderOS, my in-house multi-agent orchestration engines. The four practices below are how I deliver it.
Memory That Scales
It worked great, then it drifted, and I didn't know how to fix it.
Your agentic setup worked great at first, then it started to drift, and you didn't know how to fix it. That's almost always a memory problem: the architecture that was right for the first month stops being right as the system grows.
Memory should be right-sized to the need, and able to grow with it. I match the architecture to where you actually are: sometimes that's a simple Obsidian setup; sometimes it's a knowledge graph with embeddings and a hybrid-retrieval architecture. Crucially, I design the path between them, so the simple version doesn't become a dead end you have to rip out later.
The outcome is memory that's right-sized for today and scales without drifting, so the system keeps getting more useful with age instead of quietly degrading.
- D.01Memory architecture right-sized to where you are now
- D.02A scaling path from simple setup to knowledge graph
- D.03Embeddings + hybrid retrieval where the need warrants it
- D.04Drift diagnosis and a way to keep it from recurring
My setup worked great, then it drifted and I couldn't fix it. What happened?
That's almost always a memory problem. The architecture that was right in the first month stops being right as the system grows, and the symptom is drift: it quietly gets less reliable. The fix is matching the memory architecture to where you actually are now, with a path to grow.
Do I need a complex knowledge graph, or is something simpler fine?
It depends entirely on the need. Sometimes a simple Obsidian setup is exactly right; sometimes you need a knowledge graph with embeddings and a hybrid-retrieval architecture. I right-size it to where you are rather than over-engineering, because the wrong-sized memory is what causes drift in the first place.
If I start simple, will I have to rip it out later to scale up?
No, that's the part I design for deliberately. I map the path from the simple setup to the more complex one, so the early version is a stepping stone rather than a dead end. The whole idea is memory that scales without drifting.
How do you stop the drift from coming back?
By diagnosing what caused it and building the architecture so it stays right-sized as the system grows. The outcome is memory that keeps the system getting more useful with age instead of quietly degrading, and where it helps, I provide ongoing monitoring and support to keep it that way.