Merlin, Link, and a Chief of Staff: Building a Multi-Agent Team with Grok Bot

Merlin, the wise guide: a pixel-art wizard with a long white beard and a gnarled staff, standing in a mossy forest

Ask most people what makes AI coding good and they’ll name a model. Claude. Codex. Gemini. Grok. Fair enough, the models are extraordinary. But after enough hours in the chair, I’ve come to believe the model is the least interesting part of the setup. The interesting part is the harness: the environment that wraps the model, feeds it context, remembers what it’s supposed to do, and lets it act.

This is a post about that harness, about a tool called Grok Bot that leans into it, and about a slightly ridiculous, genuinely useful idea I’ve been building toward for a while: a team of named AI agents, each with a personality and a job, all reporting to a chief of staff.

Let me explain by way of a wizard, an elf scout, a boy general, an inventor, and a detective.

What a good harness actually buys you

A model on its own is a brilliant amnesiac. It’s smart in the moment and forgets everything the second the moment ends. A good harness fixes that. It’s the coding environment that lets you:

Integrate multiple models and features behind one consistent interface, so you’re not rebuilding your workflow every time you switch tools.
Layer in skills and .md-based guidance documents, standing instructions the agent reads automatically, so you’re not re-typing the same context every session. Write down “here’s how we do database migrations” once, and every agent that touches the repo knows it.
Cache aggressively and keep the environment consistent, so the agent starts each session in a known-good state instead of re-deriving your whole project from scratch.

That last point is the quiet superpower. Caching and a consistent environment aren’t glamorous, but they’re what turn “an AI that can write code” into “an AI that can do my work.” You stop prompting constantly and start delegating.

And once you’re delegating, a natural question follows: why delegate to one agent when you could have a whole team?

Enter Grok Bot

Grok Bot leans all the way into that question. It lets you spin up multiple agents and, crucially, personalize each one. Different guidance, different specialties, different names.

That personalization matters more than it sounds. An agent that is only a database specialist, with only database guidance loaded and a name that reminds you what it’s for, tends to behave like a better database specialist. Specialization is a feature, not just a vibe. Narrow the job and you narrow the mistakes.

Months before Grok Bot, I’d already made a list, half for fun, half in earnest, of AI agents modeled on characters from literary and mythological history. Now I finally had somewhere to put them.

The roster

Here’s the crew I’ve been assembling. Each character is chosen so the name itself signals the job. When I hand work to “Sherlock,” I already know what I’m going to get.

Link, the capable scout: a pixel-art elf ranger with a quiver of arrows and a green cloak in a sunlit forest

Link, the capable scout. Exploration, tooling, practical action. Link goes and finds out. Where does this function get called? What breaks if I change it? Does this API even exist? Point him at unfamiliar terrain and he comes back with a map.

Merlin, the wise guide. Deep thinking, strategy, synthesis. When I’m not sure what I’m building yet, Merlin is who I talk to. He’s slow on purpose. He’s the one who asks the question that saves you a week.

Ender, the tactical operator: a pixel-art young commander in a Battle School uniform studying a strategy simulation on a tablet

Ender, the tactical operator. Systems, simulations, hard problem-solving. Ender takes the genuinely nasty problems: the concurrency bug, the performance cliff, the “this works locally but not in prod” ghost. He runs the scenarios until the enemy’s gate is down.

Sherlock, the master detective. Investigation, deduction, evidence. When something is broken and nobody knows why, Sherlock reads the logs like a crime scene. He doesn’t guess; he eliminates the impossible and follows what’s left.

Daedalus, the master builder: a pixel-art craftsman in an ancient workshop shaping a mechanical wing, a labyrinth visible through the window

Daedalus, the master builder. Architecture, systems design, elegant construction. Daedalus is who I hand a green field to. He designs the labyrinth and the wings to escape it: structure first, then the clever thing that makes it fly.

Sherlock, the master detective: a pixel-art Victorian sleuth with a pipe at a cluttered Baker Street desk, Big Ben through the window

And there’s a bench behind the starters, each one a job I know I’ll eventually want:

Athena, the strategic commander: judgment, planning, diplomacy, disciplined leadership.
Neo, the system breaker: unconventional solutions, hidden patterns, escaping constraints.
Zeus, the executive authority: decisive action, delegation, high-stakes calls.
Newton, the first-principles thinker: logic, math, rigorous cause-and-effect.
Leo (Da Vinci), the visionary inventor: creativity, design, imaginative problem-solving.
Loki, the cunning disruptor: red-teaming, loopholes, challenging every assumption you didn’t know you were making.

Loki, for the record, is the one I’d trust to try to break my own code before somebody else does.

The chief of staff

Here’s the part I’m most excited about. I don’t actually want to manage ten agents. I want to manage one, and have that one manage the rest.

The org chart is simple: a chief of staff agent sits on top. I bring it the goal. It decides which specialist gets which piece, hands out the work, and pulls the results back together. I talk to one agent; a team does the work. That’s the whole dream of a multi-agent setup, and a good harness is what makes it a workflow instead of a party trick.

Two modes fall out of this naturally:

