# AgentCraft: Putting the Orc in Orchestration Ido Salomon | AI Engineer Europe 2026 | 11:18 Source: https://www.youtube.com/watch?v=kR64LOqBBCU Channel: AI Engineer (https://www.youtube.com/@aiDotEngineer). Summarised by AIE Talks. Page: https://aietalks.com/talks/agentcraft-putting-the-orc-in-orchestration Published: 2026-04-25 Tags: agents, coding-agents, computer-use, design, multi-agent ## TL;DR - Running many agents in parallel makes the human operator the bottleneck, so orchestration needs better visibility and faster ways to react. - AgentCraft borrows ideas from games, including maps, quests, campaigns, and muscle-memory controls, to help people manage coding agents. - The system moves work away from constant babysitting through autonomous campaigns, review bundles, visual evidence, and collaboration between humans and agents. ## Summary Ido Salomon presents AgentCraft, an orchestrator for managing multiple coding agents. His starting point is that creating more agents is easy, while keeping track of them becomes difficult for the person coordinating the work. AgentCraft turns agents into visible units on a game-like map that reflects the user's file system. It shows mission status, file changes, agent lineage, and possible collisions. Salomon then describes quests for routine work, campaigns that let agents decompose and execute broader tasks in containers, and review bundles with screenshots and videos. The system also supports shared workspaces where people can see one another's agents and coordinate with them through direct prompts and chat. Salomon argues that these skills are familiar from games, even if engineers have not used them at work before. AgentCraft is experimental and available for people to try and give feedback. ## Key ideas ### The human operator becomes the bottleneck when many agents run at once [00:37](https://www.youtube.com/watch?v=kR64LOqBBCU&t=37s) Salomon argues that scaling from one agent to 10, 20, or 100 does not automatically make the work 100 times better. Spinning up agents is easy. The difficult part is managing them. Engineers are rarely trained to supervise dozens of reckless employees, yet multi-agent systems create a similar coordination problem. Salomon says the skills needed for this work are not entirely new. They have been used in games, where players manage many units at the same time. AgentCraft applies those patterns to productivity and coding work, with the stated goal of raising the ceiling of human-agent collaboration. ### AgentCraft turns coding agents into visible units that can be controlled [01:48](https://www.youtube.com/watch?v=kR64LOqBBCU&t=108s) AgentCraft represents a live coding session as an agent that can be detected on a device, visualized, or spawned from the application. Salomon says it can work with agents such as Cursor, Claude Code, Codex, or OpenClaw. The user can prompt an agent with voice, text, or images, then ask it to develop a feature. The interface surrounds the agent with buildings that represent functions such as skills and plugins. It also includes an integrated terminal and Git, so the workflow can run from the same place. The design treats agent management as an active workspace rather than a list of disconnected sessions. ### A map of the file system gives the operator a view of agent activity [03:06](https://www.youtube.com/watch?v=kR64LOqBBCU&t=186s) Salomon describes visibility as the second part of improving orchestration. AgentCraft has a side panel with a high-level mission summary, but its map provides more detail. The map is a projection of the file system. Directories appear as areas, and files appear as rooms. This lets the user see which file an agent is working on and inspect the complete change list. Since the orchestrator knows which agent made each change and when, it can provide lineage for the work. Salomon also describes a heat map that can show collisions between agents and potentially prevent those conflicts before they happen. ### Game controls help people react quickly when agents need attention [04:47](https://www.youtube.com/watch?v=kR64LOqBBCU&t=287s) Visibility alone does not finish the orchestration problem. Agents may need approval for a plan or answers to questions, so the operator still has to respond. AgentCraft borrows a mechanism from real-time strategy games by letting the user cycle quickly through agents that need help. Salomon compares this to muscle memory. The aim is to reduce the time spent searching for the next blocked agent. This creates a tighter loop between seeing what is happening and taking the required action, although Salomon says it only solves the first part of the larger problem. ### Quests and campaigns reduce the amount of work the human has to invent and supervise [05:25](https://www.youtube.com/watch?v=kR64LOqBBCU&t=325s) Salomon identifies two limits on parallel work. People can hold only so many ideas in their heads before becoming tired, and watching many agents still takes time. AgentCraft addresses the first issue with quests, where agents find tasks such as refactoring and testing that the user does not want to handle directly. Campaigns go further. The user gives a broad description of the desired outcome, and AgentCraft starts a container where agents can decompose the task, plan it, and present the plan. The campaign orchestrator takes over the ongoing babysitting, leaving the person with more work in planning and review. ### Review bundles let the operator compare many agent-produced changes [06:48](https://www.youtube.com/watch?v=kR64LOqBBCU&t=408s) Salomon describes running campaigns on a schedule, including a cron job that could scan Twitter for ideas and implement them. This produces many pull requests, so AgentCraft includes review bundles. A bundle shows what changed, why the agents made the changes, and which tasks they addressed. Salomon also wants reviewers to rely on visual evidence, including screenshots and videos, instead of spending as much time reproducing the work themselves. With this approach, the user can shift effort from detailed planning toward review. He suggests running a task multiple times and selecting the plan that fits best. ### Shared workspaces extend coordination from one person to a team [07:47](https://www.youtube.com/watch?v=kR64LOqBBCU&t=467s) Salomon says agents are not yet smart enough to handle every part of the process alone, so AgentCraft also involves other humans. Shared workspaces let a product designer and an engineer see each other's agents and continue work from where the other person stopped. One person can wait for a designer's agent to finish or hand the work to their own agents immediately. Collaboration happens through direct prompts and through a chat shared by humans and agents. Agents can state what they are doing, learn that someone else is working on the same area, and see which files other participants are changing. ### The project treats game skills as practical skills for future engineering work [09:32](https://www.youtube.com/watch?v=kR64LOqBBCU&t=572s) In his conclusion, Salomon says engineers may worry about a future in which they tell agents or other people what to code instead of writing everything themselves. He argues that the required abilities already exist, although people have not normally used them at work. AgentCraft applies game-inspired skills through visibility, greater agent autonomy, and human-agent collaboration. He is direct that the product is free, experimental, and new, with more changes needed. He asks users to try it, join the Discord community, and provide feedback. ## Notable quotes - "It is us. We are the bottleneck in orchestrating all of these agents." (00:37) - "The cool thing about Agent Craft is that we don't just see a list of what they can do. We can actually see them working." (03:49) - "How do I take myself out of the equation as much as possible?" (05:44) - "The campaign orchestrator and that's his problem." (06:25) - "These are not exactly new skills." (09:52) ## Tools & references mentioned - AgentCraft - Cursor - Claude Code - Codex - OpenClaw - Git - Twitter - Discord ## Who should watch - You are building or using several coding agents and spend too much time checking their status, resolving collisions, or answering routine questions. - Your team needs a shared view of agent work across engineering and product design, including file changes and handoffs. - You want to experiment with autonomous coding campaigns while keeping human review through plans, pull requests, screenshots, and videos. ## Related talks - [Develop at Idea Velocity](https://aietalks.com/talks/develop-at-idea-velocity) (Jeffrey Lee-Chan, Snapchat, 15:28) - [The Missing Primitive for Agent Swarms](https://aietalks.com/talks/the-missing-primitive-for-agent-swarms) (Lou Bichard, Ona, 18:37) - [Don't Build Agents, Build Skills Instead](https://aietalks.com/talks/dont-build-agents-build-skills-instead) (Barry Zhang & Mahesh Murag, Anthropic, 16:22) - [Agents Need More Than a Chat](https://aietalks.com/talks/agents-need-more-than-a-chat) (Jacob Lauritzen, Legora, 14:21) - [Conquering Agent Chaos](https://aietalks.com/talks/conquering-agent-chaos) (Rick Blalock, Agentuity, 14:40)