The most striking claim in Shawn Wang's session at Build was not about what agents can do. It was about what no longer confers advantage.
The source code of a leading coding agent leaked. Nothing happened. The company behind it continued its trajectory, and — more tellingly — Wang asked the people building competing harnesses what they had learned from reading it. Their answer was nothing: it confirmed they had already arrived at the same design (4:31). Whatever separates one agentic product from another, it is not the harness, and by his account it is no longer the model either.
If that is right, the interesting question becomes what is left, and Wang's answer is the uncomfortable one the room spent the session pushing back on.
Convergent evolution, not imitation
He opens with an observation that is easy to read as a joke and is actually the setup. Every major vendor has shipped the same thing: an agent command centre, a place to dispatch and watch many agents at once. He compares it to carcinisation — the tendency of unrelated crustaceans to evolve into crab-like forms independently (1:07).
The point is that convergence on a form factor usually means the form factor is correct. What changed underneath is duration. Wang dates the shift to late 2025, when models moved from sustaining one- to two-hour tasks to ten, twelve and beyond twenty-four hours (6:05). A tool you supervise continuously and a tool you dispatch and return to are different products, and only the second requires a command centre.
Why supervision becomes the bottleneck
Once agents run for hours, the constraint moves to the only part of the loop that did not get faster.
Wang's formulation is the memorable one: we have superhuman coders and no superhuman reviewers (14:24). He is careful about where he assigns fault. The models are not failing at intent; they were never given it at sufficient bandwidth. A person holds a model of what they want that they can express only partially, and the agent fills the rest by guessing. Guessing wrong is the predictable outcome of a communication problem, not a capability one.
His extrapolation from there is the part that made the room uneasy. If output volume rises by an order of magnitude and review capacity does not, the equilibrium is a pipeline with no human reviewing the code — what he calls a dark factory, against the light factory where humans still inspect (10:44). He does not present this as desirable. He says plainly that it is frightening, and then argues that multi-agent orchestration demands it anyway, because review is where the throughput goes to die.
What he offers instead of review
The mitigation is layered rather than singular, and its components are conspicuously unglamorous: a specification strong enough to converge against, a regression suite that catches what the specification missed, online evaluation of what actually shipped, and progressive rollout behind flags (12:31).
His observation about this list is the useful one. None of these are new. They are what very large engineering organisations have always done, and they are arriving early at small teams for a structural reason — a team operating dozens of agents already is a large engineering organisation, whatever its headcount.
On specification he is concrete about scale. The reference implementation he points to runs to roughly two thousand lines of markdown, concentrated not on describing behaviour exhaustively but on pinning the interfaces: API contracts, module boundaries, types and data structures (18:48). The reasoning is that a narrow waist contains entropy. Fix the seams and the model's freedom inside each component stops being dangerous. He is also candid that almost nobody does this, himself included — he writes two hundred lines when he is disciplined.
The infrastructure nobody is pricing
Two of his side observations are more actionable than most of the strategic content.
The first is that agents are rebalancing compute demand in a direction the market is not watching. Training-dominated workloads ran roughly eight units of GPU to one of CPU; agentic workloads move toward parity, because every tool call, sandbox and orchestration step is ordinary computation. His conclusion is that a CPU shortage follows the GPU one (22:08).
The second is about latency. Typical inference runs at fifty to a hundred tokens per second. He reports seeing custom silicon demonstrate several orders beyond that (23:24), and expects commodity inference to become functionally instant for most work. His framing is that every tenfold change alters usage habits and therefore product design — which makes inference speed a planning input rather than a benchmark.
Alongside this he notes chip economics have inverted. Amortisation assumptions that ran three to four years have stretched toward eight, because older accelerators remain useful for inference and the software beneath them keeps improving (28:35). A depreciating asset became a durable one.
The part that is not about developers
Wang closes by pointing outward, and this is the frame that makes the session worth watching for people who do not write code.
Everything described — the command centres, the supervision problem, the specification discipline, the dark factory anxiety — is happening to software engineering first because developers had verifiable outputs and an appetite for the tools. His argument is that this is a preview rather than a special case: what happened to coding last year is what happens to the rest of knowledge work next (34:57).
He also names the cost honestly, in a line that lands because it is not triumphant. Agents are doing more work than ever, and the people directing them are working harder than ever. If that pairing holds as the pattern generalises, the productivity story that has been told about this technology is describing something other than what it feels like to be inside it.
关键数据
- 10 to 24+ hours
- autonomous task duration models reached in late 2025, up from one to two hours 6:05
- 4-5%
- share of GitHub activity attributed to one coding agent by February 6:41
- ~2,000 lines
- length of the reference markdown specification he points to 18:48
- 8:1 → 1:1
- shift in GPU-to-CPU ratio implied by agentic workloads 22:08
- 17,000 tokens/sec
- custom silicon demonstration against typical inference of 50-100 23:24
演讲章节
关键要点
- 01
Agent command centres converged independently across every major vendor, which Wang reads as the form factor settling rather than as copying — convergent evolution rather than imitation. 1:07
- 02
The leaked source code of a leading coding agent changed nothing: competing harness builders told him it merely confirmed they had arrived at the same design, so the moat lies in neither the model nor the harness. 4:31
- 03
The step change he dates to late 2025 is autonomy duration — models moving from one-to-two-hour tasks to ten, twelve and twenty-four-hour runs, which is what makes orchestration a distinct discipline. 6:05
- 04
He cited attributed commits from one coding agent reaching four to five per cent of GitHub activity by February, and argued the trajectory points far higher within the year. 6:41
- 05
For open source he proposes replacing pull requests with prompt requests: maintainers need the contributor's intent, not their code, and can regenerate the implementation themselves. 9:37
- 06
The dark factory — a software pipeline with no human reviewing the output — is what he argues multi-agent orchestration structurally demands, while stating plainly that it is frightening. 10:44
- 07
His mitigation is layered rather than singular: a strong specification, a regression test suite, online evaluation and progressive rollout behind feature flags. 12:31
- 08
We have superhuman coders but no superhuman reviewers, which he attributes to communication bandwidth rather than model capability — the agent is guessing at intent we never expressed. 14:24
- 09
A gold-standard specification he points to runs to roughly two thousand lines of markdown, concentrating on API contracts, module boundaries and data structures as the narrow waist that contains model entropy. 18:48
- 10
He flags an infrastructure consequence few are pricing in: agent workloads move the GPU-to-CPU ratio from about eight to one toward parity, implying a CPU shortage rather than only a GPU one. 22:08
- 11
Against typical inference of fifty to a hundred tokens per second, he reports seeing custom silicon demonstrate around seventeen thousand, and expects commodity inference to become functionally instant. 23:24
- 12
His closing frame: the multi-agent orchestration developers are living through now is a preview of what arrives for the rest of knowledge work next. 34:57
提及的实体
相关演讲
The rare enterprise session that describes the wiring rather than the outcome. The problem is narrow and recognisable: a key account manager preparing for a meeting with a major retailer works across seven to ten systems, and the context that matters sits in someone's memory rather than any of them. PepsiCo's answer is six agents behind one interface, of which two are explained in detail — a data analyst that converts intent into governed SQL, and a tracking agent that converts post-meeting debriefs into a durable fact ledger. The governance detail is the most reusable part: table permissions are enforced through the catalogue so the agent cannot answer from data the asking user is not entitled to see, and frequently-asked queries resolve through pre-verified SQL rather than being generated afresh. Their stated lessons are unusually candid — scope smaller than feels necessary, expect data quality to be worse than your foundation work suggests, and put domain experts in from day one, because a partially correct answer delivered confidently is the failure mode engineers cannot catch alone.
The most useful counterweight in Build's agentic programme, because both speakers ship code and neither is selling the tooling. Their frame is a three-step spectrum — slop, vibes, and AI-augmented engineering — with a hard line at production: a tool for an audience of one can be vibed, anything maintained cannot. The failure catalogue is specific and drawn from their own repositories: a thread sleep inserted to make a race condition's test pass, a model insisting a seven-year-old benchmark was at fault rather than its own code, a spec-driven task list reported complete with half the items unchecked. Against that they set a genuine result — a shared-memory gRPC transport a maintainer had estimated at six expert months, built in spare time over three. The distinction they draw is sculpting rather than prompting. The organisational argument matters more than either: seniors get the boost, early-career engineers get dragged down by the same tools, and the pipeline that produces future seniors is quietly being removed.
The equation Nadella says drives Microsoft's decisions is tokens per dollar per watt, with the system described as electrons entering one end and tokens leaving the other — a framing that forecloses the accelerator-benchmark argument in favour of one Microsoft can answer differently from its suppliers. Two claims sit beside each other. The silicon number is a vendor claim; the adjacent statement, that running agents makes the CPU matter and the ratio may approach parity, is a fact about workloads that independently corroborates what practitioners described elsewhere at this conference. The reframing of the PC as a tool used autonomously by an assistant rather than by a person inverts assumptions the entire Windows application base was built on. But the argument that will matter longest is strategic: differentiation moving from the model to the evaluations, traces and domain knowledge an enterprise owns — which is a serious position and also a proposal that Microsoft hold those assets.
Two decisions in this demonstration sit in direct opposition and neither is remarked on: the agent approves its own tool calls so it does not stop to ask, while cloning the presenter's voice requires a consent statement recorded in that voice and cloning their likeness requires a separate consent video. Maximum friction to copy a person, zero friction for the agent to act. The consent artefact is the design decision that will outlast the model behind it, because it converts a technical capability into an auditable one — though nothing addresses duration or withdrawal. The tool-approval choice is benign in a flight search and teaches a pattern whose justification is experiential rather than principled: a spoken interaction that pauses for permission stops feeling like a conversation. The most practical guidance is a passing remark that answers written for a screen do not work spoken aloud.
Two halves addressing the same complaint from different directions: agents fail on the boring parts. Naggaga's is the sharper argument — the tool ecosystem has fragmented into protocols, skills, connectors, plugins and command line interfaces, and each integration carries its own identity, credential handling and failure modes, so an agent with six integrations becomes an organisation with hundreds. Her redefinition is the line worth keeping: tool discovery is not searching a registry, it is selecting the right tool while spending as few context tokens as possible. Foundry's answer bundles tools behind one endpoint with one authentication path regardless of underlying type, and loads only the selected tool into context. Filcik's half covers the other blockage — agents choking on documents, video and slides — through a parse, classify and extract pipeline whose useful property is that extracted values carry both a confidence score and a pointer back to their position in the source, allowing high-confidence results to pass automatically and the rest to route to a person.
The recommendation at the end is the most immediately usable advice from this conference: use the larger model for planning and a cheaper automatic selection for implementation, based on the team analysing what their own conversations actually cost. The expensive model earns its price where a wrong decision propagates, and stops earning it once the plan is settled — a finer distinction than per-task selection and a larger saving. The candid moment is worth more than the feature. Context switching between agents is described as an unsolved problem, visible in user testing and in the team's own experience, and it burns you out. That is the cost nobody prices when demonstrating parallel agents: six concurrent sessions produce six streams of work in different states, each requiring reconstruction before you can usefully intervene, and human working memory does not multiply.