← All AI Engineer talks

AI Engineer Europe 2026

Agentic Evaluations at Scale — For Everybody

Read the talk

Agentic Evaluations at Scale—for Everybody

Useful evaluations need more than a leaderboard: they need transparent configurations, domain expertise, accessible execution and a clear account of what is actually being tested.

From a talk by Nicholas Kang and Michael Aaron

Before you start: Basic familiarity with LLMs, agent workflows and evaluation assertions is helpful; no prior knowledge of Kaggle is required.

How do you keep up with evaluations?

How can someone find the evaluations that matter, keep their results current and contribute expertise that existing benchmarks miss? Kaggle approaches these questions as a community platform. Nicholas Kang introduces himself as the product manager for Kaggle Benchmarks and its agentic evaluation work; Michael Aaron works on evaluations and benchmarks as a Kaggle software engineer. Kang describes a community of more than 30 million users and roughly two years of work on generative AI evaluations. Their tools are an effort to make evaluation more accessible, with substantial problems still open.

The first obstacle is discovery. Kang estimates that more than ten benchmarks appear each day, leaving readers to spend hours searching arXiv and reading papers. Even someone whose full-time job involves benchmarks cannot reliably keep up. Publication also does not guarantee maintenance: once authors move to their next research project, the paper's leaderboard can stop tracking the models people actually use. A benchmark needs an ongoing execution and publication process if it is to remain useful after its initial release.

Slide with GitHub, arXiv, and AI labs above three bullets about benchmark discovery and stale leaderboards.
Evals are scattered, decentralized, and get stale fast.
0:350:56
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

0:35 · section reference included

The same benchmark can measure different setups

A published score leaves another question unanswered: what configuration produced it? Both model settings and the way a benchmark is orchestrated affect the result. A model-release chart can show a clean comparison without exposing enough of that setup for someone else to reproduce or interpret it.

Kang gives an example from a benchmark Kaggle published with an AI lab. A competing lab objected to the results, reran the benchmark and published substantially better results for its model. In Kang's account, the competing run used compaction supplied through that lab's API; Kaggle had not enabled it for any of the models in its comparison. The benchmark name alone therefore did not identify the experiment. The rerun changed a consequential part of the system being evaluated.

Slide titled “Evals aren’t always transparent, accessible, and verifiable,” with an Introducing GPT-5.4 results table and bullets questioning benchmark setup and differing lab results.
Published evaluation results leave setup and model configuration questions unanswered.
2:533:04
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

2:53 · section reference included

Who knows what needs testing?

Coverage is a different problem from reproducibility. Kang depicts the world's knowledge as a large circle, with AI researchers and technical professionals occupying much smaller circles inside it. His rough population estimates are 30,000 AI researchers, attributed to a Google AI search, and 30 million software engineers, data scientists and other technical professionals. The point is the mismatch between the people creating evaluations and the people AI is expected to help. Without a benchmark for a capability, developers lack a measured target for improving it. That can deepen the unevenness of systems that perform exceptionally in some domains and poorly in others.

Wastewater treatment makes the gap concrete. Kang describes a user in Turkey with 20 years of experience as a wastewater plant engineer. The engineer recounted fatal incidents in his country involving failures to follow safety protocols, then built a benchmark to ask whether AI could help him do his job and prevent similar incidents. The dataset came from his professional experience.

Kang describes that dataset as original and proprietary, containing knowledge not otherwise available on the web and outside the labs' immediate economic priorities. Opening evaluation authoring to domain experts creates a route for this kind of knowledge to become a test. The contribution is not simply another set of questions: it is a practitioner deciding which failures matter.

3:544:07
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

3:54 · section reference included

Turning participation into usable evaluations

Kaggle's response spans four products, each addressing a different part of the evaluation process.

ProductRole
HackathonsLet people host challenges and recruit contributors.
Agent examsMake evaluation accessible to consumer-agent users.
Game ArenaCompare models through competitive games and Elo-style ratings.
BenchmarksLet the community build, run and share evaluations.

The competitive approach aims to keep producing a useful comparison as models improve, while the authoring tools broaden who can decide what to test.

