This Developer Turned Coding Agents Into an RTS

Here's a question that sounds ridiculous until you think about it for five seconds: what if managing AI coding agents is basically the same skill as playing StarCraft?

That's the premise behind AgentCraft, a new tool from developer Ido Salomon that treats AI agents like units in a real-time strategy game. And honestly? The comparison kinda slaps.

Salomon presented AgentCraft at an AI Engineer conference in London, and his core insight is weirdly compelling: "The role of the engineer to actually go and manage dozens of reckless employees is not typically what we do in most companies," he said. "So, we need to somehow find these new potentially new skills to manage all of these agents. Luckily, they're not really brand new... if you're a gamer or used to play games at any point, managing dozens of units probably sounds a little bit familiar."

The thing is, he's not wrong. If you've ever played an RTS game, you've dealt with the exact problems that emerge when running multiple AI coding agents: tracking what everyone's doing, preventing collisions, allocating resources, and not losing your mind in the process.

Why Multi-Agent Everything Is Hard

The promise of AI agents is intoxicating: if one agent is amazing, why not spin up 10? Or 20? Or 100? The math seems simple. The reality is... not.

"Spinning them up isn't a problem," Salomon explained. "It's us. We are the bottleneck in orchestrating all of these agents."

This is the part people don't talk about enough. We're so focused on making individual agents smarter that we've barely started thinking about the human factors of managing them at scale. It's like we invented really good interns and then gave ourselves 47 of them without any management training.

The UI problems alone are wild. How do you even visualize what 10 agents are doing simultaneously? How do you know when they're about to step on each other's toes? Traditional development tools weren't built for this—they assume one human, one task, linear progress.

The Gaming Solution

AgentCraft's approach is to literally render your codebase as a map. Your file system becomes terrain. Directories are areas. Files are rooms. And agents move through this space, visibly working on specific files.

It sounds gimmicky until you see it. Each agent appears as an actual unit on the map. You can watch them navigate to different files, see their change lists, track who did what and when. There's even a heat map showing where agents are clustering—basically collision detection for code changes.

"I can actually track and see visually what the agent is working on, which file," Salomon demonstrated. "I can see the entire change list of what happened there. And because we're orchestrating it, I also know which agents did what and when."

The RTS influence goes deeper than aesthetics. AgentCraft borrows the concept of hotkeys for cycling between units that need attention. Need to approve a plan? Agent 3 is requesting input. Got a question to answer? Tab to Agent 7. It's muscle memory transplanted from gaming to development.

The Autonomy Gradient

What makes AgentCraft interesting (beyond the gaming aesthetic) is how Salomon thinks about progressively removing himself from the equation.

First layer: basic visibility and quick reactions. You can see what agents are doing and respond when they need you.

Second layer: quest systems. Instead of constantly thinking of tasks, agents can suggest missions based on the codebase—refactoring, testing, maintenance work you'd rather not touch.

Third layer: campaigns. This is where it gets spicy. You give agents a broad goal, they spin up in a container, decompose the task themselves, and only surface the results for review. "I don't care what they're doing because it's a container, so do whatever," Salomon said. The campaign orchestrator handles the babysitting.

Fourth layer (and this is borderline absurd): automated ideation. Salomon mentioned setting up a cron job where agents scan Twitter for interesting ideas and just... implement them. You wake up to a bunch of PRs to review. "Which is actually how I implemented channels pretty quickly," he noted.

This progression raises questions about what "programming" even means when you're spending more time reviewing than planning. Salomon's explicit about this shift: "How much time do I need to spend on the plan if I can just do it 10 times and I'll just pick the one that is most fitting for me?"

That's a fundamentally different workflow. You're not architecting solutions anymore—you're curating them.

The Collaboration Layer

Here's where things get genuinely novel: AgentCraft supports shared workspaces where multiple humans can see each other's agents. A product designer on their machine can run agents that you can see on yours. You can hand off work between your agents and theirs.

But it's not just human-to-human coordination. There's a shared chat where agents announce what they're working on, and humans can pipe up too. "The agent said, 'I'm starting to work on something.' And then I can say, 'I'm also working on it,'" Salomon explained. "So the next time the agent does something, it knows someone else is working."

This soft coordination—where agents and humans can see each other's activity without explicit commands—feels like the kind of thing that either becomes essential or turns into notification hell. Probably both, depending on team size.

What's Actually Being Tested Here

AgentCraft is still experimental (Salomon is clear about this), and it's trying to solve a problem that most developers haven't fully encountered yet. We're not quite at the "dozens of agents" stage for most workflows.

But the underlying questions are real:

When agents can work in parallel, how do we maintain situational awareness without constant context-switching?
What's the right balance between planning work ourselves and reviewing agent-generated options?
How do we coordinate between human teammates when we're each managing our own fleet of agents?
At what point does "programming" stop meaning "writing code" and start meaning "directing autonomous workers"?

The gaming metaphor works because RTS games already solved these problems for a different domain. You need visibility (minimap), quick response mechanisms (hotkeys), and ways to delegate without micromanaging (rally points, unit behaviors). AgentCraft is basically arguing that developer tools should steal these patterns.

Whether the literal game aesthetic is the right move—or just a clever way to make a demo memorable—is harder to say. But the core insight feels sound: the skills we need for multi-agent orchestration aren't entirely new. We've just been practicing them in a completely different context.

Salomon's betting that the path forward isn't making agents smarter in isolation—it's building better interfaces for humans to work with many agents at once. The ceiling he's trying to raise isn't agent capability. It's human coordination capacity.

Which, honestly, might be the more interesting problem anyway.

Yuki Okonkwo is Buzzrag's AI & Machine Learning Correspondent