The problem PepsiCo set out to solve is unglamorous enough to be believable: a key account manager has a meeting with a major retailer in forty-eight hours, and the context that would make that meeting good is distributed across seven to ten systems and one person's memory (9:12).
Most enterprise AI sessions describe an outcome. This one describes the wiring, including the parts that did not work, which makes it the more useful of the two.
Why the scale creates the problem rather than solving it
The company operates across more than two hundred countries with roughly three hundred thousand employees and more than twenty brands each turning over a billion dollars (7:46). At that size, the account relationships that generate revenue are managed by individuals, and what those individuals learn stays with them.
This is worth stating precisely because it inverts the usual framing. The difficulty is not that PepsiCo lacks data. It is that the data which decides a negotiation — what this buyer asked for last quarter, which concession was already refused, what the escalation history looks like — was never institutional in the first place. It lived in a car ride home and an email nobody indexed.
Six agents, one surface
What they built presents as a single interface backed by six specialised agents: an orchestrator, a data analyst, a persona and tactics agent, a tracking agent, a best-practices agent enforcing the company's own playbook, and a conversational debrief agent (17:39).
The debrief agent is the one worth noticing, because it runs the loop backwards. Rather than answering questions, it asks them — identifying gaps in the knowledge layer and putting them to the account manager, whose answers become part of the record. It is an interface designed to extract rather than deliver.
The governance detail that transfers
Two implementation choices in the data analyst agent are more reusable than the architecture around them.
The first is where access control sits. The agent inherits the asking user's table permissions through the data catalogue rather than through instructions in a prompt (24:33). If someone is not entitled to a table, the agent cannot answer from it — not because it was told not to, but because it cannot see it. Anyone who has watched a model be talked out of a guardrail will recognise why this distinction matters.
The second is a two-path query design. Questions that closely match known patterns resolve through pre-verified queries and return immediately; unfamiliar ones generate a query on the fly (25:08). The verified set was not written in advance — it was assembled from what users actually asked during development. The system got faster and more accurate at the questions that turned out to matter, which is a different optimisation target from getting better at questions in general.
Turning debriefs into an asset
The tracking agent is where the design gets ambitious.
Configurable signals define what the system should keep learning about — pricing, escalations, whatever a category requires. Those feed a knowledge layer that ingests from the relevant sources. A fact builder converts signals plus knowledge into stated facts, each carrying a confidence score and an extraction summary. The conversational surface the account manager talks to reads only that ledger of facts (28:41).
Their term for the payoff is compounding intelligence, and the specific claim underneath it is the one that would justify the project: every meeting improves preparation for the next cycle, and an account manager arriving in a role inherits context that previously departed with their predecessor (29:51).
Whether it compounds in practice is not something a conference session can establish. But the architecture is at least shaped like something that could, which is more than most retrieval systems can say.
The lessons are the honest part
Sessions like this usually end with a slide about transformation. This one ends with three admissions, and they are specific enough to act on.
Scope smaller than feels small. Their formulation — if you think you are starting small, start smaller — resolves to one workflow, one persona, one data source before extending anything (37:04). They note they did not feel they were overreaching at the time, which is the useful part of the warning.
Expect data quality to be worse than your foundation work suggests. And the reason they give is the sharpest observation in the session: the dangerous failure is not a wrong answer but a partially correct one delivered confidently, because an engineer without domain expertise cannot identify which half is wrong (37:28). Their conclusion is that domain experts belong in the build from day one, not in acceptance testing.
The cost sits in the foundation, not the agents. The first two agents were slow; the next several were an order of magnitude faster (38:24), because what was actually being built the first time was the data layer underneath.
What this implies for anyone copying it
The blueprint they close on — secure infrastructure, unified and governed data, an AI platform, an interaction layer — is generic enough to be unobjectionable. The specific version is more instructive.
If the expensive part is the data foundation and the agents are comparatively cheap once it exists, then the sequencing that most organisations follow is backwards. Pilots are chosen for demonstrability and run against whatever data is reachable, which produces a result that impresses and does not compound. PepsiCo's account is that they paid for the foundation first, absorbed a slow start, and then found the marginal agent nearly free.
That is a harder case to make internally than a pilot. It is also the only version of this story where the sixth agent costs less than the first.
关键数据
演讲章节
关键要点
- 01
The problem is scale-driven: roughly three hundred thousand employees, products in over two hundred countries and more than twenty billion-dollar brands, which pushes account context into fragmented systems and personal memory. 7:46
- 02
The unit of work is a key account manager preparing within forty-eight hours for a retailer meeting, previously by traversing seven to ten separate systems, reports and mailboxes. 9:12
- 03
The system presents as one interface backed by six agents — an orchestrator plus data analyst, persona and tactics, tracking, best practices and a conversational debrief agent that asks the user to fill gaps in the knowledge layer. 17:39
- 04
Data access is governed at the catalogue rather than the prompt: the agent inherits the asking user's table permissions, so it cannot answer from data that user is not entitled to see. 24:33
- 05
Queries resolve down two paths — closely matching questions run pre-verified SQL for an instant answer, while unfamiliar ones generate SQL on the fly, with the verified set built from observed usage during development. 25:08
- 06
The tracking agent turns debriefs into an institutional record: configurable learning signals feed a knowledge layer, a fact builder converts them into stated facts with confidence scores, and the conversational surface reads only that ledger. 28:41
- 07
Their framing for the payoff is compounding intelligence — each meeting improves preparation for the next cycle, and account managers arriving later inherit context that previously left with their predecessor. 29:51
- 08
First stated lesson: scope smaller than feels small — one workflow, one persona, one data source before extending anything. 37:04
- 09
Second: partially correct answers delivered confidently are the dangerous failure mode, because an engineer without domain expertise cannot tell which half is wrong — hence domain experts from day one. 37:28
- 10
Third: the first agents were slow and the later ones an order of magnitude faster, because the cost sat in the data foundation rather than in the agents themselves. 38:24
提及的实体
相关演讲
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 most forward-leaning position in Build's agentic track, and deliberately uncomfortable. Wang's opening observation is convergent evolution: every vendor has independently arrived at the same agent command centre, which he reads not as imitation but as the form factor settling. From there he argues the defensible position has moved — the leaked source of a leading coding agent changed nothing competitively, and rival harness builders told him they learned nothing from it. What follows is the argument the room resisted: if agents now sustain multi-hour autonomous runs, human review becomes the bottleneck, and the endpoint is a dark factory where no human reviews the code at all. He does not present this as desirable. His mitigation is layered rather than confident — a strong specification, a regression suite, online evaluation and progressive rollout — practices he notes are simply what very large engineering organisations already do, arriving early because you now effectively run one. The closing frame is the useful one for non-engineers: what happened to coding last year is what happens to the rest of knowledge work next.
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.