No Priors Ep. 120 | With Google DeepMind’s Pushmeet Kohli and Matej Balog

Today, we're joined by two of the key people behind one of the most compelling developments in AI this year: AlphaEvolve. Pushmeet Kohli and Matej Balog worked on this autonomous coding agent, which uses Gemini models and evolutionary search to discover new algorithms.

It marks a major leap in AI's ability to contribute to core computer science and mathematics, and perhaps to sciences beyond that. It's not just a stochastic parrot or a boilerplate generator. It has shown what you might consider technical creativity, in the way that Move 37 did with AlphaGo—something humans hadn't done before, even in thousands of years of play. It might even be a real step on the path to self-improving AI.

Pushmeet and Matej, thank you so much for being here.

Thank you for having us. It's a pleasure.

Congratulations on the success and launch of AlphaEvolve. Can you give me a brief description of what it is, broadly?

In maybe one sentence, AlphaEvolve is an AI coding agent that is able to discover new algorithms, make new discoveries on open scientific problems, and, at the same time, produce algorithms that can be so practical that they are already deployed in key parts of Google's own infrastructure.

What is the origin story of working on this particular form of coding agent, or this problem statement?

We are not new to this space of algorithm discovery. As you might know, the mission of all of DeepMind is to build AI responsibly to benefit humanity. The way our particular team has been doing that for years now is to look for ways AI can discover new algorithms.

New algorithms are everywhere around us, so this is a very important question and can have a very high impact. We can discover algorithms that solve important computational problems with higher efficiency than what we've been able to achieve so far.

The first breakthrough we had in this space was in 2022, when we released a system called AlphaTensor. That was an AI system using reinforcement learning that, for a very specific but fundamental computational task—multiplying matrices—showed for the first time that AI agents can discover better algorithms than what humans had been able to do before them.

This was the first system that gave weight to the idea that, with AI, we'll be able to go into this superhuman region of algorithms that we as humans have not been able to discover ourselves.

How do you differentiate AlphaEvolve from AlphaTensor, FunSearch, and some other projects in this lineage?

One way to describe what we've done is to look back at the history of DeepMind and see a number of projects that came even before we started working on computer science.

If you go back to the project on AlphaGo, the AlphaGo agent was able to beat the world Go champion. What was remarkable about that agent was that it was able to explore this amazingly large search space of all possible Go positions in such an efficient manner that it could come up with the optimal move at that time. That really surprised people, both Go professionals and scientists.

Scientists believed that event would come much, much later because it was a very hard problem. What that gave evidence for was the ability of these large-scale neural network-based systems to reason and do very efficient exploration in these large search spaces, and come up with amazing new insights about the particular domain.

In the game of Go, there is this move called Move 37, which was a very creative new move that the agent discovered. It wasn't in the Go literature, and it really surprised the Go professionals.

In some sense, we asked ourselves the question: If you have an agent that can do very efficient search in the domain of Go, why can't you use the same kind of philosophy to search for algorithms in the space of algorithms?

That was the underlying basis of our first attempt at that problem, which culminated in AlphaTensor. We structured the algorithmic discovery problem by first looking at a very important problem, and that problem was matrix multiplication.

It's ubiquitous in computer science. It's one of the key fundamental operators that underlies not only computer science, but also neural networks, machine learning, and AI. We said, "Can we find a way to improve matrix multiplication algorithms?"

There is a very interesting history of matrix multiplication. Even though it's such a fundamental operator, people thought that the complexity, or the time it takes to multiply 2 matrices, was of order n³. Around 50 years ago—more than 50 years ago now—a German mathematician, Strassen, came up with this very counterintuitive construction, which showed that, in fact, the complexity was not n³, or cubic, where n is the dimensionality of the matrix. It was a bit lower.

That was a very counterintuitive result, and it stood for more than 50 years, until AlphaTensor came along and asked, "Can we actually improve this result?" Remarkably, AlphaTensor, by having this amazing ability to search in a very large space—even much larger than the space of possible Go moves—was able to come up with an amazing new algorithm that improved things.

But then the question was: We have now proved the thesis that these superintelligent agents can go beyond what human computer scientists have been able to do. Can we generalize them?

AlphaTensor was very smart, but it was purpose-built for the matrix multiplication problem. Can we build an agent that is more general—more general in the sense that it can handle more general problems, but can also search more naturally in the space of programs rather than in the space of very specific operations required for matrix multiplication?

