AI Changes Its Multi-Agent Topology During Inference

Hello community. So great that you are back. Today we talk about a brand new topic, and it is about Imagine the Rewires its multi-agentic team. Let's say you want to attack something or you want to find out something. You research something, but you find my multi-agent configuration is not optimal. So you want that itself optimizes during the execution its own topological structure of multi agents. Let's start. This is the paper of today, published July 30th, 2026. This is Department of Computer Science, Cornell University, Department of Computer Science, University of Illinois Urbana-Champaign, and the Institute of Information Science Academia in Taiwan. Beautiful. So they tell us topology is still typically in the old-fashioned case optimized at design time, at the training time. When we sit at home, we think, so what am I going to build today rather than adapt it during here the real execution, during the inference run? Let's change this. Let's have a study here about MANTA. MANTA stands for Multi-Agent Network Topology Adaptation for a Self-Evolving Multi-Agent System, and at the end of the video you will understand that I say it is not self-evolving, but it is a self-adapting system. But let's have a look. So you say, you know what, this is the very... For a sentence, a biological system, you know, these stupid humans, they adapt not only before encountering the environments. Okay, they plan for a job, but also when they are executing this job, they interact through a continuous interaction pattern with the environmental pressures, with their surrounding, and they adapt. So let's do this with AI. And they already tell us, hey, we propose multi multi-agent network topology adaptation. So for each task, MANTA plans now a topology from accumulated experience. So we do not start from nothing. We have to have a basic knowledge about the domain, about some ideas how to solve it. But we will self-adapt and continuously improve. We will, or the system will, audit the collaboration process of our multi-agent coherence, and it will apply here a bounded structural mutation whenever it sees fit or the situation where the organization becomes insufficient. So there's a lot of terms. So let's start because it is beautiful. So a topological level self-improvement is, for example, a multi-agent system communication structure that is now adapted because you find out, hey, I don't want that some of my agents communicate. Maybe there should be stealth agents, or maybe the agent, yeah, you understand it now, treated as something the system can change dynamically while it is in execution rather than just a design choice that is fixed even before the deployment of the troops, I mean, of their agents. No, now you might say, "Hey, we knew this." No, yes. Again, one year ago, we talked about that the agent can create and design themselves. But now we have this new idea. But you see, we are working now for more than a year as a community on the improvement that whenever an AI is in the field on the job, that it can modify itself whatever it encounters. They have a beautiful visualization here, the ORAS, the level of self-improvement. Now we start here at the lowest level. This is here the tensor weights of the LLM itself. This is reinforcement learning by human feedback and self. But we are now here on the level of the topology configuration. So we have here ADAS like I showed you in a video a year ago, or MANTA, and MANTA is our video today. Then we have here the agent role, the memory optimization, the skill relearning, the tool optimization like in my last video, trace optimization, chain of sort, self-consistencies, then everything that is with prompt. This is your text grid, Gaper, DSP here from Stanford University, and finally a self-refined output configuration. But today MANTA learns from each task, carries over to the next some knowledge, and therefore has kind of a self-improvement. I call it a self-adaptation without, and this is important, any tensor weight updates here to the core LLM. So we are operating only in the harness of this AI multi-agent system. Let's have a closer look. So this is yet a complete infographic if you want. So we start here with a particular task. This is my instruction to my AI machine. Then we do have here of multi-agent system a topological planner AI system. No, the job of the plan is simple. Design a team for the task. Have a basic idea. What should be the topology? How many agents do we need? What is the role of the agents? What are their capabilities? Should they have specific skills when the agents start? You get it. Then we have an orchestration level of our AI, and the task is simple. Validate now the topology that we have from the planner. Spawn up all the agents. Activate everything. Analyze maybe a little, have a view over, is this really the right way how to build it? Maybe modify it already a little bit. Great. And then we have to execute, run once the collaboration turn. Let's see how the system behaves. And we got a trace out of this. We got a first result. And we have here trace auditor AI. Now this auditor has a simple job. Flag the process anomalies in the trace. What worked? What did not work at all? And we record this. And now this is important. We are not operating here in a latent vector space. They decided to go for the simplest solution. Let's just have here a playbook. So we have short-term playbook. So we note down each tolerance topology, all the findings that happened in this particular run, all the decisions that were done here by the orchestrator, and so on. And then we audit here the report by the auditor, and we have a controller, and the job of the controller is simple. I say, yeah, done, so we can stop and have here the finalizer that synthesizes now the result from the evidence, or we say no, it's not good enough, and we have to do something, that we have now to modify our topology of our multi-agent system. And this is here the trace back repair. Careful, there's only one mutation per run. And this makes sense. We just want to have one single topological modification and not multiple at the same time because then we do not know, hey, what worked and what is here really what we have to integrate here in the revised topology that we feed back now to the topology planner itself. So we have a short cycle with a playbook, but we also have a long cycle because look, if the finalizer says, yeah, this looks good, maybe we have multi-agent system that vote on this with a majority voting, so we synthesize now, hey, this looks great. So we have a reflector, and the reflector, I think it's every 24 steps or something like this, rewrites here the lesson, looks at this and says, so what happened here in the last, I don't know, half an hour, whatever you took, and it rewrites now this in a long-term playbook. Now, here we have a highly condensed view. Here we have only the standing principles, how to choose a successful topology, all the lessons learned from experience, but not the nitty-gritty, just the main path forward. And this is also fed back into the topology planner. So the topology planner has, if you want to see this here, my task, and it has access to two playbooks, the short-term playbook and the long-term playbook. Normally, we start here with a long-term playbook because the job of the planner is here, come up with a first idea, come up with what we found out during the last time we run this experiment, and then when we are in the looping here, then we activate here the short-term playbook here for further optimization for the repair. Now, of course, you know that we're familiar with these terms because I would say that the short-term playbook has more or less the role what we called here in the last month here on my channel, the short-term memory optimization of a multi-agent system. And of course, the reflector, you can see this, I see it as a skill reflector here, as a skill optimizer, as a skill self-improvement, a skill update function that then rewrites here the skill that are available fo

