AgentCraft: Putting the Orc in Agent Orchestration

If one coding agent is useful, why not launch 10, 20, or 100? A screen full of agents looks impressive, but who will keep them moving in the right direction? The human becomes the orchestration bottleneck. Engineers who normally write software suddenly have to manage dozens of unpredictable workers—a different responsibility from their usual work.

The necessary management skills may already be familiar from an unexpected place: games. Real-time strategy players routinely manage dozens of units, divide their attention, and respond to changing conditions. Ido Salomon built AgentCraft to transfer those interaction patterns into productive work with agents. The goal is to raise the ceiling of human–agent collaboration, starting with how people see and direct live sessions.

An agent on the AgentCraft map represents an actual running coding session. Salomon names Cursor, Claude Code, Codex, and OpenClaw as examples. AgentCraft can detect sessions already running on the device and visualize them, or spawn a session directly from the interface. The demonstration includes the game-like acknowledgment “At your command.”

Once a session exists, the user can prompt it much as they would from a CLI. Inputs include voice, text, and images. In the demonstration, Salomon asks an agent to develop a feature; “Prompt prompt” is heard, and the agent starts working. The game presentation changes how the session is accessed without removing the familiar prompt-and-work interaction.

The surrounding buildings expose supporting functionality. One manages skills and plugins; integrated terminal and Git tools keep the development workflow in the same environment. The visible terminal control is a concrete example: the map is an entry point into development tools, not just a display of animated workers.

With agents running, the next problem is understanding their activity quickly. A side panel provides high-level mission status and summaries. The map supplies another view: it is a projection of the filesystem, with directories placed on the map and files represented as rooms. An agent’s visible location connects its activity to the file it is working on.

That spatial view connects to a change list. The user can inspect what happened in a file, while the orchestrator records which agent made each change and when. These views answer different questions:

Once activity has both a location and an agent identity, Salomon proposes a heat map to expose collisions and potentially prevent them proactively. The walkthrough does not specify a prevention algorithm; the concrete foundation is visibility into overlapping work and its lineage.

Visibility helps only if the user can react. AgentCraft borrows another RTS interaction: using muscle memory to cycle quickly between units that need attention. Here, the interruptions are requests to approve a plan or answer a question. Instead of repeatedly searching for the next blocked session, the user moves through agents needing help.

Salomon reports that this let him use more agents in parallel, but only for a short time. Faster switching did not remove the mental cost of holding multiple ideas at once. Eventually, the operator becomes tired. Reducing the cost of each intervention is different from reducing the number of interventions. The next layer therefore has to address both the supply of work and its ongoing supervision.

For task discovery, Salomon asks the agents to find missions. These appear as quests that the user can launch with a button, including refactoring and testing work. This reduces the need to invent every next assignment, but leaves another cost intact: someone still has to keep cycling through the agents and supervising them.

A campaign moves more of that responsibility into the agent system:

1. The user supplies a broad goal.
2. AgentCraft spins up a container in which the agents can work.
3. The agents decompose the task, develop a plan, and present it to the user.
4. A campaign orchestrator takes over the ongoing supervision of the decomposed work.

Container isolation is Salomon’s stated reason for tolerating more exploratory activity inside the campaign, rather than a demonstrated guarantee that any action is safe. The organizational change is the central one: the human’s effort concentrates on planning and review instead of continuous babysitting.

Once agents can manage a campaign, even the initial idea need not always come from the user. Salomon proposes a daily cron job that scans Twitter for interesting ideas, implements them, and leaves him to decide which results he wants. He says this approach helped him implement channels quickly. The immediate consequence is a new queue: many pull requests waiting for review.

Review bundles make that queue easier to assess. They bring together the changes, the reasons behind them, and the tasks involved, along with screenshots and videos. A reviewer can inspect both what the agents changed and visual evidence of the result, rather than reconstructing every campaign from its activity history.

This changes the balance between planning and selection. Salomon asks how much effort a detailed plan deserves if agents could instead produce ten implementations and the user could choose the best fit. Ten is a proposed exploration strategy, not a measured productivity result. Its practical dependency is clear: shifting effort away from planning works only if the resulting alternatives are cheap enough to inspect, which is why review evidence follows campaign autonomy in the walkthrough.

Autonomy does not eliminate the need for other people. Agents still have limits, so AgentCraft extends the workspace to human teammates. In Salomon’s example, a product designer works with an agent running on the designer’s computer. Each participant can see the other’s agents and understand what they are doing.

The designer starts work on a new page. The engineer can wait for that work to finish, or hand it off immediately to agents on the engineering side and continue from there. Salomon corrects his own description from “my agents” to “our agents”: the workspace makes the agents part of a shared effort, rather than separate assistants hidden inside each teammate’s machine.

Collaboration then has two forms:

• Direct prompts: A participant can give instructions to their own agents or a teammate’s agents.
• Shared conversation: Humans and agents exchange messages in the same chat, making ongoing work visible without every message becoming a command.

For example, an agent announces that it is starting work, and a human replies, “I'm also working on it.” On its next action, the agent can account for that overlapping activity. Awareness of which files others are changing supports this softer coordination; it does not itself establish an exclusive lock or guaranteed conflict prevention.

The walkthrough leaves additional features unexplored, but closes on the human transition behind the product. Moving from writing code to directing others to write it can feel like entering unfamiliar work. Salomon’s answer is that some of the required skills already exist outside the workplace. Games are one place people have practiced managing units, distributing attention, and coordinating activity.

AgentCraft’s direction is to apply those skills through better visibility, greater agent autonomy, and collaboration between people and agents. Salomon offers it as a free download, with a website and QR code shown at the end of the recording. He also describes the product as new and experimental, with changes still needed, and invites users into its Discord community to give feedback. The invitation is to try whether this style of orchestration improves real work—and help shape it where it does not.