Stop coding AI: Use Runtime Topological Self-Assembly (UC, DeepMind)

Key Takeaways

Hello [clears throat] community. So great that you are back. Now today we have some brand new papers that tell us humans please stop coding your agents and you might say what? So let's start. You know in my last videos I showed you that Google builds self-arning AI systems and you remember we were talking about your context learning and my very last video was about multi- aents and that AI agent invent new algorithms to survive here in a battle. Now today we're going to look at this and say okay so the emergion of the cooperation in the multi- aent environment was via what mechanism it was via an reinforcement learning optimized in context learning where our activations were optimized in a particular way via reinforcement learning. And today today we go the next step we go to the next technology and today we say you know what let's utilize here the complete left side let's utilize here the LLM as an optimizer itself to mutate and assemble discrete non-ifferiable symbolic graphs that dictate here the system logic for our multi- aent system. So you say this LLM is just an optimizer for my multi- aent learning. This is something that is absolutely fascinating from a mathematical side. But I will explain just the basic idea today. Now up until now we said hm okay AI AI and optimization occurs in a continuous differentiable space. No of course we defined a loss function. We parameterized it with the weight and because this space is continuous we can calculate our gradients. We can calculate our loss function our gradients our back propagation. Beautiful. [clears throat] Now it turns out if we are in the real world mathematical logic for algorithms and for system architecture they do not exist in continuous manifolds. I'm so sorry this is just a mathematical approximation. So now it is time that we move AI over into reality. Our logic, our algorithms, our system architecture do not exist on continuous manifold. Yes, you can calculate a gradient. Then you're somewhere in space and this space is empty. And then what you're doing? You're sitting in an empty space and just looking around and hoping the very next star you see somewhere is maybe here your cosine similarity. So they are logic and all of this. They are discrete. They are non- differentiable and they are highly compositional. Simple example. You cannot calculate the gradient of a for loop. No on a code. So today today I found two new new papers that have two new systems. But if you combine them your your brain just explodes. So yes, welcome. If you want an AI to optimize a complex system like discovering a new game theoretical mathematical formula for mathematical optimization like I will show you from deep mind or and this is the second paper here you want to architect here a multi- aent cyber security team but you want to have the mathematical optimum of this team and we call this open sage it must search here a combinatorial space of discrete structures so therefore we have to represent these discrete structures in a particular mathematical way and this is not anymore here continuous vector space but now we operate with symbolic graph structures okay so we need symbolic graphs okay no problem no because they provide a clear defined mathematical framework for compositionality and exact logical routing and they allow the malls here our LLMs to reason about the relationship and operations explicitly rather than rely on some fuzzy and tangled vector spaces of some disgusting neural attention head. My goodness, this is so 2025. So what we are talking about is semantic mutation over code graphs. And if it sounds a little bit strange, well it is. Now the idea is now that deep mind's alpha evolve optimization optimizes now the logic the algorithmic logic of EI. solvers because to an LLM a Python program I mean what is it just a string of text no but to a compiler a Python code is a tree data structure known as an abstract syntax tree a now guess what we are lucky because an est is a discrete symbolic graph where the interior nodes represent operation binop for binary operation or if for conditionals and the leaf node represent the variable order of the constants. So Alpha Evolve at Google DeepMind uses now the LLM in a very particular function not as an end to end solution but as a smart genetic operator to mutate the symbolic graph directly and you say no but wait the LLM is the eye intelligence no the LLM is becoming now the mathematical optimization intelligence for a discrete symbolic graph that can represent sent the system intelligence and if you say this sounds great let's continue I want to give you a simple example yeah imagine you have a standard counterfactual regret update equation a CFR equation now this is it in a continuous optimization space now this is it the best any could do is tune a continuous upper parameter here a particular learning radiator and here you have your particular optimization since we are in a continuous space now guess what if If you go out in the real world, if you have AI now here, what it really is in an ASD, this is a simple graph. No, this is it. However, if Alpha Wool searches now this discrete ASD space, it realizes it can add a nonlinear if note to the graph based on the sign of the regret, effectively mutating yet the graph structure to invent an entirely new function. Now yeah if you're familiar vr4 asymmetric boosting never mind. So a simple if function can mutate here the complete or build here a complete new function that we cannot build in a continuous optimization space. So this means searching here this particular space allows here for that we are able to discover phase transition and now we go for algorithmic phase transition. And please understand we are now purely in a mathematical optimization space. So a single added note like an if an if statement can radically alter the state dynamic of the algorithm in a way that tuning a continuous wide data cannot. So we have complete new options. Now let's go back to our counterfactual regret update equation. If you play rock, paper, scissors. Now, [clears throat] now let's say your strategy is you play rock 70%, paper 20% and scissors 10%. Now, the opponent best response is paper 100%. You will lose badly. So, in competitive games, if you play a fixed strategy, your opponent can't learn this and exploit it and you will continuously lose. But we want now a strategy that cannot be exploited, is stable, and if you have seen my last video, is a Nash equilibrium. you do not lose. So in this rock paper scissor scenario the national equilibrium is simple 1/3 1/3. Therefore the exploitability is now going or approaching zero. But this means if you reduce the exploitability see my last video we reach a nash equilibrium. We reach a suboptimal nash equilibrium. Now our method says if an action would have done better in the past increase its particular probability. So it uses now regret to shift to this particular probability mouse. Why is this working? Because if the total regret approaches zero then the total exploitability approaches zero. And this is mathematically proven for zero sum games. Now Google de mind shows us here another more complex example. They operate now on policy space response oracles. If you're into it, have a look at it. If not, never mind. Just think they did some real complex mathematical optimization theorem and they could further optimize it. So let's explain pureo using here the same rock paper scissor game. This purea and its basic idea thinks very differently. Instead of just adjusting probabilities directly, our PSO says let's build a population of strategy. So we work at first in policy space, not in the action space anymore. And second, we go with a population dynamics. So if our first element here adjusted a probability inside one evolving strategy like poker, this new PCO builds a mixture of multiple distinct strategies. So this PRCO [clears throat] says let's use here our deep reinforcement learning algorithm to compute the approximate best response. And you already see where we're going. We using now here the LLM and reinforcement learning of this LLM to get a system optimization procedure. I want to show you both systems here. You know in multi- aent systems here optimizing against current opponent lead to cycles and exploitation they solve this here by CFR by minimizing the regret and I showed you this is then simple 1/3 if you go with rock paper scissor or if you go here with a policy optimization PSO iteratively eliminating the exploitability you have a meter equilibrium but you have the same you have one/3 for rock paper scissor in the in the final congrent state. So both aim for a Nash equilibrium. This means zero exploitability. But that we have many problems with the Nash equilibrium I showed you in my video yesterday. But let's stay simple. So this means our new technology is simple. Alpha Evolve and Open Sage operate on discrete symbolic graphs. This is it. And as I've shown you, A is here an example here in DeepMind's case. And now let's get here to open s because they go now here with a topological execution graph and they go now into multi- aent dynamics and agent tool use and tool calling and to um yeah in general into ADKs. Now again a topological execution graph is a directed a cyclic graph and sometimes a cyclic graph where the nodes represent isolated execution state the parent agent the sub agent the tool sandbox or the vector the graph memory state and the edges simple represent control and information flow. The agent A spawns an agent B. A and B execute a particular tool T1 and tool T returns standard out to a memory node M everything that we know. But now everything is defined as a topological execution graph. And if you think about the mathematical branch of graph theory, you immediately understand we can use now all the tools that we have for Matt graph theory to optimize the topological execution graph for a particular job. So this means in the previous ADKs like lang chain the graph was static. So we had a let's call it the human engineering whatever hard codes here a rigid pipeline. Yeah. And now they tell us the time of the humans is over. Now in open sage we enable a runtime topological generation of this. So this means the LLM the intelligence if you want of the LLM decides now in real time how to construct and branch this graph based on the environment on the task complexity itself on the vertical and on the horizontal topological complexity that we will encounter. Let me give you an example. Let's say the task is to fix a complex C++ memory corruption bug in a flat context. No beautiful we have hallucinating whatever connections great but in the new approach the topological execution graph with open sage what we have the parent agent creates now let's say a vertical topology graph at the runtime so it spawns a sub agent one for the static analysis giving it only the code [clears throat] tool second concurrently it spawns a sub aent two the dynamic analysis giving it an isolated debugger tool and a separate docker sandbox. Third, the graph branches into two isolated context. Sub agent one and two maintain distinct clean memory trees. And four, they return the concise high signal summaries back to the parent node to execute another patch. You see the difference? This means that a topological execution graph can act as an attention firewall because by encapsulating the logic into distinct nodes, we kind of artificially forced the LLM to restrict its reasoning to isolated highly relevant sub problem sub region separated sub complexity preventing here catastrophic context collapse. So this helps us a lot if you get it right on the graph. So this means here we stop now with the introduction. Let's start here with the real lesson. The first reflection from the introduction is instead of treating you an LLM as the final end to it solver. These new approaches I'm going to show you now utilize the LLM as just an optimizer. An optimizer to mutate and assemble now discrete non-ifferiable symbolic graphs. But the beauty is that those graphs dictate the system logic of multi- aent system. And this is exactly where we want to go. So let's build let the LLM build agents. This is the paper here again. Google deep mind. You see here 2026 February the 20th discovering multi-agent learning algorithms with LLMs. Read this again. Discovering new multi-agent learning algorithms. We're not any more game theoretical approach like in my last video. We let now the intelligence of the LLM in a mathematical optimization procedure that we define at first at least at first in the beginning let them discover new learning algorithms. And then the second paper that just happens to be published here or less on the same day is open sage self-programming agent generation engine which is crazy if you think about it but just look here at the end institution UC Santa Barbara UC Berkeley University of Colorado Boulder Columbia University Duke University guess what Google Deep Mind and UCLA. So Google currently has here if you want to go to the next generation AI or next next generation AI system Google is absolutely fascinating with the research it is producing and what it is experimenting with let's start here with the simpler one current agent development kits lang chain autogeni SDK restricted what we term the human center paradigm humans rigidly define here the deck the agent topology ology the static tool array and the flat vector database memory all problems break loose massive hallucination catastrophic context collapse everything that you know now open sage is here a first agent development kit that supports AI centered agent construction and this includes automatically generating the right the correct agent topology for the task designing the tools that are needed for my particular task And and this is really amazing, DI now manages here a memory. It has a memory optimization run internally to find here the best memory configuration. Humans don't have to do anything. Maybe a cold start, but this is it. The rest is a mathematical optimization program that can be run by an LLM. So the core idea is to provide a minimal and yet essential scaffold that enables an AI to automatically explore and construct agents that are perfect for the complexity level and the difficulty of my particular scientific job. So if you want the absolute new idea is here a runtime topological self assembly. You have never seen the eye with this eyes. So they tell you hey we are so great open sage look we are implementing here all the beautiful things that the other never implemented beautiful and they support dynamic creation execution termination of sub agent during the task execution we have a vertical agent topology which this is nice which decomposes the complex tasks into sequential subtask to be completed by specialized sub agents but also it takes care about the horizontal agent topology where multiple sub aents simultaneously in parallel execute the same task like search the internet for a particular competitive analysis. But beyond the topological flexibility, open sage empowers the AI to construct its own tools for the targeting task and provide tool management function tool orchestration state management execution isolation and everything. This is simply amazing. Plus, we don't stop here. The SH agent just don't invoke the tools, they compile them. So, it permits the model to write Python or C++ script. And plus, we have a hierarchical memory system that is of course graph-based that combines now the short-term history with the long-term system knowledge managed by a dedicated memory agent and therefore it completely abolishes your dense vector rack system. What an interesting powerful system. If you want to see here everything here on one visualization, here you go. Open Sage the topology structure, the tool complexity and the memory optimization. Such a nice idea. And yeah, and there go we Neo4G graph structure. Okay, now let's have a look at the result. What are the benchmarks? We have three cyber jam terminal bench and another one. So our sage agent here now we go with GD5. Let's go with medium. We have here the ADK of open sage. Look outperforms everything else. Terminal bench we go now with a Gemini 3 Pro. Open Sage outperforms everything else here. Yes, you get the idea. What's found interesting is stablation analysis. This is here for 300 instance subset of cyber gym. We have here the resolved rate. Okay. So full sage agent is here 64%. If there's no hor horizontal um topology optimization or less no vertical even less. Yeah. And if you have no features of course. And then also here for the tooling. If you take away the tools look the performance drops significantly. And if you take away the features Yeah. Of course. Yeah. Very nice is also here. Let's compare these three benchmarks. A gym terminal bench and s sw bench bro. You see here if you go here with the sage agent on ch5 for example or you go with entropic ous 4.5 open hands with gd5 or g3 of course means gemini 3 pro. So you get the ideas here. It's really outperforming the other stuff. What I found interesting if you go here and have a look here at the costs. No. So we have here a Gemini 3 Pro. This is here the thinking model, the planning model, but we also have a GD5 mini here in the mix in the set of possible LLMs here for the agent. Yeah. And if we have here, if you want a huge small collaboration, this is here either we go with Geminis 3 Pro, then we have this performance 65.2 or we go with G5 mini. And this is here on a terminal bench 2.0 31.7 or if you have this collaboration between the two LLMs we have here 47.8 date. You see, this is almost identical to a GPT5, the main one, not the mini one, the main one. But look at the difference of the costs here. GBD5 would cost us whatever 40 cents, but this collaboration would just cost 30 cents and we have almost the same performance. So finding here the optimal Gemini 3 Pro and Gemini 5 mini configuration all the mathematical best configuration is simply a mathematical task. Hey and therefore we do have computers therefore we do have artificial or machine intelligence to run this optimization tasks. So you see this can help us a lot to find here for the lowest price here the best performance ratio. Now they are really detailed and they give you here in the annex everything you need to know the tool called for creating a sub agent for the debugging or the tool called here for invoking the debugging sub agent everything is explicitly listed here in this archive preprint. So if you want to have a deep dive, you find everything you need right over there. Okay, this was the first paper. But now now comes the second paper. Now really we go again to Google deep mind discovering here the multi- aent learning algorithms. This is a heavy mathematical paper. Therefore I just want to give you a feeling for this. I just want to give you the main idea how this is possible. Now by using now the negative exploitability this is simply the distance from our Nash equilibrium as the fitness function the LLM performs a symbolic gradient descent on the code itself. Now discovering now highly non-intuitive maybe asymmetric and dynamically adaptive mathematical updates. So this means maybe the AI will discover mathematical optimization routines pure mathematical formulas that the humans have not yet sorted off for a particular kind of a job. Yes in in mathematics people have spent hundreds of year thinking about all possible problems but maybe there is one particular problem that we have not yet the best mathematical solution. So why not use an LLM to search for this solution? Yes, it will cost a lot of money. Yes, will cost a lot of time. Will cost a lot of computer infrastructure. But hey, at least we have something positive that comes out of our machine intelligence. Yours now apply alpha wolf an LLMdriven evolutionary algorithm directly to the Python source code. As I've shown you here in the explanation, this is what we call the abstract syntax tree, the ASD of the solver itself. And they go now here not for the PSRO that I explained to you in the introduction of this video, but they have now a smoothed hybrid optimistic regret PO and you already see on the title, my goodness. So what they discovered is a dynamic and kneeling MASA. So either you are now absolutely fascinated or you say what anyway it's a hybrid blending formulation where you have a ma strategy that blends here the rigorous stability of the optimistic regret matching with a greedy temperature mooded softmax over expected pure strategy values and this is the formula that it discovered developed. So you do have now a dynamic transition during the transition the training roll out the blinding factor lambda is dynamically annealed from a particular range and the early iteration parameters therefore the massive topological expansion of the game graph. This means we have the exploration via the softmax while the later interaction we have here decaying lambda to the transition into exact regret based equilibrium refinement steps. So again we have here the equilibrium the sensitive equilibrium between exploration and exploitation. Now you might say is this something here with open claw? No this is not. Open claw is just a simple communication protocol. What we are talking about is here two technologies later pure mathematical optimization algorithms that are really done by by sound mathematical proven algorithms. So this is like hey let's go crazy let's go wild maybe we find something and the video today is something about a clearly deductive mathematical logical sequence here to discover new optimization theorems. Now, let's talk about a synthesis because I showed you both papers and I was fascinated and I decided to take out this both these two papers here out of my stack and put these both papers right next to each other and read both papers with you together in this video in parallel and I think if you read it in parallel we have a scientific synthesis I want to show you. So this is now my opinion I think but both papers sulfere the limits of the human continuous reasoning by inventing simply tools to navigate your discrete graphs and you have here the first deep mind paper that tackles it a micro architecture this means the pure mathematical optimization logic by let's say mutating the abstract syntax trees it kind of proves that we can automate the discovery of foundational optimiz mathematical optimization rules and mathematical compounds let's call it something like physics no that govern the learning process of multi agents now open sage tackles here the macro architecture the cognitive routing and the context management by dynamically building topological execution graphs it kind of quotation mark proves that we can automate to a high level the highle cognitive routing distributing the cognition across specialized subm modules and building and controlling and supervising memory hierarchies. I see this as you see here as microarchchitectural optimization and macro architectural optimization. Here we have the pure mathematical optimization logic, the pure mathematical formula and here we have if you want the system configuration and the best theoretical architecture, the topological execution graph for everything for what LLMs in what combination with what tools build new tools, connect new tools in new ways, have a new highle cognitive routing between LLMs and tools and everything else. build subm modules, optimize the subm modules and have new memory hierarchies that are optimized here for your control flow. This is the way I see it. Maybe I made a mistake. Please leave a comment in for this video. But still, there's so much yet hidden in these two papers. Please have a look because I still scratch here my head and say, hm, I have so many new ideas just reading the paper. So I really would recommend you have a look at both papers. Anyway, the other message is also that the human intuition to code software engineering it has now become the bottleneck of an AI design because we humans we cannot visualize a 96dimensional uh vector space and we have to optimize now asymmetric logic that is required for a new solo algebra. I can't see this you know I can't imagine this. If you can congratulation but in normal humans can't do this. So therefore we invented machine intelligence nor can we human statically predict here the optimal multi- aent structure required for to patch your zero day C++ vulnerability. We have some recipes we have some templates. We have some empirical data. But is it really mathematically proven the best the optimal configuration to do this job? So therefore I think the future of AI research really requires here to be careful what we humans think we have to hardcode into AI. Maybe we have to stop hard coding here or trying to code the complete machine intelligence. You know if we have so many safety rules and safeguards and optimizations they are in fear with each other. They conflict with each other. We see this daily. So maybe instead of focus purely on building here the the sandboxes let's call them and the compiler that would allow here the machine intelligence to architect itself. Yes we should supervise this as humans. Yes, we should absolutely control here everything but you know give our machine intelligence a little bit of space to explore some unknown territory because if we limit to the human intelligence I'm I'm not sure that this is the way forward for the machine intelligence itself and yes of course you know me I selected those papers because I feel that maybe we can combine the ideas of those separate papers Because in my mind I already see how maybe we can apply Alpha Evolve's programmatic evolutionary search routine, the mathematical optimization routine to open Sage topological parameters. If we can do this, if you can do this, hey, great. So instead of relying here of a human to write here every single prompt that tells your open sage model how to construct sub agent how to do this how to call here particular tools. We should use reinforcement learning our one and only learning methodology that we have for AI to let the programmatic logic of the AI evolve themsel. Let's utilize the reinforcement learning method that we have that is our only learning mechanism in AI to evolve here the programmatic logic of the agent orchestrator itself. This would be an interesting element not here an open claw or multipart or whatever. This would be an optimization here for the performance of the system. That would be really fascinating. And as I've shown you from Google deep mind to UC Berkeley, every if you want academic institution seems to be currently working on exactly this problem. I hope you had a little bit of fun with this video. I hope there were some new insights. I hoped to see you in my next