something but you find my multi- aent configuration is not optimal. So you want that itself optimizes during the execution its own topological structure of multi agents. Let's start. This is the paper of today published July 30th 2026. This is department of computer

science Cornell University, Department of Computer Science, University of Illinois's Urbana Champagne and the Institute of Information Science Academia in Taiwan. Beautiful. So they tell us topology is still typically in the oldfashioned case optimized at design time at the training time. when

we sit at home we think so what I'm going to build today rather than adapt it during here the real execution during the inference run let's change this let's have a study here about manta manta stands for multi-agent network

topology adaptation for a self evolving multi- aent system and at the end of the video you will understand that I say it is not self-evolving but it is a self adapting system but let's have a look so you say you know what this is the very

For a sentence, a biological system, you know, this stupid humans, they adapt not only before encountering the environments. Okay, they plan for a job, but also when they are executing this job, they interact through a continuous interaction pattern with the

environmental pressures with their surrounding and they adapt. So let's do this with AI. And they already tell us, hey, we propose multi multi- aent network topology adaptation. So for each task, Malta plans now a topology from accumulated experience. So we do not

start from nothing. We have to have a basic knowledge about the domain about some ideas how to solve it. But we will self adapt and continuously improve. We will or the system will audit the collaboration process of our multi- aent

coherence and it will apply here a bounded structural mutation whenever it sees fit or the situation where the organization becomes insufficient.

So there's a lot of terms. So let's start because it is beautiful. So a topological level self-improvement is for example a multi- aent system communication structure that is now adapted because you find out hey I don't want that some of my agents communicate

maybe there should be stealth agents or maybe the agent yeah you understand it now treated as something the system can change dynamically while it is in execution rather than just a design choice that is fixed even before the

