Microsoft's Agensh Tests Coordination Across

Microsoft Research has open-sourced Agensh, a system designed to let AI agents coordinate through a shared Git repository, chat and a findings board instead of taking instructions from one central orchestrator. Researchers tested configurations ranging from one agent to 1,024 on ProgramBench with a six-hour time budget. That is an unusually large coordination experiment for AI coding agents. Its practical value depends on what those agents accomplish together, and at what cost.

A harness is the software around an AI model that gives it work to do and a way to use tools. In a coding task, the model might inspect files, propose edits or run checks; the harness determines how that work proceeds and how agents interact. Agensh puts the shared workspace at the center of that interaction. Rather than route every decision through a manager agent, workers can leave information where other workers can find it.

The reported ProgramBench tests span one to 1,024 agents, but the account gives neither task-level scores nor a description of the tasks, so the agent count alone cannot show whether larger teams produced better results. The release opens a more useful line of inquiry: when does shared coordination help, and when does it become another job for the agents to manage?

A Workspace Instead of a Manager

Consider a coding problem with several plausible lines of investigation. One agent checks an error path, another looks for the relevant tests, and a third examines a recent change. In a centrally managed setup, a controller could assign those jobs and collect the answers. In Agensh's design, agents have a repository for code, chat for communication and a findings board for discoveries. The workspace can carry information between workers without every exchange passing through a single decision-maker.

The appeal is straightforward. A controller handling a handful of agents may keep everyone aligned. At hundreds of agents, assigning work, reading updates and deciding what happens next could consume time and attention of its own. Shared tools give workers a way to make progress while others are busy. They also give an investigator somewhere to leave a finding that might save the next investigator from starting at zero.

Git brings a familiar strength to this setup: changes to files can be recorded and reviewed. It also brings a familiar warning. When many contributors work in one codebase, someone must still decide how overlapping edits fit together. A chat message can announce a plan, but other agents have to read it, understand it and act on it before they create a conflicting plan. A findings board can reduce repeated investigation, provided workers check it and trust what they find there.

Decentralization changes where coordination happens; it does not abolish coordination. A manager can become a bottleneck. A shared workspace can become crowded, stale or internally contradictory. Neither outcome is automatic, and a useful test would show how often agents spend their time resolving those problems.

What Does the 1,024Th Agent Do?

The number in the headline describes a tested configuration, not a recommended team size. Coding work rarely divides into 1,024 independent pieces of equal value. Some tasks can proceed in parallel, such as investigating separate files or checking alternative hypotheses. Others form a sequence: a later edit depends on an earlier diagnosis, and a final test depends on the edits being integrated.

This creates a simple question for anyone evaluating Agensh: what does each additional worker contribute after the obvious parallel work has been assigned? An agent that finds a missed bug earns its place. One that repeats an existing finding, proposes a conflicting edit or reads the same repository state without advancing the task consumes resources while producing little progress. More agents also create more communication for the group to sort through.

The six-hour budget makes those choices consequential. If two teams finish the same task within that window, the one that gets there sooner may be preferable for a developer waiting on a fix. If they finish at the same time, the team using fewer model calls, tokens or compute may be cheaper to run. If the larger team finds a correct solution the smaller one misses, that improvement may justify the extra expense. Those are different outcomes, and an agent count captures none of them.

The multi-agent trade-off is familiar beyond Agensh: parallel workers help when they can split useful work, while coordination can eat into the gains. At 1,024 agents, even a small amount of duplicated effort per worker can add up. Conversely, a single worker's missed clue might be caught by another. The engineering problem is to find out which effect dominates on tasks people care about.

A Fair Test for a Shared Workspace

A strong comparison would hold the task and time budget constant while varying the number of agents. It would measure successful, verified outcomes alongside wall-clock time, token use and compute cost. Results for one agent, a small team and much larger groups would show whether improvements continue as the group grows or flatten out. Repeated runs would help distinguish a reliable gain from a lucky attempt.

Quality checks matter especially for coding work. A patch that looks convincing in chat can fail tests or break another part of a program. A team might also spend its budget producing many proposed fixes without integrating one that works. Success criteria should reward a working final result rather than the volume of activity in the workspace. Git gives the agents a place to record changes; it does not make those changes correct.

The workspace itself deserves measurement. How much work gets duplicated? How often do agents pursue incompatible approaches? Can a useful finding reach the workers who need it before they commit to another path? These questions would reveal whether decentralized communication is solving the controller bottleneck or moving that bottleneck into chat and the findings board.

Open-sourcing the harness gives other researchers a route to examine such questions. They can study how work is shared, change coordination rules and try tasks outside ProgramBench. Reproduction will also depend on the models, budgets and evaluation procedures used in a test. A harness supplies the structure for collaboration; the behavior of the workers and the difficulty of the job still shape the outcome.

Who Pays for More Workers?

For a software team, the attraction of a large agent group is easy to understand. A difficult issue might benefit from several simultaneous investigations, especially when the alternative is waiting for one agent to exhaust each idea in turn. A decentralized setup could let the group keep moving without asking a controller to approve every step.

The bill is less glamorous. More workers can mean more model usage, more code to inspect and more decisions for a human developer to verify. If a system delivers a better fix faster, those costs may be worthwhile. If it produces the same fix with ten times the activity, the advantage is harder to locate. The people maintaining the code ultimately inherit the result, including any errors that survive the agents' checks.

Agensh makes a sharp bet about AI teamwork: give workers common tools, and they may coordinate effectively without a manager in the middle. The open release lets others put pressure on that bet. The decisive result will be a working change that a smaller team could not deliver as quickly or as affordably, not a repository occupied by 1,024 agents.