That was the origin of our first attempt with FunSearch, which was an LLM-based agent. By searching in the space of programs, it showed for the first time that you can come up with completely new solutions, and made the first scientific discovery from an LLM. AlphaEvolve is basically an extension of that.

I'm very inspired by the idea—I think many people are—that AI will actually have creativity, and does have technical creativity, as you're describing. You're operating outside of the patterns that we already know as engineers.

I want to go back to some of the mechanics here and the limits to generalization, as well as how to think about automated evaluators and a lot of different topics. But when you think about problems that are clearly economically valuable and interesting, like matrix multiplication and the potential efficiency gains, what is your intuition for why those solutions have not been found before?

Is it simply that the search space is too large? Were people in this field complacent in believing that a certain solution was the maximum efficiency? Clearly, there's value to be had here.

My opinion is that, if you look at the structure of the algorithm, what Strassen produced was quite ingenious. It was not a natural thing that you would think of, and that was for only 2-by-2 matrices.

As you go to larger sizes, the space is so huge. The constructions are not something that is very natural. These are very involved and intricate constructions that would be very hard to discover by chance.

It's quite interesting that it has this very special structure, but it's not something that comes naturally to a human computer scientist.

I definitely agree. The search space is just unbelievably vast, and the solutions are perhaps nonintuitive. The third thing I want to emphasize is that I really believe the people who worked on this in the past were definitely not complacent.

In fact, the problems we chose to apply AlphaEvolve to in the first instance—both on the scientific side and the practical side—we deliberately chose problems that had been worked on for a very long time by the very best people.

On the scientific side, since we're talking about matrix multiplication, this has been a known open problem for decades, and many people have been working on it. Similarly, for the practical applications that we mentioned in our AlphaEvolve release in key parts of Google's infrastructure, these are things that have been heavily optimized inside Google because they are so important.

Having a system like AlphaEvolve—or any other system—discover something new on these problems is as strong a demonstration as I can imagine that this is indeed something new, because no one found it before. It is also something that was not easy to discover, because those results stood for such a long time and have been worked on by such strong people.

I want to note that this is not a comment on the broad efforts of the computer science industry to date on matrix multiplication or data center optimization. I think this is a good moment to try to demystify what's happening under the hood for a broader set of people.

Can you walk us through a concrete example of how AlphaEvolve actually evolves code? Let’s take the example of trying to optimize data center scheduling. What does the step-by-step process look like, from initial random code to a final solution that saves millions of dollars in power?

I can walk you through that. The user of a system like AlphaEvolve basically specifies the problem they are trying to solve. That’s the most important thing, and you specify it by providing what is called an evaluation function. Whenever there is a proposed solution for solving the problem, this function lets you tell how good that solution is.

You basically define what makes a good solution for discovering an algorithm for scheduling jobs in a data center. This evaluation function could be something like a simulator of jobs in a data center that, given an algorithm for doing the scheduling, simulates how good that algorithm is.

This is a simulator you already had?

Yes, that’s a simulator that we already had. I would say it’s something quite natural to have in many domains, because whenever you want to innovate on something, you need to have a way of telling, “Okay, is the innovation actually good or not?” So it’s a very natural object to have, at least in principle.

You define the “what” by providing the evaluation function, and then AlphaEvolve fills in the “how.” That’s the job of our system, and you can do it in 2 fairly different ways. One is to tell AlphaEvolve, “I have no idea how to solve this problem. Let’s start completely from scratch, try to be creative, and come up with something completely new.” That’s 1 option you can take.

Another option is, “Actually, we have already worked on this problem for a really long time. Here is a very strong initial solution that we can provide to the system, and you can start from here.” That’s what we did for the application of discovering new algorithms for scheduling jobs in a data center.

AlphaEvolve takes this initial solution and, at a high level, combines the creative power of large language models to propose creative new ways to improve that solution with the strictness of the evaluation function provided by the user, which is able to filter out the things that work from the ones that don’t. Then this is wrapped inside an evolutionary algorithm that makes sure we discover the whole space of algorithms in that region, so that we don’t commit to a very specific type of solution early on. Instead, we maintain a diverse pool of potential solutions over time.

