Summit talks

58:15

The line that explains this session comes from the customer in the last ten minutes: they are preparing for a world where metadata is how agent-based systems find the data they need and access it through the controls being built. That relocates a function — governance has spent two decades as compliance activity describing data that people locate by other means, and if agents navigate by the catalogue then the catalogue stops describing the access path and becomes it. An incomplete catalogue is a documentation problem when humans can ask a colleague; an agent has no such workaround. The most honest moment addresses the perennial failure that rules get written and ignored, with enforcement rather than publication as the argument. Generated descriptions and greyed-out classification suggestions divide the labour correctly, keeping a person accountable while removing the burden of finding candidates.

Shikha Verma / AWS re:Invent

43:15

The hardest problem in this session has nothing to do with machine learning: you cannot reliably tell who owns a machine. Unlike vehicles, which carry an identification number and go through state registration, heavy equipment has no equivalent — someone can simply assert ownership. Everything the connected-product strategy promises depends on solving that, because every step after fault detection requires knowing who to contact. The estate explains why it was not solved earlier: millions of machines with 1.5 million connected, and around 160 dealers who are independent businesses with their own systems, holding the service history that makes telemetry meaningful. The prior state is described directly — multiple accumulated platforms, and dealers confused because the same question returned different answers, which destroys trust in all of them including the correct ones.

Steve Blackwell / AWS re:Invent

53:44

The statistic this session opens on is that over 74 per cent of companies surveyed are not set up to succeed at their data and AI initiatives, and the diagnosis is more interesting than the number: the obstacle is tool sets stitched together manually, which makes work slower and more expensive rather than more agile. That makes the product answer integration rather than capability. The most credible sequence in the demonstration is one where the analysis fails — a hypothesis about customer satisfaction and long-term value that does not hold, abandoned in favour of a broader search. Demonstrations almost never show this, and it clarifies what the assistance is for: not finding the answer, but making the cost of testing an idea low enough that abandoning one stops being expensive. The load-bearing assumption underneath is a well-maintained data catalogue.

Iris Sheu / AWS re:Invent

53:29

The warning that makes this session worth watching is aimed at everyone who thinks this is a procurement problem: traditional development approaches are no longer sufficient, and adding AI tools to an existing process will not help either. The Ericsson account locates the constraint precisely — thousands of engineers across the globe make small-team Agile practice very hard because handovers become unavoidable, and the AI-native claim is that agents can carry context across a handover in a way documents never could. Their four-level maturity model encodes a sequence: context infrastructure before organisational change, and organisational change before the tooling pays off. Skipping the middle step produces individually faster engineers inside unchanged coordination structures. Their governance and culture arguments are unusually direct, and notable mainly for appearing inside a session about a command-line coding agent.

Ali Maaz / AWS re:Invent

56:39

Beer names the constraint that makes key management genuinely hard, and it is not the mathematics: the key at the top of a hierarchy must be in plain text at all times for the system to stay available. Everything below can be encrypted by something above; the root cannot, or there is nothing to start from. The threat model that has moved from theoretical to planning-relevant is harvest now, decrypt later — capture encrypted traffic today, decrypt it when capability arrives — which means the exposure is to everything transmitted now rather than to a future secret, and inverts the usual reasoning about when to migrate. The strategic argument is about delegation, and it is a vendor's argument that happens to be right: cryptographic agility is not something most organisations can retrofit, because the assumptions live in code written by people who have left. One remark connects the session to the rest of the conference, on certificate infrastructure built for a countable number of endpoints.

Ken Beer / AWS re:Invent

20:33

Beach invents a language no model has seen in order to establish something most context-management advice lacks: a controlled baseline. From there he walks the obvious fix — paste the documentation into a rules file — into its own failure, which is that it works while quietly taxing every unrelated request. The corrections that follow are the transferable part. Compress the reference to what the model actually uses. Make the rules prescriptive rather than descriptive, telling the agent when the material applies and how to validate its own output. Then shrink the file to a pointer and fetch documentation at the moment of need, so context cost is paid only when relevant and the reference cannot go stale. His closing habit is the one most likely to outlive the tooling: when an agent visibly struggles, ask it what guidance would have prevented it.