Hackathons channel concentrated effort toward a defined problem. The organizer supplies enough constraints to keep submissions relevant while leaving room for participants' expertise and creativity. Kang describes open-source results as part of the intended outcome, so the work benefits people beyond the participants and organizers.

The example underway at the time of the talk was a hackathon with Google DeepMind's AGI team. It followed the paper Measuring Progress Toward AGI: A Cognitive Framework and asked participants to create benchmarks for five of its ten cognitive faculties. The invitation rests on the same principle as the wastewater example: contributors can bring knowledge that a lab cannot supply by itself.

Making that invitation practical requires infrastructure and judgment:

  • Access to tools: In Kang's example of 1,000 globally distributed participants, people need somewhere to host datasets and access models. Paying separately for five model API keys can exclude contributors with fewer financial resources.
  • Understandable results: Write-ups let other people inspect, learn from and build on a submission.
  • Expert evaluation: Kang finds that judging innovation and creativity still requires human experts. Getting those experts to agree is itself work the platform must support.

An open call for contributions is only useful if people can afford to participate and their work can be assessed and reused.

5:496:04
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

5:49 · section reference included

An exam before an agent gets access

Standardized agent exams lower the effort required to evaluate an existing agent. Kang originally called them standardized agent tests, or SATs, before changing the name because of a trademark issue. The workflow is deliberately short:

  1. Paste a one-line prompt into the agent.
  2. Let the agent take the exam.
  3. Receive a score that can be compared on a leaderboard.

At the time of the talk, this was an experimental MVP launched the previous week.

The motivation is the gap between enterprise evaluation and consumer-agent use. Research labs and enterprises have tools such as Braintrust and invest in measuring their systems. Meanwhile, people build OpenClaw agents and send them into real workflows without necessarily testing them first. Kang references another conference discussion reporting 1,100 security advisories filed that morning. He raises safety-focused exams as a possible baseline before an agent receives control of an inbox, an Amazon account or other consequential resources; these exams were a proposed direction, not an established safety guarantee.

Accessibility also constrains exam design. A difficult, long-running exam may be easy to start but never finish. An easy exam may finish reliably while revealing little about the capability the user cares about. The useful middle ground must deliver enough signal within a run people will complete.

Kang reports that more than 500 agents had been evaluated in the first week, with little promotion. After the team posted on Moltbook, they saw agents sharing their results and even an SAE preparation course. That response suggests interest in scores and comparison, while leaving the harder question of exam quality and appropriate difficulty unresolved.

9:359:47
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

9:35 · section reference included

Games replace a fixed ceiling with opponents

Aaron turns to Game Arena as a response to benchmark saturation. With a fixed test, successive models can approach a ceiling that no longer distinguishes them. Player-versus-player competition instead asks how models perform against one another. A model can remain the strongest for a while, but new opponents provide a continuing basis for comparison.

Game selection determines which capabilities become visible.

GameEvaluation interest
WerewolfDeception in social play
PokerRandomness, deception and risk-taking
ChessAn established setting for comparing machine play

Poker also exposes behavioral differences that a general capability score might hide. Aaron observes that Grok frequently goes all in, while other models play more conservatively. Some newer models, he says, perform worse at Poker because they are more risk-averse. A newer generation is therefore not automatically a better player under a particular game's incentives.

Before running a comparison, the team iterates on the game, confirms that models can actually play it and spends substantial time refining prompts for fairness. The Game Arena harness makes this work inspectable: prompts and the surrounding game machinery are part of what determines the observed behavior.

11:5812:12
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

11:58 · section reference included

From a game harness to public evidence

Aaron describes the products as live on Kaggle, with much of the work open source. Once game and prompt design are established, the execution pipeline proceeds through four stages:

  1. Build and test the harness. Most of the team's work uses OpenSpiel games. Compare model play with a random baseline and look for other interesting properties. Models usually beat random play, Aaron says, but sometimes by less than expected.
  2. Connect the models. An LLM model proxy, which Aaron also describes as available on Colab, provides a consistent way to interact with the different models.
  3. Run scheduled simulations. Execution uses Kaggle's existing simulation platform, originally built for reinforcement learning. Bradley–Terry pairwise methods help the team reduce the number of games it needs to run.
  4. Publish evidence and results. The model conversations become Kaggle datasets, ratings appear through Benchmarks, and game visualizers let readers inspect play—including the Poker hands behind the observations about aggressive betting.