One big project, many hands. The chief of staff splits a single effort across the crew: Daedalus lays out the architecture, Link scouts the existing code, Ender takes the hard subsystem, Sherlock stands by for when something inevitably breaks.
Many projects, right specialist each. Or point the team at separate problems at once, letting the chief of staff match each job to whoever’s built for it.

The manager pattern is what keeps it from turning into chaos. Ten agents with no coordination is just ten ways to get confused. One coordinator with ten specialists is a team.

The multi-model escape hatch

There’s a wonderfully practical benefit to a strong harness that has nothing to do with intelligence and everything to do with logistics: it can manage more than one model.

Run out of tokens on one? Spin up another, reconnect it to your GitHub, and keep going. Between Claude, Codex, Gemini, and Grok, if you carry subscriptions across all four, it’s genuinely hard to get stuck. The harness abstracts the provider away, so “I hit a limit” stops being “I’m done for the day” and becomes “switch lanes and continue.”

The same machinery powers concurrency. Because the harness can assign different models to different agents, your chief of staff can run on one model while each specialist runs on whatever suits its role, all at the same time. Different models, different agents, different jobs, one team, running in parallel.

Beyond code: pointing the team at a life

Here’s where it stops being a coding trick and starts being something I actually care about. The same structure, a chief of staff directing focused specialists, works on goals that have nothing to do with software.

I keep a running list of the kind of person I’m trying to be:

A supportive husband who actually understands her needs and struggles.
A loving father who backs his kids’ interests and gives them unstructured, unhurried time.
A top-notch home caretaker, the clean garage, the organized closet, the dog-poop-and-appliances stuff that quietly runs a household.
A responsible, healthy man, mobility work, less belly fat, more strength.

None of that is a coding task. But all of it is the kind of thing a well-briefed, well-remembered system is good at: holding the goal, breaking it into next actions, and nudging me back on track when I drift. If a harness can keep a coding project’s context alive across sessions, it can keep these alive too. That’s the version of this I’m building toward.

How does it compare to OpenClaw?

The obvious question, if you’ve been following this space, is how Grok Bot stacks up against OpenClaw, the open-source harness a lot of tinkerers reach for first.

They’re solving the same problem from opposite ends. OpenClaw is the maximalist, roll-your-own option. It’s open, hackable, and endlessly configurable, which is exactly what you want if you enjoy living in config files and wiring your own orchestration logic. The ceiling is high. So is the setup cost. You own every piece, including the parts that break at 11pm.

Grok Bot trades some of that raw flexibility for a smoother on-ramp. The multi-agent model is a first-class feature rather than something you assemble yourself, personalizing an agent is a built-in idea instead of a convention you invent, and the harness handles the caching and environment consistency for you rather than leaving it as an exercise. You give up a little control and you get back a lot of time.

A few honest distinctions as I see them:

Setup. OpenClaw expects you to bring the plumbing. Grok Bot ships with more of it already connected.
Personalization. Naming and specializing agents is a core Grok Bot workflow. In OpenClaw it’s achievable, but it’s on you to structure.
Model juggling. Both can talk to multiple providers. Grok Bot leans into the “run out of tokens, switch lanes, keep going” pattern as an expected way to work rather than a clever hack.
Who it’s for. OpenClaw rewards the person who wants to understand and control every layer. Grok Bot rewards the person who wants a team working today.

Neither is strictly better. If you want a workshop, OpenClaw hands you the whole workshop. If you want a crew that’s already clocked in, Grok Bot is the faster path. I’ve spent time in both, and lately I reach for the one that lets me think about the work instead of the wiring.

Where is this expected to go from here?

If I had to bet, the next chapter is less about smarter models and more about smarter coordination. A few directions I think are coming, some sooner than others:

The chief of staff gets real autonomy. Right now I still hand it the goal and watch closely. The near future is a coordinator I trust to break down a fuzzy objective, assign it, check the results, and only surface the decisions that genuinely need me.
Persistent memory across the whole team. Today each agent’s context lives mostly in its own lane. The version I want is a shared, durable memory the entire crew reads from, so Sherlock already knows what Daedalus built last week without me repeating it.
Agents that improve their own guidance. The .md files that steer each specialist are hand-written now. It’s a short hop to agents that notice a recurring mistake and propose an edit to their own instructions.
Blurring the line between coding and life admin. The same structure that ships software can run a household or a training plan. I expect the “point a team at a personal goal” idea to stop feeling novel and start feeling normal.
Provider-agnostic by default. As harnesses mature, which model sits behind which agent should matter about as much as which brand of wrench is in the drawer. You pick the right tool for the job and stop thinking about it.

None of this requires a breakthrough. It mostly requires the harness to keep getting better at the unglamorous work of remembering, coordinating, and staying out of the way. That’s the part I’ll be watching.

The real takeaway

It’s tempting to chase the newest, smartest model. But the leverage isn’t in the model, it’s in the harness around it: the skills it loads, the context it caches, the environment it keeps consistent, and its ability to run a whole team of specialists, across multiple models, toward a goal.

Grok Bot made that team concrete for me, and gave a wizard, a scout, a boy general, an inventor, and a detective somewhere real to live. The characters are a bit of fun. The structure underneath them, one coordinator, many specialists, persistent context, model-agnostic, is the serious part.

If you’re curious what a setup like this could look like for your own work, or your own life, that’s exactly the kind of thing I love thinking through. Come say hi.