Brian Beach / AWS re:Invent

58:04

The most honest moment in this session comes near the end: most of the security processes the team has automated still route their output to security engineers rather than the business, because the results are not good enough. That sits half an hour after a story about two engineers building a working prototype in two days that runs a training exercise in seven minutes for ninety-one cents. The gap between the two is the subject. What distinguishes them is not model capability but whether the task has a verification loop a machine can close, which reframes the automation question entirely. Three loops appear — citation, self-checking, and a compiler pass that guarantees syntactic validity — and only the last removes a person. The rejection of single-number evaluation scores in favour of precision and recall follows directly, because in security the two error types have wildly different costs.

Eric Brandwine / AWS re:Invent

48:39

The number in this session's title is a triage improvement. The story underneath is that the queue being triaged should never have grown that large, and what fixed the root cause was not AI. The diagnosis is candid: it was easier to obtain an exception than to fix the problem, partly because application teams did not know how to fix certain vulnerabilities — not bad developers, simply not security engineers. That produces a self-reinforcing failure where a better scanner makes things worse, because more findings enter a pipeline limited by developer capability. Average false-positive review time falling from thirty days to thirteen is real and is a faster way to process the symptom. The durable change is a tiered security champions programme whose second tier exists to verify the first, anticipating the incentive that delegation creates.

Mark Arel / AWS re:Invent

19:22

The forecast the session leans on deserves examination before acceptance: over a third of enterprise software including agentic AI by 2028, up from around one per cent. Read carefully that is not a prediction that a third of software will be agentic, but that products will contain some agentic capability — a much lower bar most vendors clear by adding a feature. The useful framing follows immediately in the build-versus-buy question, which is more interesting for agents than for conventional software because the usual reasoning does not transfer: value sits in the connection between generic reasoning and specific context, and a purchased agent brings capability with no context. Their explanation of why agents differ commercially is compact and correct — something that pursues an outcome can be sold against a job rather than a capability. The mechanics get less attention than the forecast and matter more.

Mike Levy / AWS re:Invent

58:49

The framing question is better than the answer most teams give: can the problematic statement be identified and fixed, and separately, is this the right instance type. The order matters, because a database at full utilisation from poorly written statements presents identically to one that is genuinely undersized, and resizing is a one-line change while query analysis is work. The number that settles the argument is a query moving from thirty seconds to forty-six milliseconds — a factor no amount of hardware closes, which is why sizing is the wrong first move. Their treatment of caching depends entirely on sequence: applied before the query is understood it hides a problem that returns when access patterns shift, and applied afterwards it removes work that genuinely did not need repeating. The operational figure that makes the whole discipline affordable is a failover of up to thirty seconds, which turns instance sizing into a reversible decision.

AWS database specialist team / AWS re:Invent

52:14

The session opens by dismantling the reassuring version of its own subject: you put a box around the workload, secure it, call it confidential computing, and the problem is solved — which is why the presentation exists. The gap comes down to one question: how do you know the code you are talking to is the code that is running, rather than taking someone's word for it. A protected environment addresses operator access but not the customer's actual objection, which is that they cannot confirm any of it. Attestation converts the claim into a signed measurement, and the step that turns evidence into a control is a key policy permitting operations only when the environment matches. Trust becomes arithmetic rather than process, with no reviewer to convince and no exception to grant, which is what allows a model owner and a data owner to collaborate without trusting each other.

Alex Graf / AWS re:Invent

46:42

The show of hands at the start tells you what this session is about: roughly half the room had generated cost reports in the standard format, and considerably fewer had analysed them. That gap is the whole problem, because producing the export is configuration while turning it into something anyone acts on is the work. The single most valuable element described is unglamorous — an invoice identifier column that lets reported figures match the invoice actually paid, which is the difference between a report and an accountable number. Every cost reporting effort dies at the reconciliation step, usually because aggregation cannot be tied back to a specific charge. The remainder is data preparation rather than analysis, and the detail about needing pattern matching to extract tag values reveals where the real difficulty sits.

Justin Marks / AWS re:Invent

52:44