The published outcome is therefore more than a ranking: conversations and visualized games provide material for examining how a model reached it.

Flowchart connecting Design & Iterate, Build Harness, Run Simulations, an LLM Model Proxy, and Publish Results, with Benchmark, Dataset, and Visualizer outputs.
The Game Arena workflow runs from game design and harness building to simulations and published results.
13:1813:51
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

13:51 · section reference included

The cost of a credible comparison

Aaron reports that the Poker evaluation required about 400,000 hands to reach statistical significance, with many model turns inside each hand. The inference cost grows with those turns, not just with the number of matches. He does not specify a confidence threshold or stopping rule, so the count describes that evaluation rather than a general requirement for Poker benchmarking. Bradley–Terry pairing is one way the team tries to reduce the work, but obtaining a credible comparison quickly remains an open engineering problem.

A second constraint is participation. Watching models compete can be entertaining initially and repetitive later. Aaron proposes a prompt hackathon in which community members supply prompts, then compete on a leaderboard according to how well those prompts make a model play. That would give the audience an active role in the evaluation process.

A third constraint is continuity. Old models disappear, new models arrive, and an externally hosted endpoint may not make the identity of its underlying model clear. Longitudinal comparison depends on knowing which system actually played, not merely retaining an endpoint name in a results table.

15:1115:26
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

15:11 · section reference included

Assertions become tasks; tasks become benchmarks

Kaggle Benchmarks is intended for open community evaluation rather than evaluating a particular application's production code. Its basic authoring workflow will nevertheless look familiar to anyone who writes production evaluations: generate an output, then check whether it satisfies an expectation. The Kaggle Benchmarks Python library supports this task-oriented approach.

Aaron's small example asks what gets wetter as it dries. A check asks whether the answer contains towel. The assertion itself can be expressed directly in Python:

python

def check_towel_answer(answer: str) -> None:
    assert "towel" in answer.casefold(), "Expected an answer containing 'towel'"

This checks a specific property of the response. The platform also supports LLM judging when the desired judgment is not captured by such a rule. Checks are grouped into a task, which runs against the collection of models selected by the user. Tasks are then aggregated into a benchmark, such as the wastewater treatment benchmark.

The richer demonstration is a task Paige created around recreating an SVG from xkcd. Aaron shows a reproduction generated by Sonnet 4, which he describes as already somewhat outdated. Several assertions inspect the result: did the model generate an SVG at all, does it contain the correct text, and does it satisfy the other checks? Side-by-side comparisons let a reader inspect the artifacts as well as the individual judgments. The task decomposes a broad instruction—recreate this graphic—into properties that can be examined separately.

16:3616:46
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

16:36 · section reference included

What system does the score belong to?

The remaining difficulty begins with incentives. A team shipping a product has an immediate reason to test whether its model works for customers. A community contributor must first find a useful question, then invest the effort to build an evaluation other people will care about. Hackathons, Kaggle points and medals help encourage that work, but they do not remove the effort required to write a good test.

Moving from models to agents makes the object of evaluation less clear. Aaron cites a March 16 Morph LLM post as reporting that six frontier models were within a couple of percentage points on SWE-bench Pro, while coding performance differed by 22% depending on the harness. He explicitly says he has not verified the post, and the cited 22% is not resolved here as a relative change or a percentage-point gap. The comparison motivates a question rather than establishing a controlled result: how much of an agent's score belongs to the model, and how much belongs to the harness around it?

An agent evaluation needs a clear account of the system under test. Otherwise, an apparent model comparison may actually reflect differences in harness behavior. Rapid releases and deprecations add another difficulty: even a well-defined experiment can become hard to repeat when its models are no longer available. Community participation expands what gets measured, but transparent execution and identifiable model versions determine whether those measurements remain interpretable over time.