Maybe we combine ideas from different solutions that are already strong until we actually have an algorithm that’s so strong that we’re happy to deploy it to a critical part of Google’s infrastructure, let’s say.

Intuitively—not in the machine-learning sense, but in the evolution sense—you have different generations where you’re getting closer to an optimal solution.

Yeah, that’s right. As you would expect, in each iteration of evolution, what you’re doing is looking at the previous iteration, looking at maybe the strongest solutions you have, and then trying to be creative about how you can combine ideas from those solutions, or maybe bring in completely new ideas, to come up with something even better. So yes, each generation gets stronger and stronger.

How much scaling are we talking about? Is there a way to predict how many generations it takes, or how do you constrain the number of iterations that the model can use?

There are 2 parts to your question. One is, okay, how does scaling work, and then how can you predict it? For the first part, this is actually a really nice feature of AlphaEvolve: it can adapt to the difficulty of the problem.

If you ask AlphaEvolve to find a solution to a problem that’s unexpectedly easy, then it will just do it very, very quickly. Almost immediately, you will have the solution. But if you ask it to solve a problem that’s really, really difficult—and by really, really difficult, I mean really difficult, maybe an open question that has stood for decades in the sciences, or you want a practical algorithm for a really high-value application in Google—then you would of course expect that this is not an easy problem. You might need to spend a longer time considering different solutions, exploring the space, and combining ideas.

What’s really nice about AlphaEvolve is that it is able to sustain this scaling in a way that it keeps improving over time, and it keeps improving for so long that you can make discoveries on this level of difficulty, like breaking decades-old scientific challenges or discovering high-value algorithms.

I know it may sound trivial that if you wait longer, you get better results, but in practice, that’s actually a really difficult thing: to build automated agents that are able to sustain this continual improvement without plateauing quite early. This is, I think, a nice feature.

There was a second part to the question about predicting how many iterations you will need. That’s something that’s actually not so easy, because it’s like asking a priori, “Do you know how difficult this question is going to be?” Especially in the sciences, that’s something that often has a very surprising answer. Very trivial questions can turn out to be extremely, extremely difficult, and vice versa.

But the nice thing is that you have continual improvement if you run this system. As long as you can run it, you can expect to get better and better results, and you just have to see where this gets you.

If you think about the coding agents that general developers have access to and are increasingly using today, 1 frustration with them is that, on relatively trivial problems they’re set out to do autonomously, they’ll get lost, blow themselves up, or plateau, as you said, in frustrating ways. Can you talk about whether you think there are implications from AlphaEvolve for these other general coding agents?

While large language models and coding agents are getting much better at understanding code, they’re not perfect. They do make mistakes. The other element is to think about what task these agents have been assigned.

Mostly, if you’re asking an agent to solve a particular task or write a particular program, you’re providing a specification. You’re specifying the task either in natural language, or you’re saying, “Well, I’m trying to do something complicated,” right? So it’s not a complete characterization of what you want; it’s a partial specification of what you want.

The agents then try to solve the problem and might get lucky and get the right result, or they might hallucinate and get the wrong result. The issue is, how do you know whether the result is right or wrong? That depends on having a good evaluator. That’s how AlphaEvolve solves the problem.

In some sense, we’re able to leverage the hallucinations for a beneficial purpose, right? The creativity and the wrong answers that AlphaEvolve can somehow come up with—how do we know that they’re wrong? They might be very good; we just don’t see them in that way. Which is why the role of the evaluator is really important, and how we even do the evaluation is very important.

When you come up with a new idea, should you try to explore that idea much further? How deep should you go into stress-testing that idea? Should you try that idea out on a few different instances, or 1,000 different instances, or really stress-test whether the idea actually works for the whole thing?

This is one of the interesting parts of AlphaEvolve. Getting that balance right is really important, so that you can look at where the creative solutions are, filter out the ones that are promising, and then use them later to refine the search process to get the final solution.

If evaluation functions—automated evaluators—are really such a limiting constraint here in terms of what we can get agents to do, do you have any intuition from this project or others on how to overcome that? Can models get good at helping us create automated evaluators? Should we imagine simulators that are better for lots of different domains?

If I’m a product manager putting an incomplete natural-language spec into a coding agent, should I work with an assistant to complete that spec? Do I use traces? How do you think that gets solved?