deployment of the troops I mean of their agents. No, now you might say, "Hey, we knew this." No, a yes. Again, one year ago, we talked about that the agent can create and design themselves. But now we have this new idea. But you see, we are

working now for more than a year as a community on the improvement that whenever an AI is in the field on the job that it can modify itself whatever it encounters. They have a beautiful visualization here the oras the level of

self-improvement. Now we start here at the lowest level. This is here the tensor weights of the LLM itself. This is reinforcement learning by human feedback and self. But we are now here on the level of the topology configuration.

So we have here ADAS like I showed you in a video a year ago or manta and manta is our video today. Then we have here the agent role, the memory optimization, the skill relearning, the tool optimization like in my last video,

trace optimization, chain of sort, self-consistencies, then everything that is with prompt. This is your text grid, gaper, DSP here from Stanford University, and finally a self-refined output configuration. But today manta learns from each task carries over to the next some knowledge

and therefore has kind of a self-improvement. I call it a self adaptation without and this is important any tensor weight updates here to the core LLM. So we are operating only in the harness of this AI multi- aent

system. Let's have a closer look. So this is yet a complete infographic if you want. So we start here with a particular task. This is my instruction to my EI machine. Then we do have here of multi- aent system a topological

planner EI system. No, the job of the plan is simple. Design a team for the task. Have a basic idea. What should be the topology? How many agents do we need? What is the role of the agents?

What are their capabilities? Should they have specific skills when the agents start? You get it.

Then we have an orchestration level of our AI and the task is simple. Validate now the topology that we have from the planner. Spawn up all the agents.

Activate everything. Analyze maybe a little have a view over is this really the right way how to build it. Maybe modify it already a little bit. Great.

And then we have to execute run once the collaboration turn. Let's see how the system behaves. And we got a trace out of this. We got a first result. And we have here trace auditor AI. Now this auditor has a simple job. Flag the

process anomalies in the trace. What work? What did not work at all? And we record this. And now this is important.

We are not operating here in a latent vector space. They decided to go for the simplest solution. Let's just have here a playbook.

So we have short-term playbook. So we we note down each torance topology all the findings that happened in this particular run all the decisions that were done here by the orchestrator and so on and then we audit here the report

by the auditor and we have a controller and the job of the controller is simple I say yeah done so we can stop and have here the finalizer that synthesizes now the result from the evidence or we say

no it's not good enough and we have to do something that we have now to modify our topology of our multi- aent system.

And this is here the trace back repair. Careful, there's only one mutation per run. And this makes sense. We just want to have one single topological modification and not multiple at the same time because then we do not know

hey what worked and what is here really what we have to integrate here in the revised topology that we feed back now to the topology planner itself.

So we have a short cycle with a playbook but we also have a long cycle because look if the finalizer say yeah this looks good maybe we have multi- aent system that vote on this with a majority voting so we synthesize now hey this

looks great so we have a reflector and the reflector I think it's every 24 steps or something like this rewrites here the lesson looks at this and says so what happened here in the last I don't know half an hour whatever you

took and it rewrites now this in a long-term playbook. Now, here we have a highly condensed view. Here we have only the standing principles, how to choose a successful topology, all the lessons learned from experience, but not the

nitty-gritty, just the main path forward. And this is also fed back into the topology planner. So the topology planner has if you want to see this here my task and it has access to two playbooks the shortterm playbook and the

long-term playbook. Normally we start here with a long-term playbook because the the job of the planner is here come up with a first idea come up with what we found out during the last time we run this experiment and then when we are in

the looping here then we activate here the short-term playbook here for further optimization for the repair.

Now, of course, you know that we're familiar with these terms because I would say that the short-term playbook has more or less the role what we called here in the last month here on my channel, the shortterm memory

optimization of a multi- aent system. And of course the reflector you can see this I see it as a skill reflector here as a skill optimizer as a skill selfimprovement a skill update function that then rewrites here the skill that

are available for our particular domain knowledge for our particular complexity level here in our long-term playbook. So you see immediately you are familiar with the process here and with this flowchart just to give you here the example the

