Something unexpected happened after I built my memory system.
I'd set it up so both of my AI agents - Claude Code and Marcus (my OpenClaw agent) - could read and write to the same Supabase brain. 540+ memories, searchable by meaning, accessible from anywhere. The original goal was persistence. But once they shared the same knowledge, a different question showed up:
What if they didn't just share memory - what if they actually worked together?
I want to be clear about something: I'm not interested in building agent workflows that just sound impressive. There's a lot of hype around multi-agent setups right now, and most of it stops at the demo. I want something genuinely productive. Something that actually changes how much I can get done in a day.
Claude and Claude Code have already helped me grow significantly - I've shipped more in the last few months than in years before. But I need to get to a different level. In terms of efficiency, in terms of autonomy. What I have now is good. What I need next requires the agents to work together, not just side by side.
Two agents, two jobs
I use Claude Code and OpenClaw for very different things.
Claude Code (I call him Claudio) is my primary agent. He writes code, refactors, debugs, manages my projects, runs my MCPs, knows my voice, my patterns, my preferences. We've been working together for months. He has context that's hard to replicate.
Marcus (OpenClaw) is my runner. He's designed for independent execution - handling tasks, running checks, processing batches. Named after Marcus Aurelius, because discipline over drama. He can work on his own and report back.
They're both powered by Claude's brain. Same model, different purpose.
The hierarchy flip
I originally set this up the other way around. Marcus as the supervisor, Claudio as the builder. It made sense on paper - OpenClaw is designed for orchestration.
But in practice? I work with Claudio directly for almost everything. He has my MCPs, my project access, my accumulated context, my memory system. He knows how I think. Marcus is newer to my workflow.
So I flipped it.
Now Claudio is the orchestrator. He's the one who breaks down tasks, assigns work to Marcus, reviews what comes back, and presents results to me. Marcus executes and reports - constantly. That reporting loop is what triggers everything. Marcus finishes a piece, reports back, Claudio evaluates, assigns the next piece or adjusts course.
It's a small change that made the whole thing click.
What actually works right now
- Shared memory. Both agents search and save to the same Supabase brain. When Marcus learns something, Claudio can find it. When Claudio solves a case, Marcus can reference the pattern later.
- Task delegation. I give Claudio a list, he breaks it down and spawns Marcus for the pieces that don't need my input. Routine audits, data checks, batch processing.
- Continuous reporting. Marcus doesn't just finish and go silent. He reports back at every step. Claudio decides what's ready and what needs another pass.
- Everything stays local. No public APIs, no exposed keys. Both agents run on my machine with defined MCP permissions.
What's still hard
I'm being honest about this part because I think it matters more than the shiny demo.
Context handoff is fragile. When Claudio spawns a task for Marcus, that session starts fresh. It doesn't carry the full context. I've built workarounds - context injection files, custom agent definitions - but it's not seamless yet. Every handoff loses something.
Trust calibration. I'm deliberately keeping this supervised. Not because I don't trust the tech, but because I want to understand how the collaboration works before giving it more autonomy. You don't hand someone the keys until you've seen them drive.
Why it matters
This isn't about a cool setup. It's about getting to a place where I can realistically do more without burning out.
I've already seen what working with one agent can do. Claudio and I built my blog, rolo.pet, and a dozen other projects. The growth has been real. But I hit a ceiling - there are always tasks in my Linear backlog that I don't get to because the day runs out.
And the bottleneck isn't always code. A lot of what slows me down is administrative - things that depend on someone else showing up, sending a message, triggering a process. Support cases that need follow-up. Emails that need a response before something else can move. Updates that need to happen when a certain condition is met. That stuff piles up quietly and eats your day.
If Marcus can monitor those triggers, handle the routine responses, flag what needs my attention, and keep things moving while Claudio and I focus on building - that's not hype. That's a real multiplier. Not AI replacing me. AI extending my reach to where I actually need to go next.
What's next
This is a work in progress. Deliberately.
Right now I'm in a micromanagement phase, and that's on purpose. I want to understand the logic of every handoff, every decision point, every report. Not because I enjoy micromanaging - but because you can't automate what you don't understand.
Once I see the patterns clearly - which tasks Marcus handles well, where he needs guardrails, what Claudio should review vs. approve automatically - I can start applying that logic to broader things. Not just code tasks. Administrative workflows, support triage, content pipelines, anything with a trigger and a process.
The loop right now: I assign to Claudio, Claudio delegates to Marcus, Marcus reports, Claudio reviews, I approve. Every step has my eyes on it. Over time, some of those steps will become automatic. But I'm earning that trust, not assuming it.
This is also the most interesting phase for Velora, my system for tracking how much I've recovered in efficiency and growth. Everything I've measured so far - the projects shipped, the workflows optimized, the time saved - has been me working with one agent. This is the transition point. How well I connect these agents, how much I can delegate without losing quality, how far I can push autonomy while keeping control - that will determine how much I grow in the next months and years.
I'm not going to get another moment like this. The tools are ready, the memory is there, the agents exist. The question is whether I can use this transition to get to a level I couldn't reach alone.
Two agents, one brain, shared context. Let's see where it goes.