We're the bottleneck, but we don't have to be — Ido Salomon, AgentCraft

Coding agents can produce anything from cat memes to B2B SaaS applications. Why, then, doesn’t everyone have an army of them? Ido Salomon, creator of AgentCraft, starts with the gap between an agent’s capability and a person’s ability to use many agents at once. The imagined setup is easy: get enough monitors, start 25 agents, and let them work. The actual work begins after they start.

Each agent needs steering, direction, and review. Adding agents adds demands on the same person’s attention, until supervision becomes exhausting. Salomon’s diagnosis is that the human becomes the bottleneck. More work can run concurrently than one person can comfortably understand and guide.

Strategy games offer a familiar way to handle this problem. In Warcraft, or even The Sims, multiple units act while the player watches, intervenes, and decides what should happen next. AgentCraft takes that experience into work: a game-inspired orchestrator that represents agents spatially and gives their supervisor controls for understanding and directing them. The useful skill being borrowed is managing several active units without inspecting every action continuously.

An AgentCraft unit represents an actual agent. The application can detect agents already running on the device or start new ones. Selecting a unit opens a side panel where the user can prompt it, including by voice. Buildings represent other work functions: managing plugins and skills, opening an integrated terminal, and using Git. The game vocabulary organizes ordinary tools into one space.

Visibility has several distinct jobs:

• Agent status: The side panel shows each agent’s task, its last action, and what it is doing now. That gives the user a quick way to decide who needs attention.
• Location of work: The file system can be projected onto the map. Files appear as runes, and agent activity is associated with the directories or files being worked on. Inspecting a file reveals what an agent did and when.
• Activity overview: Those associations support heat maps, letting the user see where work is happening across the project.

A map helps only if the user can respond to what it reveals. AgentCraft borrows another game control: pressing the space bar jumps to the next nearby item needing attention. The supervisor can move between questions and plan approvals rather than repeatedly searching through every agent. Status tells the user what is happening; the shortcut turns that information into an intervention.

Seeing everything does not mean being able to hold everything in your head. Following agents at the level of files and tool calls remains tiring, and a large project creates another demand: deciding what to do next. AgentCraft lets an agent inspect the codebase and suggest tasks. Those tasks become quests that the user can accept with a button, after which an agent does the work.

Task suggestions relieve the user of inventing every next step, but accepting 20 quests can still leave 20 jobs to babysit. The next layer delegates coordination itself. A user supplies a general goal; an orchestrator breaks it down and runs the work. In the demonstrated setup, execution happens in a local container, which Salomon describes as keeping the work isolated while the agent handles supervision.

Loops extend that delegation to ongoing sources of work. The examples are scanning Twitter for things to build or scanning GitHub, then creating features in the background. This reduces how much the user must specify up front. It also creates a downstream problem: even five completed changes arriving together can be difficult to review.

The review kit packages the result for that decision. It offers the changes and changed files for file-by-file inspection, alongside images or videos showing what changed. It also supports comparing implementations produced by several parallel instances and choosing the preferred result. Visual evidence makes the visible consequence easier to inspect; the file view remains available for examining the underlying changes.

Where does human attention go as more work becomes autonomous? The flow below shows two ways work enters execution: a general goal decomposed by an orchestrator, and background loops that find work. Both eventually produce changes for review. Delegating execution reduces continuous supervision, while making the presentation of completed work more important.

Visibility and autonomy still leave one person responsible for the results. That person may also be the wrong reviewer for part of the work. AgentCraft’s next step is collaboration: locally hosted shared rooms, with tunnels allowing other people to join.

The concrete example is a product designer joining the room—in this case, Salomon’s wife. After he approves her entry, she works on a design. Her work becomes visible on his map, so he can follow up on the design and implement it while she continues working. The observable change is from one person supervising alone to two people advancing different parts of the same project concurrently.

The shared workspace supports handing off or forking work. Git remains usable, while coordination also happens inside the room. Chat connects people and agents, and a notice board records what each participant is doing. In the design example, the engineer can announce that he has taken on the design task, giving the others information about the follow-up rather than leaving them to infer it from changes.

How can implementation begin without making the designer stop? The diagram follows the example’s two paths: the designer continues designing while the engineer follows up on the visible work. The room’s activity information helps participants coordinate those paths. Access also extends to mobile devices and Telegram, so participation need not stay tied to the map on a desktop.

The combination of visibility, autonomy, and collaboration raises the ceiling for power users. The more surprising feedback concerns people who had not used agents before: parents reporting that their children enjoyed orchestrating agents, and a former StarCraft player finding a productive use for familiar skills. These are Salomon’s reported anecdotes; his estimate that roughly 90% of people need a lower entry point is an approximation, rather than a measured adoption result.

That feedback leads to a different interface experiment, tentatively called Loopers. Warcraft-style complexity can itself be daunting, especially for someone uninterested in which files an agent is editing. The proposed experience moves toward the level of a mobile game: projects users return to, autonomous loops that keep work going, and a basic interaction of prompting and receiving a result.

The tradeoff is how much execution detail the interface asks the user to manage. AgentCraft brings file activity forward; the simpler concept lets users focus on results and inspect the process when they want to. It relies more heavily on agents acting autonomously, while trying to make the experience inviting enough that people return to their projects.

A game interface will not feel easy to everyone. Something inviting to one person can be difficult for another. Salomon therefore treats this as an early experiment in customization: finding what a particular person needs to understand the tools and want to use them. Loopers is a very early draft, and its tentative name reflects that unfinished product direction.

The closing invitation separates the two products’ stages. AgentCraft is already available to use. The simpler concept remains experimental, with Salomon seeking interest and feedback about the level of accessibility or capability people want. The next design decision depends on what users need to see, control, and return to—not on assuming that one game metaphor suits everyone.

The practical invitation is to take familiar skills from elsewhere in life and apply them to agent work. Strategy games supply one such vocabulary: watch units, notice what needs attention, delegate work, and coordinate with others. AgentCraft turns those actions into controls for coding agents; the simpler experiment asks which controls a person needs before the experience becomes useful rather than exhausting.