orchestrator has quite a complex task. It combines three LLM components. There's a topology planner, the trace auditor and I call it now the skill reflector which deterministic code that validates the topology runs the agent routes all the messages because we have

a different communication topology now controls here the repair and decides here also when to stop. So this harness layer or this orchestration layer of this particular configuration in the harness itself is now quite a challenging task. So you should choose

here a good LLM that has some idea how to handle this higher complexity. Great.

Now I want to show you or just make you aware. Have you seen that our short-term playbook and our long-term playbook here in orange? They are verbal playbooks.

They have nothing to do with mathematics. This is just here a written out recipe.

One records the topology and the audit history within the current run. This is our short-term memory and the other the long-term skill adaptation stores the lesson across the different runs and is updated. Yeah, I call it a skill

reflector after I think it's 24 runs or 24 steps. Please check it in the paper.

So, it uses only the process signals and never receives here the benchmarked verdict itself.

So, just to make it clear, compare this to my other videos. We are now here in a purely verbal LLM space. This is a verbal description and this is the level of analytical complexity that we try to understand and that we try to optimize

on a topological level. Remember last time we were looking here at a latent space. latent spaces were synthetic mathematical highdimensional 10,00 dimensional vector spaces where we operated here with vector mechanics if you want and the AI was reasoning about

the closeness of vectors or cones of vector structures or whatever but now we are here the artist decided no we don't want to go with this mathematic approach we want to have here for the debugging of the system and for understanding what

the system is actually thinking and doing we want to see this really written out here in let's say English words beautiful so how do we start again the planner receives the task and the experience memory without access to the

benchmark identity or a particular hand design topology we want to start quick and dirty so it analyzes now my human task requirements and the likely process risks so you see you have to have an LLM here as a planner that is familiar with

your complexity in your domain knowledge and has done the job before. Otherwise, yeah, you have a long trial and error.

Processes here a compact plan specifying the interaction pattern, the how many agents, the agent count, and any optional verify or nested group that you need, multi- aent grouping and so on.

Please note that we are here within a deterministic code and I will show you the prompt and everything in a minute.

But here we do not give here complete freedom to the eye to come up with some ideas. No, we have deterministic clear defined level structured pathways that the eye has to follow. This is it. We want to make sure there's no

hallucination. We are have here clear context policies here. So we want to keep the EI within our safety limits.

Just notice that the rooting topology is here much richer than in a classical graph not a hyperraph in a classical graph because the manttopology specifies here hey we are depending on those particular parameters. So the first one A is here the active agents. G is the

nested interaction groups because you have agent that form subgroups and have a particular communication pattern within their interaction groups.

E is the direct communication links on a global and on a local level. R is the structural and the stage rules. I will show you there are two different possibility how we can configure this. O is our execution order how we start.

What is the time dependence? What is the information communication dependence? What is the context dependence here in these subgroups of agents? and C is the information visibility policies. At what time should an agent have access to a particular kind of knowledge for the

particular kind of job that this agent is doing? Now at time step 312. So you see okay we have quite an interesting complexity but remember we are on a verbal level. We don't have any mathematics at all. An agent has two

role dimensions. As the order tell us the agents has a structural role like being a coordinator, a worker, a verifier, a debater or a voter. And you will see this has here an influence here on the topological configuration we're

going to work with. Or you have a stage rule. The stage rule determines its current computational function at this particular subgroup at this particular time. You're a worker, you're critiquing, you are an aggregate of information, or you have here a clearly

defined planning job with a deterministic code structure. There are five predefined patterns or the simplest topological configuration.

This is a singleton, a star, a chain structure or you let the agents debate between themselves or at a particular time you can have a voting between the different agents on a particular decision. So therefore topology controls at least four forms of the computation.

You can control with the topology what agent or who computes, what agent or sub aent configuration is doing what part of the computing what agent or sub agent grouping is communicating about what particular topic on what particular complexity level to what other agents.

