Agensh Removes the Dispatcher

If You Only Read One Thing

A thousand agents can spend six hours working and still leave almost half the tests failing. Microsoft’s newly released Agensh harness makes the case for removing the dispatcher; GPU-unlock’s independent serving tests make the case for speeding up prompt processing. Both reward a more specific question than “Is it faster?” Which part of the job was actually holding everything up?

Agensh Lets Workers Find Work

Agensh makes a serious case for letting coding agents coordinate without a manager assigning every task. Microsoft released the harness on October 24, turning September’s research into something people can inspect and run. A central manager can become the bottleneck even when its workers have plenty left to do.

Microsoft used GPT-5.6 Sol to rebuild programs from observed behavior and documentation, with six hours and no internet. Across five difficult ProgramBench tasks, teams of 128 agents passed an average 28.78% of tests, versus 19.31% for one agent. Microsoft also reports a newer GPT-6.1 Sol experiment on Pandoc, the document converter: 79.59% with 32 agents against 56.19% with one. These are shares of tests passed in unfinished reconstructions, not shares of projects successfully delivered.

What replaces the manager? Agensh gives peers a shared workspace, messages and reusable context. Workers find a subtask, claim it, investigate, verify and merge their progress. Gitea holds the work; Mattermost carries messages.

A worker can pick up a useful finding without waiting for a central session to read it, summarize it and send out another assignment.

If you already run isolated worktrees and parallel workers, Agensh changes who decides what happens next. Your manager can still define the goal and the acceptance rules. Agensh moves repeated task discovery and coordination into the worker pool. A larger team can then pursue opportunities that a busy dispatcher hasn't noticed yet.

Microsoft hasn’t shown that this is the cheapest way to finish ordinary repository work. Its six-hour comparison allows larger teams to consume more resources, and the release guide identifies changes from the historical experiment. I’d take the architecture seriously, but I wouldn’t replace a working manager on these results alone.

Agensh also sharpens yesterday’s discussion of removing specialist handoffs. Yesterday, Anthropic tested whether a separate worker earned its overhead. Microsoft asks whether a central dispatcher earns its place between workers. An agent system can consolidate specialist roles while decentralizing the remaining coordination.

A team comparing architectures could give managed workers and peers the same task, spending allowance and final acceptance checks. Agensh earns a place in a production workflow when its workers finish more accepted work within that shared allowance. The peers would have to beat the managed team’s accepted output at equal spend, including integration and repair.

GPU-unlock Speeds Up the Front

GPU-unlock can make a local agent start answering sooner without making it write much faster. An agent with long prompts gets a useful improvement; an agent waiting on generation doesn’t get a general doubling of speed.

An RTX 3090 owner captured the practical effect in an October 25 report. The reporter served quantized Qwen3.8-27B through vLLM and compared the same 250-watt power cap. The RTX 3090 cut the wait for its first token from 126.8 to 101.4 seconds with a roughly 96,000-token prompt.

The card generated around 30 tokens a second in both runs. The reporter used fresh prompts, 512-token outputs and medians of three runs.

A local agent reading an unfamiliar repository would feel those saved 25 seconds. An agent producing a long answer from an already cached conversation would benefit much less.

The 3080 reporter’s matrix tests help explain the split: floating-point operations ran faster, while integer operations stayed flat. GPU-unlock changes particular execution paths. The 3090 reporter also had to make it load before NVIDIA’s driver. A local agent can hit different limits while processing its prompt and generating its answer on the same card.

The 3080 reporter supplied a broader comparison in paired serving tests updated October 24. On two memory-modified RTX 3080s, the reporter fixed the power cap and tested several prompt lengths and concurrency levels. The vLLM configuration processed prompts 33–36% faster; generation changes overlapped the runs’ normal variation.

Both reporters bypassed prefix caching and used short outputs: 384 tokens on the 3080s. If you separate those phases and control cache reuse, you can see which wait actually shrinks.

GPU-unlock requires an unofficial boot-path change. The 3080 report repeats measurements within boots, without randomizing boot order. NVIDIA isn’t supplying a supported fleet upgrade here. I’m fairly sure the prompt-processing gain is real on the reported systems; long-term reliability and transfer to another setup need their own evidence.