That’s a really, really great question, and I think you can view it from 2 perspectives that I think will happen at the same time. One is that, yes, currently the strict evaluation function plays a key role in AlphaEvolve. One takeaway you can take from this, thinking about the future, is that it shows the really high value of having these evaluators available, because in many cases it might be that you have a really important problem, but you don’t actually have a very precise definition of what makes for a good solution.

One takeaway you can have from a system like this is that if you actually do build a very precise evaluation function, then this unlocks the possibility of having an agent like AlphaEvolve discover something that’s way beyond what humans have been able to discover, or what your best developers have been able to discover. That’s 1 takeaway.

But the other takeaway that I’m maybe even more excited about from the research perspective is that we don’t actually think this is a conceptual limitation. Today, this was maybe the easiest way to get into this game of discovering new things by looking at problems that already come with these very precise evaluation functions.

That’s just a natural first step to take. But I do believe that this assumption can be relaxed in very significant ways. In particular, you already mentioned one example where maybe language models themselves will be able to evaluate whether proposed solutions look promising or not, or whether they fail in some particular ways.

Indeed, there is parallel work from DeepMind called AI co-scientist, which demonstrates this very clearly: if you propose ideas in natural language, then you can get language models to provide meaningful critiques and distinguish the ones that work from the ones that don’t. I really do see a lot of hope in relaxing this assumption. Even in between these two extremes—the strict evaluation that exactly tells you how good a solution is on one end, and natural-language evaluation by a language model on the other—there’s a continual spectrum of simulators and auxiliary evaluation functions which may not be perfect. As long as they are correlated with the true signal, we can build the algorithmic scaffolding of the evolutionary algorithm around them in such a way that we still make meaningful progress. Maybe it will take a few more iterations, but we can still go really, really far.

Just to add what Matej mentioned, I think one of the takeaways is that LLM-based agents like AlphaEvolve, especially when we structure them in this way with population-based search and evolutionary approaches, are extremely effective at searching. They can search very convincingly and very effectively in very large spaces and come up with very counterintuitive new solutions for important problems—problems that we have studied for many, many years and, in some cases, decades.

The other element is the evaluator. As Matej mentioned, there is work on using other sources for evaluation. You don’t have the perfect evaluator. Even for AlphaEvolve, even if you have a simulator, that’s not a perfect evaluator, because you’re going to evaluate things on a specific distribution of problem instances. You might want to prove certain properties of the solution. You might want to say that the solution always has a certain performance. If you want to prove certain properties of the solution, that might require other work. You might have to have a proof agent which tries to prove certain properties of the solution.

On the other hand, you have these LLM-based evaluators, which can look at the solution. Nobody has built a simulator, but they can still make a guess about how good that solution is. In fact, that approach also works very well. We have shown that AI co-scientist, which we have used for hypothesis generation, basically uses a multi-agent setup in which LLMs themselves are able to figure out that certain hypotheses are better in terms of novelty, significance, and impact and should be propagated. That whole process ends up—and this might be surprising and counterintuitive to some—in producing much, much, much better results than the base large language model. You are really able to discover new information beyond what the large language model itself was able to produce.

That begs a question, which I think is one of the biggest meta questions raised by this sort of work: Do we get self-improving AI? One of the things you demonstrated with AlphaEvolve is that you can optimize the systems used to train AlphaEvolve, right? So you have this 23% speedup in part of the training infrastructure, if I recall correctly. Are we now witnessing the early stages of recursive self-improvement in AI? What do you think the implications are if that’s true?

In some senses, yes. But at the moment, what we have seen is basically improvements in computation time. What AlphaEvolve has been able to do is make training more efficient. But you can ask the question: Can you improve the training process such that the underlying model is not only trained faster but is actually fundamentally better at certain cognitive tasks? That is something that still has to be validated, but it is a direction that is definitely very appealing and something that is being actively explored by many people.

Do you have a reason to believe it won’t work?

No, it should work. But as we mentioned, having good evaluators is an important element. You need an evaluator which can say, “This proposal that you have just suggested for me to improve the training process will yield a good result.” If you have that kind of evaluator, then it will work. There is no reason why such an evaluator does not exist, but we need to work on building those evaluation functions.

Maybe just one thing to add is that I would also agree that we are perhaps seeing the first sign of self-improvement. But one also needs to be very specific about what we have shown so far. As Pushmeet mentioned, it’s speeding up the training of the next generation of the Gemini model, so the feedback loop is fairly long, at least currently—maybe on the order of months. But you can call it self-improvement for sure.