If you have visual who what agent sees what at what particular time in which order temporal you got the idea. So you see changing topology can really change the behavior of the complete AI system of the harness. Now although every agent

uses the same frozen LLM at the core this is now I talked here to my AI and this it tried to come up here with a visualization but it is not perfect but it it shows you what's working. So let's

have a look. This is just for fun. Manta here we are a mutable self adapting collaboration topology pattern so we start with a task this is here my blue crystal this is here my human defined task for my AR machine so I have an EI

that is now the topological planner the planner has now access to the long-term verbal playbook here our long-term memory how to do something in my particular task and it creates now a initial topology idea the planer AI comes up with the first idea for my

particular task. It says given what I know from the past experiences and from my inherent knowledge I would say let's start with an initial topology and then we have the orchestrator AI that takes the orchestrator AI takes this planner EI configuration

topological configuration and already optimizes it because this orchestrator AI has a particular job with particular instruction we provide only to the orchestrator and therefore the orchestrator has a clear job to do maybe it is grouping This also as you see here

colorcoded subgroups of agent or maybe an agent is missing and the orchestrator decides oh yeah I need to have a search agent otherwise I'm limited here to a a minimum search space no way to do this and then we have the first run and we

have the execution. Now you see the different temporary roles that we have. Now we have an analyst in green, the planner in pink, the retriever agent here in orange, the verifier agent in red and the synthesizer agent in blue. I will show

you we have three shared state substrates. They just called it the relay packets, the evidence ledger and the candidate answer. And then we have a controller. And the controller says now, hey, which agent or which agent group has access at what time to what

particular piece of information? You got it. Then we have the trace auditor agent. Simple. It analyzes here from a complex multi- aent topology network.

Hey, which traces here provide some information. What connectivities are missing? Remember, we are on a level of a graph structure only. We are not talking about hyper edges. We are not talking about hyperraph structure. And then we have a repair controller. And

here the repair controller here has some tools, some ideas, a limited way to repair this because it is a deterministic controller. Then we have a topology validator. We just validate everything is fine. Great. Either we are finalizing this and we can have now the

uh entry the path is here missing to the long-term playbook or we have here that we build a new skill reflector. We have here skill optimization but what I wanted to show you and this is came out beautiful and this is why I leave this

chart here with you. We have here mutation grammar. So what are actions do we have to repair this topology? At first we have to add an agent here. then expand to a different group change a particular topological pattern that we

have. EI is a pattern recognition machine. So beautiful. We can add or we can remove edges connectivities between our nodes between our agents and we can change the visibility at a particular time what piece of information is available to what subgroups of agent.

Beautiful. And as I told you, we also have from the topological side, the complexity side here also five options. No, we have a singleton a star configuration for our agent, a single linear chain configuration or we allow here a debate

configuration here, a topology where all the in all the agents can communicate with all the other agents or maybe just within its own subgroup. And then as I told you we have voting mechanisms, majority voting or whatever you define

here that is necessary and then we have a final answer. So here you see mantra here in its complete glory. This is it.

So my goodness do we have crazy steps here from a context control or repair controller validator skill reflector to our answer. So I just want to show you here the planner system prompt and they provide you with all the information.

Read the paper. It's a beautiful paper. And we start here with the topology planner. As I told you, it receives here my task, the long-term verbal playbook.

And you see here the instructions are clear. We tell it, hey, you are an expert topological planner for the multi- aent system. Given one task, you design a small query condition topology of specialized agents. Work in three steps. Analyze this particular task.

Choose the topology its analysis implies. Justify your choice and say what each agent has to do. You return only a compact JSON plan and then a deterministic code will expand this and validate it here on the orchestration level

and we give it here three axis. We tell the planner listen you have a task type either you go with retrieval or search or multi-step reasoning or you have coding agents or external tool use optimized agents state mutation

verification comparison summarization you got it. Then you have attributes you can assign. Need for breath parallelism, need for debate, need for verification, hallucination, risk reduction. You got it. And the failure risk. You should be aware. Are there duplicates between the