The most useful admission here is that intuition is what fails: the team stepped back because performance work was not going as fast as they wanted and found their instincts were leading them astray. The mechanism is that bottlenecks hide others — you remove the visible one and uncover a worse problem that was masked behind it, which is why a correct fix so often moves no numbers. Their answer is to survey broadly before drilling in, explicitly checking whether the processor back end is worse, finding it is not, and setting it aside. The diagnostic figure is instructions per cycle averaging below one against hardware capable of eight to twelve, which reframes the problem from slow code to an idle processor. Every fix that follows is about memory layout rather than logic, and returns nearly twenty per cent more throughput from configuration alone.

Toby Buckley / AWS re:Invent

58:18

The design decision at the centre of this session is one most teams get wrong: rather than assembling a large context and handing it to the agent, extract what actually matters from the conversation. That is the difference between a longer window and a memory — one holds more, the other decides what is worth holding. The instinct to add room fails invisibly, because an agent with an enormous context does not attend to all of it equally. The most instructive moment is an admission that the identifier for whose memory this is happens to be hardcoded, and should instead derive from who is logged in. Trivial in a notebook and the entire security model in production, since memory is per-actor by construction and the wrong binding produces an agent that recalls someone else's details — a breach that presents as good service.

Akasha Seag / AWS re:Invent

18:09

The number that matters here is not a benchmark but a shape: scaling up to 2.2 million virtual cores and back down to zero across four hours. Peak capacity has never been the hard part of scientific computing, because institutions have built large clusters for decades — the difficulty was that the cluster was sized for the peak and idle the rest of the year. Returning to zero removes that calculation, which suits genomics precisely, since analysis is bursty by nature. The acceleration claim is a change in the kind of activity rather than a productivity gain: eight hours means return tomorrow, thirty-five minutes means adjust and run again. The hardware explanation is unusually clear that cores per chip rather than total core count drives the improvement, and two operational findings — provisioning cost and a storage benchmark that showed no difference — are more portable than the hardware itself.

Marissa Powers / AWS re:Invent

49:29

Twenty-nine minutes after asking whether anyone really wants to hand production keys to an agent, the demonstration disables tool confirmation entirely. That is not hypocrisy — approving every call would be unwatchable — but the gap between the stated concern and the working configuration is the one every team will meet. The scope makes it concrete: the example prompt blocks network addresses and creates snapshots, which are write operations on production initiated by a chain of reasoning that started as a sentence in English. The design response is decomposition, and the split between an investigating agent and an acting one is where a permission boundary can sit. The construction itself is genuinely simple, and the generated report of 859 critical findings is both the session's most useful artefact and the place the trust question returns in a form nobody can check by hand.

Omar Tobaca / AWS re:Invent

43:59

Everything in this session is downstream of one diagram: an accelerator has finite memory bandwidth and finite compute throughput, and where a workload sits between them is decided by how many operations it performs per byte read. Landing memory-bound means expensive compute units idle while data arrives, and every technique demonstrated exists to move a kernel across that line. The natural objection is that a compiler should handle this, and the implicit answer is that it cannot, because the decision depends on tensor shapes whose relative importance a general compiler cannot infer. The kernel structure repeats identically for every operation — allocate on-chip, copy down, compute, copy back — which is an explicit data-movement schedule with arithmetic attached, and which ties the code to one memory hierarchy. Two practices are worth stealing regardless of hardware: measuring on a few layers rather than a whole model, and verifying numerical equivalence rather than assuming it.

Scott Perry / AWS re:Invent

55:41

The forecast this session opens with is over 1.3 billion AI agents in production by 2028, offered with the suggestion that it may be conservative. Treated as a claim about connection counts rather than a market prediction it becomes useful: the thing on the other end of a database connection is increasingly something that decided moments ago it needed storage. Provisioning latency, a background annoyance for twenty years, becomes a hard dependency in an automated build, and maintenance that presupposes a human operator who scheduled a window no longer fits. The customer migration that grounds the abstraction — eight engineers moving four and a half petabytes in under 120 days — is credible mainly because it ran between closely related products, which is the honest caveat. The optimiser improvement buried at the end matters more than it looks, because an agent writing its own queries has hand-tuned none of them.

G2 Krishnamoorthy / AWS re:Invent