The big question that many people are curious about is how this extrapolates into the future. You can have different types of self-improvement. One is where you get maybe a one-off benefit: the model improves itself once, and that’s it. Another is where the model keeps improving itself continuously, but maybe the improvements get marginally smaller and smaller and smaller, and you converge to some limit. Or maybe the improvements will keep accumulating, up and up and up. That’s a big open question that we don’t have an answer to today.

Let’s take that projection to other fields. Obviously, these are all interrelated, but one of the things, Matej, you’re really excited about is how AI applies to the sciences. When you think about new mathematical constructions, improved solutions to open problems, or problems that looked solved to humanity 50 years ago, what do you think the implication is in different fields? Is it a fundamental shift in how scientific discovery or mathematics gets done?

First of all, yes, I’m super excited about using AI to accelerate the sciences because, in a way, it’s the most exciting application of AI that I can imagine. What could be more valuable or exciting than advancing the frontiers of human knowledge? So, yes, that is definitely there. Of course, in different fields of science, the speed of progress or the advance you get from AI might be slightly different.

In AlphaEvolve, we’ve primarily focused on mathematics and computer science because these are the domains where it’s easiest to get automated evaluation functions. You often get them basically for free. That’s not to say that you cannot get them in other branches of science, but in math and computer science, they’re just most common.

If you think about biology or chemistry, you want to design a molecule. You can have an evaluation function again in the form of a simulator or a predictive model that, given a candidate molecule, will make a meaningful prediction about whether it’s actually going to work in practice. If you are in this regime, then again, AlphaEvolve would be applicable. We’re only talking about the version of AlphaEvolve that we have built today, and these are problems that we can address today.

But we don’t think that the journey of AlphaEvolve finishes here. We have many ideas about how to make this system more powerful and more broadly applicable, and I’m fairly confident that we will see many applications across many branches of science. That’s only talking about AlphaEvolve. There are many other agents—Pushmeet mentioned AI co-scientist and many others—that I’m sure will keep transforming how science is being done across the whole spectrum.

Yeah. Broadly, a lot of science involves searching: searching for the right idea, searching for the right construction, searching for the right solution, the right drug candidate, and so on. In some sense, what scientists have been trying to do is somehow make that process repeatable. At the moment, there is still an element of serendipity to some of the discoveries.

But as we move toward rational materials discovery or rational drug discovery, you’re seeing computational approaches and very systematic evaluations playing a much more important role in many areas of science. As that work propagates, you’ll have systems like AlphaEvolve that will be able to search in those spaces and use these evaluations much more effectively. You can see this as a tool that will give scientists a superpower in their ability to search over very complex and sometimes counterintuitive solution spaces.

When I think about one logical extension to this approach, it’s automated evaluation in the real world, right? So, lab automation—a bunch of robotic arms doing experimentation if you’re screening molecules for something. What do you think the role, let’s just say very near term, if that vision is true, of the human scientist or engineer is? Is it problem framing, determining the evaluation? Is it constraining the search space—giving some intuition for a starting point or a search space? What should the human scientist be good at from here?

There are many elements. First of all, as we’ve been talking about a lot, there’s the role of the evaluation function. That needs to be defined: How do we really want to assess these solutions? But then there are many other elements as well.

When we are trying to find a solution, it has to have certain properties. What are those properties? For example, if you’re trying to discover a new drug, you want to make sure that the drug treats the disease but does not kill the patient. Its side effects should be low, and you also need to consider the delivery mechanism.

There are so many different requirements that a solution might need to satisfy. Some of them are encoded in the evaluator function, and some of them you might want to hard-constrain in the solution. Can you specify those requirements so that an agent like AlphaEvolve can take them into account while it explores the search space or constructs the solutions that it will generate? These are all very interesting places where human input might be required, especially as we look at many different types of domains.

I think we should definitely see this as an amazing tool for scientists, computer scientists, and mathematicians. This has, in fact, been our experience as well: in the right hands, it is a very powerful tool. Mathematicians who have tried to explore it have been able to specify the types of solutions they’re looking for, and they can be much more productive and effective in finding those solutions.