agent? Do we have redundant agents? What about premature consensus? What about we verification? What about poor decomposition of the complexity in multiple lower complexity elements? No.

And we also give it instruction that we say I prefer the smallest apology that covers the work. Extra agent cost tokens and can be of conflict potential. Do not provision enough agent to cover but sorry but do provision enough agents to

cover the task. And you see we have a lot of instructions. So this is a very very specific system prompt. Not at all.

Like we have here the instruction in my video here on OPOS 5 that they say, "Hey, just tell us what you want and we do it." No entropic here. As you can see, they really had to specify here

because we have no mathematical optimization methodology in the background. Just a verbal. We have to really be explicitly and detailed in our verbalization. You notice the output is a JSON list and this is here exactly. And then yes,

you got it. Yeah. Beautiful. Now, if you say, but wait, this is here a video here. This was the last video here. Yesterday, I showed here to my members of the channel. This is a real complex mathematical paper. But in this

paper, we made the next step. And the next step is simply we do not go with pair-wise graphs like we do here in this video, but we go to hypographs. and hyperraph we have here the added mathematical complexity of hyper edges

for EI optimization. So if you are interested this is a members video but there is an explanation how to go on a higher mathematical complexity and solve it also not only in a graph structure but on a hyperraph structure. But let's come

back to today's video. So manta manta has a control loop. Let's look at this.

Since there's no mathematic it can it's simple now the central loop can be formalized here that we have here the topological planner that selects now an initial topology from my or for my particular task Q and the long-term

playbook M long-term playbook and then we just come up with a topology zero and then the topology is executed here and we have here the query z is the new collaborated trace that we get here out and x of t is here the accumulated

shape state. Now the orus tell us we start with a very particular configuration. Our maximum initial agent is five. The maximum total agent after the repair step is maximum 10. The topological mutations per run as I showed you is

one. So you can only have add one agent or do add one verifier or group agents into a subgroup or but not multiples.

Your operations permutation is at most three and temperature and yeah you have a lot of information what is important look those are baby steps. So you see we are doing this in a verbal optimization.

So we depend on the understanding here and of the parametric knowledge of the large language model itself. So therefore the authors decided to go only here with small topological state space modification that we verbalize and that we limit in the amount of operation here

regarding the amount of agents regarding the amount of topological mutations per run and so on.

So you see we have quite a limited playbook now singleton chain here star configuration then you have here the complete communication network or you go with a voting system but you see manta here tries to really be limit itself

here to baby steps we don't make a huge jump in the topological complexity because we have no idea where we end up and how we can come back if it's wrong let me be absolutely clear here this is

now my interpretation what it really can't change and what it does not change. The mutation language, this is not a mathematical operation, contains the following element. No, as I showed you, add an agent, expand an agent to a

group, a particular group, subgroup, set a group pattern, a particular job pattern, add an edge, remove an edge, set a context policy for a particular subgroup, for you got it. Yeah. So beautiful.

Now they give you examples. So suppose one worker in a store becomes overloaded. Now it is the job here of this multi- aent system to see okay one of my worker one of my agent here is overheating and therefore I have to

reduce the overload and I have now to create instead of one agent I have to create the agent A3 A4 and A5. So I create now a subgroup. I divide here the job here on a group where I reduce the

complexity for each A3 to A5 and they call this a local topology refinement action. If you have parallel agent to attempt the same state changing action, you're no this is not insufficient intelligence. This is just a concurrent execution. You don't want this. Or you

go here low confidence answer with no independent validation can be transformed from a singleton worker into that you add a verifier. So you add an agent that has a very specific top job and a task description. It's computational role here is checking for

examples or you have a communication rearring which agent sees the global evidence ledger. Yes, I think it's clear.

As I told you regarding the worker context management and the topology mutation things are clear. The autist decided here to have here that the agents in manta are state less between the stages. So no agent owns a private