A local agent could start fresh codebase investigations sooner, especially with modest answers. A matched run with the prefix cache enabled would reveal the remaining opportunity: elapsed time saved per completed agent task after ordinary context reuse, including the unchanged generation time.

The Contrarian Take

Everyone says: A bigger team needs a more capable central manager to keep it useful.

Here’s why that’s wrong: Agensh’s workers organize useful progress without a central dispatcher. Microsoft reports higher test coverage as peer teams grow, so central assignment clearly isn’t a prerequisite for scaling this kind of coding work. The owner still needs to define success and control resources. But task allocation can belong to the workers, while the owner keeps authority over acceptance. Buying a stronger manager is only one possible response to a manager that can’t keep up.

Under the Radar

Agensh’s peers can merge without approval. The released setup allows pull-request merges with zero required approvals and disables its continuous-integration merge gate. That helps peers move freely, but it also puts responsibility for acceptance outside the merge event. A merged change in this experiment isn’t equivalent to an independently approved change in the reader’s existing review loop. The release conditions make that choice explicit.
The same GPU change can yield a much smaller serving gain. The dual-3080 reporter also tested Strata with a different model representation. That configuration showed little prompt-processing improvement at 8,000 tokens and roughly 12–13% at longer inputs. Hardware alone therefore can’t predict the gain; the engine, kernels and model representation travel together. The report usefully exposes that boundary without isolating which software difference caused it. The paired configurations are more informative than a matrix-multiplication headline.

Quick Takes

IQuest-Q1 adds another deployable coding candidate. The October 22 release has 320 billion total parameters and 15 billion active per token, with dedicated vLLM and SGLang deployment paths. Its sparse compute bill doesn’t shrink the entire model’s storage requirement: the published vLLM recipe uses eight-way tensor parallelism. IQuest belongs in server-scale coding comparisons; its own benchmark table can’t settle a switch from the current frontier models. (Source)
Unified-brain makes retrieval size depend on the question. The October 24–25 repository updates expose a codebase-memory service that can score stored knowledge with Jev, then retain evidence above a threshold within count and character limits. That extends the reader’s existing relevance-matched learning files with a runnable selection mechanism. The extra scoring call buys a variable evidence set; the project’s sweeping accuracy claims still need independent testing. (Source)
NVIDIA’s small-model release has two distinct jobs. October 23 Bolt E4B artifacts include full-precision weights for customization and a quantized GGUF variant aimed at local assistants. NVIDIA publishes a vLLM example for the former and llama.cpp commands for the latter. That makes the release useful beyond a model announcement, while keeping adaptation and local serving separate. A “4GB” model name alone can’t specify the memory needed for a long conversation. (Source)

The Thread

A faster component matters in proportion to how much of the job it controls. GPU-unlock makes that visible within one request: accelerating prompt processing saves little when generation dominates. Agensh raises the same question across workers: a stronger dispatcher helps only while dispatch is the limiting step. Once peers can claim useful work themselves, integration or final acceptance may take over as the constraint. This adds a timing question to the recent discussion of agent boundaries. Before deciding how many workers a system needs, its owner needs to know where workers wait and where useful progress stops. A local run with heavy prefix reuse and a peer team with a crowded merge queue may both have impressive component benchmarks and disappointing completion times. The best next improvement is whichever changes that remaining wait, even if its isolated benchmark looks less exciting.

Prediction Ledger

Weekly Scorecard

MiniMax would publish M3.1 Flash weights by October 30. Made October 20, medium confidence. Correct, ahead of deadline: the official repository contains downloadable weight shards. Availability settles this call; successful deployment is a separate question.
NVIDIA would publish Bolt E4B weights and an inference example by October 30. Made October 23, high confidence. Correct on delivery: NVIDIA’s full-precision model card dates availability to October 23 and includes a vLLM recipe. The model card records the promised October 23 release.
VibeMemBench would publish executable evaluation code by October 24. Made September 24, medium confidence. Correct: an October 19 commit added the memory, agent and scoring stages with usage instructions.

The overdue Fast Search guidance call stays pending verification because its primary page blocked access. The older unresolved backlog remains open; a failed lookup isn’t evidence that a forecast was wrong.

These calls had named artifacts or an announced release milestone behind them. They say little about whether a tool will become popular or outperform another system in production. I’m keeping that boundary when choosing the next forecast.

Issue date: 2026-10-26. Generated: 2026-10-26 03:36 ET.