I just wanted to highlight that even though we’ve been describing AlphaEvolve as this kind of autonomous agent that does things on its own, in practice, using this agent often turns out to be surprisingly collaborative. We’ve seen this in particular with mathematicians we’ve collaborated with.

There are a few reasons for this. One is that AlphaEvolve is an agent that doesn’t just give you the solution; it searches for an algorithm that constructs that solution. Depending on how you set up your problem definition, the algorithm is often even more valuable than the solution itself, because it tells you how to construct the solution.

That means you understand the ideas that go into building that solution. Maybe especially—and definitely in mathematics—that’s what people really care about: understanding the nature of our universe and building up an understanding of fundamental ideas. It’s often almost not interesting what the solution is; what you care about is how you build it.

We had firsthand experience collaborating with multiple mathematicians, and it’s been fascinating to see how we would share the output from AlphaEvolve with them. They would be fascinated looking at the code that it found and trying to understand, “What is it actually doing?” Then they would realize, “This is doing this, and this is doing that. Now I can see why, if you put it together, it leads to a really good solution.”

I can also confirm from my own personal experience that looking at the code or the algorithms that the system finds is often a really interesting experience. It’s code that looks humanlike, like something you could have written, but would you have thought of writing it exactly this way? Trying to understand exactly what it’s doing is a really interesting experience.

At the same time, that’s one of the key strengths of the system—not only for scientific applications, where you can look at the code and gain some understanding from it, but also for many practical applications. It’s hugely valuable that the artifact you get out of AlphaEvolve is a piece of code that you can deploy. Before you do that, experts—engineers who have worked on that system—can visually inspect the code, understand it, and make the final decision about whether it’s going to be deployed.

It’s in a completely different league from, let’s say, considering using a neural network to make decisions in some production system, where you need to trust that the neural network will always behave in the way you hope it will. With code, you can look at it, understand it, and make the decision yourself.

Not all code is interpretable by humans. The solutions and programs that AlphaEvolve finds are interpretable by human programmers. This is going to be a very interesting area of work in the future: when you find these solutions, what can we learn from them?

This was a very interesting experience, as Matej was mentioning, when we were working with Jordan Ellenberg in an earlier version of AlphaEvolve on the cap set problem. The programs it discovered had very interesting symmetries that mathematicians didn’t know about. Not only was the solution mathematically interesting, but the actual construction—and the algorithm for producing that construction—had a structure that was interesting in itself.

For listeners who are thinking about accessibility or the implications for themselves, when they’re not professional mathematicians collaborating with AlphaEvolve, what are the considerations in making some of these capabilities more broadly available?

We want to make these capabilities accessible to as many people as we can, to the wider community. We’ve started a trusted tester program, where we’ve asked people to submit proposals. What we intend to do with that program is figure out the right ways in which people can really leverage AlphaEvolve.

We’ve used it internally across Google, but, as you know, it requires certain things, including an evaluator function. As part of the trusted tester program, we’re going to be evaluating AlphaEvolve on a range of different types of applications, and that will inform our future release strategy for making it more broadly applicable.

The second element is that you not only need the evaluator; you also need a significant amount of computational resources. It’s not just a single LLM call—it requires a significant number of function evaluations, depending on the difficulty of the problem.

If it’s an easy problem, you can do it very quickly. But if you’re going after a very hard problem with a large, extended search space and you want to spend a significant amount of time searching over it, how do you build the overall system so that people can use it effectively and efficiently? That’s another thing we’ll be thinking about.

Last question for you both. Is there a practical application within Google that you think will be interesting, that you haven’t tried AlphaEvolve on yet?

In this white paper, we tried to think holistically about the computational infrastructure of Google. What are the key parts of this infrastructure that would demonstrate that AlphaEvolve can make discoveries across the stack—not only in one part of it—and that it can make discoveries that are highly valuable?

We tried to cover the entire spectrum. We show that AlphaEvolve can improve the efficiency of the data center, contribute to hardware design, and improve the efficiency of the most important pieces of software being run inside Google. One intention was to demonstrate that this is a really versatile tool that you can apply across the spectrum.

As Pushmeet was saying, this is a tool that is already available inside Google and is being used for many problems.

There are quite a few exciting ones. I’m not ready to share the particulars yet, but, as you can imagine, there are so many exciting computational problems in a place like Google, within AI and outside of AI. I’m sure there will be many really cool results coming in the future.