jet history that survives a single turn. All conversational state lives here within three append only stores. And I already indicated this to you but now we have it here explicitly. We have the packet store that holds every relay

package ever sent. The evidence ledger holds every claim and its supporting evidence. And the candidate list holds the best group output of each completed turn.

Here you see it in a mathematical notation. What is now really important is it separates it separates the persistent task state from the temporary organizational structure of our multi- aent configuration topology. So in harness terminology the agents are

temporary computational role instantiated over a shared state substrate or three and they are not persistent independent minds of course not to have dependencies. Now what are the insights? Let me be clear what manta is not. It does not update the model

weights here of our layers of the transformer. It does not perform a gradient descent as I told you. It does not evolve a population of architectures. It does not use crossover or evolutionary selections. We have only baby steps. It does not freely invent

some arbitrary communication protocols. No, we have deterministic structures. It does not optimize against benchmark reward function. Remember we here in verbal description. and it does not conduct an open-ended architecture discovery that it goes out and wants to find new solution and it knocks here at

the door of hugging face and says hey can I just ask you here can I just have access to your server because I need a particular solution this is manta this [clears throat] is not what manta is doing what manta is doing it is change

it's actively changing here the topology during the inference run so during its job it decides okay my internal configuration is not optimal. I have to modify myself. It does preserve the experience across the runs. Remember the ledger. It does rewrite the verbal

topology selection policy verbal. It does use execution traces to select bound and structural mutation. It transfers some learned topological principles to later task. Remember we have the two playbooks for the short-term memory and for the longerterm memory or skill development or skill

optimization. So M demonstrate that some procedural failures are better repaired by changing here the system organization. This means for example the communication topology or the job assignment rather by asking here the model to reason harder. This is what you author showed. Also you do not

have to go here with a more expensive AI model. You can try as the first step in your optimization.

Are you sure that your multi- aent system has the perfect communication topology? Because maybe it is not the intelligence that you have to pay up double the price for a better cloud model because maybe you can solve here

the failure modes that you just optimize the communication topology or at what time you provide some information to a particular subgroup of agents.

Now let's have a look at the result. the result beautiful you have here in the very last line manta and you see not really here yeah sometimes it's better sometimes it's not at all better so I would say a mixed result but what I love

and this is why I show you you see here the comparison to the other technology and the other methods that we implement in this particular case so here the first one you have the reasoning miles the single agent configuration the chain

of sort the self-consistency the self-refinement then you have the static multi- aent system orchestrator without discussion with discussion with tree structure and then you have the adaptive multi- aent system like I showed you aflow or adas here or moss we talked

about this and now we have mentor so it gives you now a very beautiful comparison here for information seeking or planning and workflow execution or pure mathematical reasoning if you're interested here you can see oh wow wait a minute a reasoning model that does

some self-refinement has a performance of 96.7%. This is not bad at all because manta has only 91%. So you see for your specific job for your specific domain complexity choose the perfect configuration. Maybe you do not need a

multi- aent system. Maybe you need only one agent or maybe you you don't need an harness at all. Maybe you just need here a model that does some self-refinement that is real simple to implement. I wanted to show you this. This is a

beautiful table. They also said what is now the most powerful element in manta. So with a full manta we have a success rate 71%.

Great. What success rate do we have when we leave the topology plan at the very first step out? we fall down to 57%.

What happens with no topological mutation 60%. So you see they just go through this input token output token token uses and whatever and they say hm so the orchest come to the conclusion that mant largest advantage comes from

selecting here a suitable topology before the execution begins. So the planning process is really really important how you start from which level you start and not from evolving it afterwards. Yes of course it has a contribution but if you look for the

biggest driver is start with the correct topology from the planning. I found this interesting the statistics of the repairs because they had about 450 specific mantrans if you see read the paper. Now, out of these 450, 117 answers were simply incorrect. False.

However, 75 of those 117 were incorrect runs and were flagged as incorrect. So, okay. 125 correct runs were also flagged. So, this is something you do not want. And only 208 correct runs remained unfl flagged. So 450 to