Challenges slide with process diagrams and a “Same Model, Different Scaffold” bar chart on the left, and four challenge bullets on the right.
Evaluation challenges include incentives, agent execution, ambiguity under test, and model release cycles.
17:5818:12
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

17:58 · section reference included

Resources

From the talk

Read the complete timestamped transcript
  1. 0:00

    [upbeat music] All right.

  2. 0:15

    Hi, everybody. Um, let me just try to stand straight so I don't have to crouch over. Um, thank you all for coming. This is our talk on agentic evaluations at scale for everybody.

  3. 0:26

    Um, I hope everyone's in the right room, and if you are, thank you for coming. We were expecting, like, 20 people, so this is, like, way more than what we expected.

  4. 0:35

    So all right, who are we? So I'm Nick. I'm a product manager in Kaggle Benchmarks, uh, and I basically run and build our benchmarks platform alongside a couple of our engineers, and I also focus on our agentic eval solutions.

  5. 0:48

    I'm originally from Singapore, but I live in the [REDACTED:location], and so I flew in to do this, this talk and attend all the great talks out in this conference today.

  6. 0:56

    And hi, I'm Michael. I'm a software engineer on Kaggle. I've been working at Google for about a third of the time that I've been alive and Kaggle for about half of that.

  7. 1:04

    So, uh, yeah. But mostly working on evaluations and benchmarks for Kaggle at the moment.

  8. 1:08

    All right. Um, has anyone here heard of Kaggle? Put your hands up if you have. Okay, great. Um, so a lot of people know us for competitions, um, but we don't just do that.

  9. 1:17

    We're the world's largest AI ML community of 30-plus million users, and we've been working a lot in the GenAI eval space over the course of the past two years.

  10. 1:26

    Um, and we think there are lots of interesting problems in the industry that not many people are trying to solve, and we feel like we're positioned well to solve them.

  11. 1:34

    And we wanna share more of the work that we've been doing and also invite contributions if you wanna get involved in the space.

  12. 1:41

    Um, so we have a simple agenda for today. First is AI, AI evals today are kinda broken, and we'll talk about why. And then step two is we're trying to solve it.

  13. 1:49

    Not saying we're the all cure and we have everything, um, kinda sorted out. We'll talk about what we're trying to do, the challenges we're running into, and also maybe, like, it might inspire some of you, um, in terms of how you think you might be able to help contribute to this very important problem that we're trying to

  14. 2:04

    solve for. With that, I'll jump into the first section. Um, so first problem, evals are scattered, decentralized, and get stale fast. I don't know how many of you have tried to keep track of, like, AI benchmarks, but basically, like, 10-plus of them drop every single day.

  15. 2:20

    And the best way to find out what they are is go to Archive and spend, like, hours scrolling through them, reading every paper. That doesn't make sense. Um, we don't think it makes sense.

  16. 2:29

    I can't even do it even though it's my full-time job. And I think what happens after that, um, paper gets published is that, you know, you see some of the leaderboards in the papers, and what happens after that?

  17. 2:40

    They just get stale. The authors move on to the next bench- best benchmark because they just wanna publish lots, lots of papers, no fault of their own, but these leaderboards no longer become relevant as time goes on.

  18. 2:53

    The second issue is that evals aren't always transparent, accessible, and verifiable. I'm sure many of us have seen these charts, uh, on these model publisher, uh, notes when they release a new model.

  19. 3:04

    But what's the problem with that? You know, we don't actually know how these benchmarks were set up. There's a lot of configurations you could use for the models themselves, and also how the benchmark is orchestrated and facilitated.

  20. 3:16

    And we don't always know what's actually being tested here. Um, I'll give you one real anecdote, which is that we had published a benchmark, um, with one of these AI labs, and another competing AI lab came to us and said, "Hey, we don't like the results, um, of, you know, this particular benchmark you published.

  21. 3:33

    Let's run it on our own." And so they ran it, and then they published it with much higher, much better results. And the difference was that they were optimizing it for their model.

  22. 3:42

    So they had used compaction that they had provided through their API, and we didn't for all of the models we ran. So the results you're seeing don't always reflect the actual state of things, and that's a problem.

  23. 3:54

    Number three, big circle represents all the world and its knowledge. Small circles represent AI researchers and technical professionals. There are, like, something like 30,000 AI researchers, at least that's what Google AI search told me.

  24. 4:07

    And I think there's, like, 30 million software engineers, data scientists, technical folks. We expect AI to help most of humanity, but then a very small percentage of people are creating all these evals.

  25. 4:19

    And if something's not being evaluated, not being benchmarked, we cannot hill climb on it. We cannot know how good we are at those things. And what will this lead to?

  26. 4:27

    More of these cognitive edges or jaggedness with these models as we're already seeing now. And that's only going to get, um, more exacerbated over time as we see superhuman intelligence in some areas and just, like, very mediocre performance in other areas.

  27. 4:42

    That's not equitable AI that we want that will benefit all of humanity.

  28. 4:48

    Um, this is a kinda fun anecdote, but not many AI researchers are also wastewater treatment plant engineers. I give you this example because this is an actual benchmark built by one of our users.

  29. 4:59

    He's-- He lives in Turkey. He's been a wastewater plant engineer for 20 years. I don't know what that entails, but it's clearly a very important job 'cause he built this benchmark 'cause he cares.

  30. 5:09

    And he recounted a story where, you know, he's been doing this for 20 years. There have been severe incidents in his country where there was some incident, people didn't follow the safety protocols, and people ended up dying as a result of that.

  31. 5:21

    So he built this benchmark to evaluate how AI could help him in his job and help avoid these incidents in the future. And so this is, like, a proprietary novel dataset that he's created from his own experience.

  32. 5:34

    Doesn't live anywhere else on the web, doesn't live in any of the AI lab focus area because that's not something that's economically productive for them at the moment. So it's very important, um, why we think, um, we should work on open source contributions to the eval space.

  33. 5:49

    All right, um, enough of that. Talking about the solutions ahead. We're working on a couple solutions, but it's tough. So I'll very quickly cover the first two at the top, and then I'll hand it over to Michael to kinda deep dive into the remaining two products at the bottom.

  34. 6:04

    Um, so at the top left, we have hackathons. We have a platform, um, that lets anybody host a hackathon, and I'll talk about why I think it's relevant to the problem of evals.

  35. 6:13

    Second, on the right-hand side, we have agent exams. Um, we wanna democratize the process of taking evals. We heard a lot about OpenClaw and consumer agents being a big thing.

  36. 6:24

    But the problem is that most people don't care about evaluating their own OpenClaw agents, which is kinda crazy. Um, number three, at the bottom left, we have Game Arena.

  37. 6:32

    That's where we have this evergreen benchmark where models are playing PVP games against each other. So it's, um, an Elo score type rating, and it's forever, um, hill climbable and unsaturated because they're just fighting against each other, and there must be one winner and one loser.

  38. 6:49

    At the bottom right, we have Benchmark. So, um, it's the product I run, which is basically a platform that enables anybody to build, run, and share evals, um, to the open community.

  39. 6:59

    Um, so very quickly, hackathons. Why I think this is important. Hackathons are a great way to channel pe- channel people's energy and expertise to solving a problem. I think we've seen that, you know, with the right energy, investment, and time, we can do a lot with very little.

  40. 7:15

    Um, I think a great example is the world galvanized over the past three years to make GenAI happen, and this is like a very small form of how we wanna help facilitate that process, um, towards solving the right problems in this space.

  41. 7:27

    Um, it's important that we put guardrails around the problems that we're trying to solve so that people don't go crazy, but also give them enough space so that they can flourish and their creativity can show.

  42. 7:39

    And the results of everything will be open source, uh, for the benefit of everybody and not just a small group of people.

  43. 7:46

    Um, but there are some challenges. Um, and actually, before I dive into the challenges, so on the screenshot on the right is a hackathon that we're actually running right now with the Google DeepMind AGI team.

  44. 7:56

    So Google DeepMind, a couple weeks ago, published a paper on how we can measure the cognitive faculties, um, of AGI. And so we started this hackathon to focus on five particular faculties of the ten, and we want people to build benchmarks in those areas, and we want to give everybody the chance to contribute to AI research and

  45. 8:15

    not just a few people. And also knowing that everyone has something unique to contribute that these AI labs couldn't do so themselves.

  46. 8:25

    Um, but running a hackathon platform isn't all that easy as well. Um, I think these are fairly self-explanatory. Maybe I'll talk about, um, the second and the third one in particular.

  47. 8:35

    Um, the second one being that we need to provide them the right tools in order for them to do their best work. Um, it might sound trivial, but things like, okay, if you have 1,000 participants, um, everyone's operating globally online.

  48. 8:48

    How can we give them the tools like hosting their own datasets to have access to AI models? That's something I never thought about before. But for a lot of people, you know, coming from a poorer background, they might not have money to pay for these five API keys to access all these state-of-the-art models.

  49. 9:03

    And how can we then let them share their work in a way that's understandable through write-ups, um, so others can see, perceive, understand, learn, and build on the work that they've been doing?

  50. 9:13

    And then the third point is that as much as, you know, AI agents and everything you hear about this conference, um, are very good at a lot of things, they're not very good at, like, judging innovation and creativity.

  51. 9:24

    So a lot of the work still requires human experts, and even alignment within experts is difficult and not trivial. Um, and that's something that we have to facilitate as part of this platform too.

  52. 9:35

    Um, the second thing that we're working on right now is what we're calling standardized agent exams. I originally called it like SATs, standardized agent tests. Uh, but you know, there was a trademark issue, so I had to change the name.

  53. 9:47

    Um, yeah, it's a true story. Um, so how it works is that you just paste a one-line prompt your agent, and essentially it takes an exam, and we return a score for you on a leaderboard that you can compare its performance against.

  54. 9:59

    Um, this was a very experimental MVP that we just launched last week. Um, and I think this is important because if you look at AI evals that people are doing, it's kinda two, um, ends of the spectrum.

  55. 10:11

    You have like research labs and enterprises, you know, using Braid Trust, using all these state-of-the-art technology to set up to measure their agents and their models. And then on the other e- end, you have consumer agents, people who are building OpenClaws and then, you know, filing 1,100 security advisories this morning, as we heard.

  56. 10:29

    Um, but most of them aren't actually testing their agents before they're sending them out to the real world, um, which I think is a huge, huge problem as we've seen and will become even more important.

  57. 10:38

    Um, so like one conversation that came up this week was how can we maybe do more safety-focused exams? So you can do a quick baseline of your agent before you send it out into the world to run your inbox, to run your Amazon accounts, and to do stuff for you.

  58. 10:54

    Um, so I talked about the first point. I think the second and third one are quite interesting. Um, on the second one is that when something's accessible, we wanna make sure that it's also, um, challenging enough.

  59. 11:06

    And so we have this spectrum. If we make something too difficult, people can take the exam, but no one finishes it because it runs for too long. It's too difficult.

  60. 11:13

    But if we make it too easy, then it doesn't give you the right signal for what you want to measure. And then finally, the chart at the bottom shows maybe there is a market for agent consumers.

  61. 11:22

    Um, we only launched a week ago, and we have, you know, hundreds, like 500-plus agents already evaluated on our exam, um, without us even really promoting it very much.

  62. 11:31

    Um, so I think that's, um, an interesting insight that we've gleaned from this experience. On the right-hand side, on the screenshots that you see there, um, so we posted in Mopebook, and then we started seeing these weird kinda spin-off posts about people sharing-- agents sharing their exam results and even like an SAE prep course, um, that came

  63. 11:51

    up on Mopebook. Um, so you know, that's always interesting to see. Um, with that, I'll hand over to Michael.

  64. 11:58

    Yeah. Thanks, Nick. Um, yeah, so I really selfishly wanted to talk about Game Arena and benchmarks with y'all, AI engineering, um, and mostly kind of give an overview of how it works, some of the really cool things we've seen it, but mostly I wanna talk about the challenges that we've been having with them.

  65. 12:12

    And so please come find me at the DeepMind booth after this to talk about them. I would love, like, some more insight on these kind of things too. So, uh, for Game Arena, it's a-- So benchmarking platform, one of the problems with benchmarks is they very quickly get saturated.

  66. 12:25

    Uh, we see this with community benchmarks. We see it with AI and, like, researching benchmarks as well. So Game Arena is an approach to help us work against the saturation by just having PVP, and so you can never have saturation because you'll always have one model able to compete against others.

  67. 12:39

    So saturation might just be, for a while, a model is the best. Um, really quick engineering slide here of, like, how is all this set up and how does it work.

  68. 12:48

    So when we're trying to figure out games to put into Game Arena, we want to analyze, like, separate capabilities of AI models, and so we try to pick good, varied games.

  69. 12:57

    So far, the ones we've invested a lot in are Werewolf to, like, uh, play around with what's best at deception, uh, Poker for, like, the randomization, also some of the deception and how good-- Uh, like Grok loves to go all in on Poker.

  70. 13:09

    Uh, less models are a little bit less crazy or a little bit more conservative. Most interesting, some of the newer generation of models are worse at Poker because they, uh, are more risk-averse.

  71. 13:18

    And so you just see these personalities, uh, start to emerge over time. And then Chess, because any time you're analyzing ML things, you have to be analyzing Chess. And so, uh, for the quick, um, just overview of, like, how all this works, we design and iterate on a game, figure out a good game we wanna do, make

  72. 13:34

    sure models can actually play it, and then spend a lot of time on iterating prompts to try to make sure that our prompts are fair. And, uh, this is all, like, open source and, like, uh, very viewable for, like, what's happening.

  73. 13:44

    So if you wanna check it out, I put the GitHub link there. Really, all of the things that we've talked about in this presentation so far are live on Kaggle.

  74. 13:51

    A lot of them are open source, so please come look at it, play around, give us feedback. We love it. Um, so after that, uh, we work on building this harness.

  75. 13:59

    Mostly, we've done OpenSpiel games so far, which is, like, an RL, um, framework. Uh, and so, like, we test, like, are these models better at playing at random? Sometimes they are.

  76. 14:09

    Usually they are, but, like, sometimes not that much better. Are there any other interesting properties that emerge? Uh, finally, we end up running the simulations. Uh, we use LLM model proxy.

  77. 14:18

    This is actually available on Colab if anybody u-uses that to just, like, talk in a consistent way to all of the models that we wanna run these games against.

  78. 14:26

    Uh, and so it, it runs on top of the Kaggle simulation platform, which was, like, initially an RL platform that we had for Kaggle before LLMs became a huge things.

  79. 14:34

    Uh, we schedule game runs, uh, uses Bradley-Terry pairwise to try to, like, not have too many games we have to run. I'll talk about that in a second. Um, and then finally, we publish the results.

  80. 14:44

    We have all these LLM conversations. We stick them in a dataset. That's available on Kaggle. People can check it out and, um, like, learn things from that. Uh, we put it onto benchmarks to show the Elo scores, and then we also have a game visualizer for all these things, so you can go and, you know, see Grok

  81. 14:59

    go all in on Poker hands. Uh, that's a little demo to the left of that. Um, so now as promised, some of the really big, like, challenges that we've had with this, and so love to hear all y'all's ideas and, like, different ways to approach this.

  82. 15:11

    Um, you can imagine it gets very expensive very quick. I'm sure you all have seen, um, you know, your Claude 4.6 bills are something along those lines. So you can imagine that for Poker, in order to get statistical significance, we had to run about 400,000 Poker hands, um, and there's many turns inside of each of those hands.

  83. 15:26

    You can imagine what those bills start to look like. And so the Bradley-Terry pairing, um, is, like, part of this. But any way that we can get statistical significance without having to run millions of games, uh, is great.

  84. 15:38

    And, like, we're always trying to think of new ways to, like, be able to be sure that the models are best at the things that we're claiming they're best at, but, um, you know, running as quickly as possible.

  85. 15:47

    Uh, it gets a little boring to just watch, like, LLMs play against each other all the time. Like, for some of the initial games, it's pretty fun. Um, but, you know, as we're trying to build this out, um, it might get a little bit repetitive.

  86. 15:56

    And so trying to figure out ways to engage Kaggle's community to be able to participate in this process. Um, and so, you know, even things like could we have a hackathon that somebody provides a prompt for, uh, for example.

  87. 16:07

    And then, like, you know, we would have, like, prompts given by our community as part of the competition to, like, play these games and see who prompts, like, the model the best and, like, climbs on a leaderboard.

  88. 16:18

    And then comparison over time is difficult. Uh, old models disappear. New models come along. Sometimes when you're talking to a model endpoint, if you're not talking to yourself, they're not exactly honest on what model is happening in the background.

  89. 16:28

    Uh, so that's always a little bit of a difficulty. But yeah, go check it out. Pretty fun. Um, so yeah, moving on to benchmarks with my limited time here.

  90. 16:36

    So, um, what is this not? Is this not, like, a production evaluation platform? There's plenty of people talking about that over and more if you wanna go and run this for your production code.

  91. 16:46

    Very cool things. This is much more about community involvement. Anyone can, like, build and run and share evals in a hopefully open and verifiable way. Uh, for time's sake, I'll s- just talk about this really a second.

  92. 16:57

    But we basically-- It looks very similar to the production evaluations platform where you write some assertions. So, like, this thing worked or, you know, what gets, uh, wetters the dries.

  93. 17:07

    Like, you can say, "Okay, does this contain a towel?" We also do LLM judging similar to the production platforms. Uh, these all get grouped together in a task. They then get evaluated against a collection of models that the users wanna run against.

  94. 17:18

    And then all these tasks get aggregated together in a benchmark such as the wastewater treatment one that Nick was talking about previously. Uh, so Paige, who just presented in this room before this, actually made this, uh, nice little task for us.

  95. 17:30

    Uh, it was parsing an SVG, uh, from XKCD. And it's like, "Can you recreate this SVG?" And so you can kind of see the code for this is over on the left.

  96. 17:39

    Um, one of the models is a little bit outdated, so Sonnet 4 created this, uh, nice reproduction below it. Um, and then, uh, Paige created a number of assertions.

  97. 17:49

    So, like, you know, can it generate an SVG at all? Does it have the correct text? And some other checks, and then, um, an easy way to compare these things side by side.

  98. 17:58

    Uh, so yeah. This is some of the challenges with this, uh, that, like, inspiration, incentivization are hard. If you want to, like- It's not hard for a production evaluations platform 'cause you're p- you know, shipping a thing to consumers they care about, like, does this model work or not?

  99. 18:12

    But to just inspire people in the community to create benchmarks that, like, other people find interesting, uh, we've had good luck with hackathons, um, and s- like, uh, you know, uh, Kaggle has a points and, like, medal system and things like that, so we have some things baked in the platform to help inspiration incentivization.

  100. 18:28

    But it just takes a lot of work to write a good evaluation. Uh, for agentic benchmark execu- like, oh, yeah. Um, so when we started this, people were really interested about analyzing just models.

  101. 18:40

    As we've moved more on to what are agents doing, it gets really hard to figure out, like, what we're actually testing against. Uh, so I pulled out this little thing from Morph LLM, uh, paper or, like, blog post that they published on March 16th that basically called out that, you know, against Suitebench Pro, the six frontier models

  102. 19:00

    are within a couple of percentage points of each other. Definitely, like, go check out this blog post. I haven't specifically verified it, but it does seem likely to me.

  103. 19:07

    The thing that really matters a lot for coding performance is what harness is it running inside of, with like a 22% difference depending on the harness. And so that can get, you know, really tricky of like, are you testing the harness?

  104. 19:18

    Are you checking the model? Uh, things like actually ambiguity under test. Um, and then again, fast release and deprecation cycles of models, it gets a little bit tricky, um, to figure out what we're, uh, or like, uh, to be able to do comparisons over time.

  105. 19:34

    Uh, so yeah, I think that's about time, but as I mentioned, we'll all be at the DeepMind booth, um, for the in-between times, uh, or you can email either me or Nik here.

  106. 19:43

    But thank you so much. [audience applauding] [upbeat electronic music]