208 gives you an idea. Do we really need multi- aent system complexities? Because honestly the performance is not famous.

Also keep in mind that a repair flag does not mean that the answer is probably wrong. Most flag runs were still correct. So the interpretation here from the study is more that the auditor estimates here rather the structural risk and not the answer

correctness. So this means we have to look now at the system prom for the auditor AI agent and maybe optimize over there because if I mean yeah it makes sense also to go for structural risk now but also you want to have a query to

answer. So you see there's a hierarchy of elements that you have to check here with your auditor agent.

Another result I found absolutely fascinating is that only 9.3% of mantra operation really add an agent starting out here from the planning and orchestration level and I think this data therefore support the available conclusion we had already in the last

month here on this channel. Theology evolution is mainly redistribution, contraction, the ordering, a specialization of agents, a grouping of agents. But it is not that we have a continual system growth that we have to add 10 agent or 20 more agent or 50 more

agents. If you hear here on social media, yes, I have 500 agents. My goodness, the tokens you waste.

Unbelievable. No. So this study also shows us that Manta is exploring a relative small handdesigned structural grammar. Of course we defined it remember baby steps to a small topological search space rather than going out and explore a general graph

space. So this is interesting here from this verbally limited exploration. Think about this. Simply adding more agent does not really guarantee success.

It's quite the contrary. Often those added agents fail more often because more agent can produce correlated mistakes, duplicated work, duplicated state mutations, premier due consensus like you have seen in my last videos and the first answer comes up and seven

agent vote this is the correct answer. It's complete nonsense. But yes, somehow they decided hey this is it.

more agents produce excessive context compression if you have a longer reasoning chain and unnecessary token consumption. So do not assume that 100 agents more is the solution to your problems. Now as always I have to give you the limitation that I think that the

study has. So be careful. I think manta is generally self- adaptive and weakly self- evvolving at a symbolic harness level. But it is not really a pure example of an evolutionary learning algorithm.

There is no mathematical optimization routine in the complete background. There's no gradient descent. There's no back propagation. There are no numerical loss function. There's no continuous parameter tuning. Nothing. This is just here a languagebased. I mean we have

only LLMs that are really outperforming VLMs and real but yeah I mean the systems optimization is entirely verbal in its description. It is discrete. It is non-ifferiable. We cannot compute mathematics. Everything is purely textbased relying exactly on those two

let's call it textbooks no playbooks and combined here with a deterministic graph validation. So this is a real limited space exploration that we open up here and remember it's just entirely verbally defined.

I will I have to tell you they have some beautiful playbooks when you look at this and they provide you after some runs they show you what this system came up with. So have a look here at the long-term

playbook. You know this is here if you want here the results that after some runs they came up with no they have here the skill document here with the standing principles concentrate the state changes in a single executor match the topology to

the question shapes distinguish a premature give up from honest uncertainty. They even have your instruction how to choose a particular topology. They tell the AI agent analyze the task dependency structure, the evidence needs, the action risks, the aggregation requirements and the

resource budget. I mean if you have a local 3 billion free trainable parameter model along how to chase a top choose a topology is a real complex task. So you need your cloud-based model if you want to have it here more or less correct.

Then the instruction is choose the smallest topology in which every agent has a distinct necessary contribution.

Treat the following as possibilities not fixed mappings subtask dependent subtask independent subtask singleton lessons from experience. And now you have here what the system learned running autonomously. So this is really nice. It is absolutely transparent. It is a pure

verbal description. But honestly, do you think this is the way forward? I mean, we have large language model. So, this is the natural habitate. But somehow, you know, deep down in my heart, I'm missing a little bit of mathematical optimization

circles. So, there you have it. Manta, a new idea to change in a multi- aent configuration on a particular task while we execute this task during the inference run. And we have a new much more adequate team configuration with specific roles of the

team, specific subgroup configuration, a complete new topology. I hope you enjoyed it. Would be great to see you in my next