Today we are going through a very interesting piece of research — extremely important and extremely recent. Research within artificial intelligence that has data on genuinely current models is rare. Because the outside institutes that analyse everything usually work with older, previous versions or with builds that are not the strongest. So then: what happens not with one strong agent but with a system in which dozens of agents work side by side, depend on each other, share various resources and tasks, when we set them different goals, and these agents make decisions inside what is effectively a shared system.
And Anthropic takes the view that testing individual models is no longer enough, and that agents which are safe separately can form an unsafe system — in their understanding, broadly. And they have released research that I think is extremely interesting for us to look at together. It is research into the patterns and problems in emerging multi-agent systems. It came out only, notionally, a couple of days ago. The work itself began on 7 April, when Anthropic introduced its experimental model Claude Mythos.
And that project, known as Glasswing, is a programme applying this model to finding vulnerabilities in critical software. And in the earlier work agents were launched independently, and each agent was given a separate project — some file or section of code. Whereas here we have research that is about multi-agent work. I want to offer a preamble. There are some quite interesting things in the substance of the experiment, because there are forty — when forty-five agents look for vulnerabilities at the same time.
My preamble is this: we now live in a world where the very leaders in artificial intelligence, the people running companies like Anthropic, like OpenAI, like Gemini and xAI. Today we have xAI. Elon Musk's xAI. It is not by chance that today I am rather more on Elon Musk's side. So then: people very often make extremely superficial claims, and then they change them. And you can see over the past year how much the market's perception of what an agent even is has shifted. That is, at one point it felt as though an agent did the work for you.
And now we live in a world where there is some enormous number of agents. Some people even use the notion of thousands of agents. And the question is whether those really are thousands of independent agents you control, or whether they are merely components of this artificial intelligence, or of what can be called artificial intelligence. And how far we, ordinary people, need to understand and go deep into the separate, independent notion of an agent at all. Why did I mention Elon Musk? Because many of the projects Elon Musk releases or builds — I like his project, this Macrohard, a sort of replacement for Microsoft, to rebuild all software — are fundamentally clear.
That is, he says we will make the new software of the future, we will not use the current solutions. That is, future solutions will be something else. I said repeatedly three years ago and I still hold to it that a system like ChatGPT is becoming an operating system. And then the question: is there any point in reasoning about agents at all? But! Right now all the systems are still very heavily built on agent terminology or agent architecture. Although in some systems these agents do something, and in others it is unclear what they do.
I remember Elon Musk first releasing Grok — quite a lively one, where he sat there himself at the presentation and showed it off a great deal. Grok appeared, the expensive version, which cost two hundred and fifty dollars at the time. And there, when you launched it, it would say: four agents are now working in parallel. And every system started using the notion that, for instance, four professors from some famous university are working in parallel for you, four scientists sitting there resolving your question.
For example, whether you should take these pills or not. Or what conclusion to draw about a set of financial statements. At the time that seemed a broadly interesting idea. But as we all understand, we do not actually need four people sitting there. We need our task solved. And how it was solved — by four agents, by eight hundred and sixty agents — what difference does it make to us? Nobody looks at what is under the hood of a Google search that gives us an answer. Hardly. So then: Anthropic's first experiment, forty-five agents looking for vulnerabilities. That was the experiment.
Why test this? Vulnerability research splits well into various parallel tasks. And in general, what I am going to describe today is a fairly serious and important subject, given the various break-ins and the question of where artificial intelligence now stands and how far it is within anyone's control. We have said repeatedly, even in the last episode with Ilnar, that all the systems already are, as it were, outside anyone's control, even… Kimi 3 Moonshot — either that is their marketing, or they too wrote that their model got out of control.
The Chinese model Kimi 3. So, one agent can investigate. For example, if it is looking for a vulnerability, it might handle memory. Another agent might read the code that comes over the network, the network code. A third agent might check, say, the access-rights checks. And accordingly, one agent's mistake does not necessarily spoil the others' work. And, by the way, whoever often uses this agent management inside, say, Codex or inside Claude, please tell me, because I recently had a case where Claude answered me, I had already started working through it, and then it sent me something.
It said the agents had done some more work here, and sent a completely different conclusion. Very interesting. That is, one batch of agents decided one thing and another batch decided something entirely different. And Anthropic in this first experiment wanted precisely to find out whether the agents coordinating on their own gives an additional result compared with simply running a lot of these isolated agents. And anyone who has used Codex or Claude for a while — a while being months — knows this story exactly.
There was even a fashion for writing in the Claude chat: «run an agent orchestration task for me», for instance. Launch them for me, orchestrate them. And we had an enormous number of debates and comments inside. You are using it wrong, you are using it right. We know this, we do not. People wrote in. I always enjoy the comments where people write «you are using it wrong». So I think: this person presumably writes Claude code themselves, and therefore knows absolutely every detail and understands how it works.
Personally I can say that I do not understand how all these systems work, even though I am a very professional user of all of it. But when I say I do not understand — why? Because I do not understand why ChatGPT in the pro version sometimes solves my task straight away, spending forty minutes, say, or an hour and a half. And sometimes it spends two hours and writes: «You know, I have not solved your task yet.» And then you ask it further. By the way, anyone who has run into this over the past weeks, write in too.
And in general, anyone who has run into new models sometimes working far worse than old ones. Because the new models seem to want to go into this eternal, endless cycle — the so-called loop — and resolve the whole task they were set by themselves. So far I have not seen a single task of mine resolved that way. And those first versions of systems like Opus 4.8, for example, or Claude Codex 5.5 — those were probably genuinely revolutionary. They really made a revolution relative to the previous systems.
As for the current models, I have big questions about them. Except Fable. So far I put a tick next to Fable. So, how was the experiment set up? What did Anthropic do? It launched forty-five agents. Each had its own virtual machine. For anyone who finds some of the technical information difficult — well, you are listening, the details will be interesting, and the general conclusions about artificial intelligence — but some terms may be hard. So, each agent had its own virtual machine. All received the same assignment: find vulnerabilities.
There were fifteen open-source projects. They had a neat setup, a shared forum for coordination. By the way, have any of you watching tried to build different systems so that AI agents from different systems talk to each other and do something? At one point I had an acquaintance who even built such a system, and we even started building a piece of it together, but then we somehow went our separate ways. He had a decent vision, I liked it. He said the following: there will be a world where agents talk to each other. And so we need to build a system for agents to talk to each other.
And it seems to me this subject is not studied at all yet. And there are some exchanges, someone is trying to build agents, trading and so on. There are even decent, interesting projects. Our editors will show them here. But the subject is absolutely unstudied. That is, can my agent talk to, say, my wife's agent and agree with it about something? That case would work nicely in education, where people are split into groups, say. And agents of one group talk to agents of another, or your agent talks to some other person.
A decent idea. People often go off into this subject, by the way. And earlier in Silicon Valley everyone talked about needing agents that coordinate schedules with each other. Now agents are at a simply colossal level. Not once has anyone tried to schedule a meeting with me through an agent. Well, maybe there is some layer of people scheduling meetings through agents, but it is somehow unclear how it will work and why it is needed. Even though the system now seems developed. Write in if you have ever done it. So, Anthropic, again: for those fifteen projects, forty-five agents, they had a shared forum for coordination.
Agents could choose which project and which type of error to investigate. They checked each other's results. A very interesting subject. Again, the research is incredibly good. And a separate arbiter agent decided whether a reported vulnerability was, for instance, new and well-founded, or somehow not genuine, and so on. Two models were tested. Claude Mythos Preview and Claude Opus 4.8, which I have just described to you. Again, very good models, very current. This is not a study at the level of «ChatGPT-4 was tested on a hundred thousand people».
That is, a very good, strong subject, genuinely strong. Yes, I am sure Anthropic has far more data. They shared part of it with the community. Obviously they will not share all their data with us on agent research. And plainly such corporations must have teams running work between agents, in strong organisations generally. If you work in a serious organisation, in a technical or AI function, you should have separate research streams that compare how different agents work together.
Again, this is expensive work that is unlikely to bring much profit now, but that lets you gradually — as I always call it — live with the present. How to make money from it is another question entirely. So, the control variant was different. In the setup they built, several independent agents without a shared forum received pre-assigned sections of code to check. And so the comparison was not forty-five agents against one but a coordinated group against a parallel group with no communication.
So, what were the results? There is a coordinated group and an independent group, and in both modes it turned out that of Mythos Preview's two hundred and sixty-six results only a hundred and twenty-eight related to the main directories in which the independent agents were allowed to search. The remaining hundred and thirty-eight were found outside the area assigned to the control group. And besides, the independent Mythos Preview run used — important or not, but for the technically minded I will say it — six and a half million tokens, the output portions of text by which a model's volume of work is roughly measured.
And the coordinated group used twenty-seven million tokens. That is, the group spent effectively four times more money, four times the compute, and had a wider search area. So saying, for instance, that the team turned out to be twelve times more effective would be wrong. But at the same time the raw results really do differ overall — two hundred and sixty-six against twenty-one, that is, twelve times. But at equal search area and accounting for tokens spent, Anthropic itself calls the effectiveness of the modes roughly comparable.
And here an important aspect comes up — my favourite subject — that many of the systems being built in the world today are built on cheap models. And all the chats you use, the semi-free agents built into various systems, are often not agents running on super-expensive models. Sometimes there is a premium somewhere, a promo and so on, but mostly these are cheap models. When you go to super-expensive models it becomes very expensive, especially supporting each one of you. Whether you are in an interior-design chat or a marketing one, or in some educational chat, and you are studying, I don't know, spiritual literature, or you are studying English — running expensive models at your volume, at the level of not even Fable but Opus 5, or not Sol 5.6 but something simpler, even 5.5 — that is still very expensive.
Running 5.5 Pro in particular is a very expensive proposition. So, what did the coordination give? Where the agents worked in a coordinated way inside this so-called forum. First, the agents distributed themselves across directions on their own, built their own tools and specialised — they ended up specialising in particular classes of vulnerability. And if, for example, they saw that some area could be checked more seriously, they dived deeper into it. That is, they took more of their capacity, their resources, their agents and switched more of it there.
Or, for example, they kept finding new problems at roughly a constant rate over a long run. There is a very interesting feature, by the way: a small volume of overlap. Of these two hundred and sixty-six Mythos results, only twelve were also found by the independent mode. Not twenty, only twelve. This shows the two approaches examined the code differently and can complement each other. And we see this ourselves when you write in the chat «check it again» — it checks and finds another error.
I strongly recommend to everyone doing serious work — I recently said to a partner of mine: «Listen, you are checking these legal documents, be sure to write in the chat, check it for me again, go through the base again for me.» And you have to get very used to that. The point is not even that the model can be wrong. It can, first of all, offer an enormous number of different opinions. And so what is completeness of an answer? What is a correct answer? That is a big question.
I ran into a story about this, by the way. In my own life I specialise heavily in data normalisation and in data storage generally, in database architecture. And it was always very easy for me to think through database entities — to describe what parameters a company has, or what parameters a department has, or what parameters some system has. I remember from university that I found this fanatically interesting. And what did I run into? That on the one hand I like the kind of agent work I am describing to you in this Anthropic test, because I have obviously been using such agents for several months, where they produce incredible things in parallel.
On the other hand, I see that many of their things, many of their processes, are unfinished. And here programmers like to come back and say: no agent is yet a fully-fledged strong programmer, none writes strong architecture. And I have a double-sided view, because I have rarely met programmers who worked things through really well — who during development could genuinely think through the business logic, understand it, extend it, rather than simply build some architecture per the specification or do something per a written systems analysis.
The question in general: fine, even if a good programmer did the systems analysis themselves, wrote it all out, the whole architecture, and produces some result — how far do they really understand the final part, how it will be rolled out, or what problems are possible where, or what will blow up where? That is, how ready is the system to recall it? I have several systems I am building. Let me remind you — remember, in one of the episodes, if you have not watched it, watch it, and if you have, give that system a like.
I built a system, it is still very much alive, under a fairly large load. I showed you a system in real estate that pulls data from our CRM. So, in our system, the one it pulls data from, there is a data-normalisation error. There is effectively the notion of a lead, a lead and a person, that is, a person who submits enquiries. That is notionally one, one foundational construct. That is, there is no arrangement where you manage a separate person. That person has many different enquiries. There is a very interesting story here, by the way, that there may be a company, the company may have many different people, and those people submit enquiries on the company's behalf.
That is, effectively the company has many enquiries, and here the question is whether an enquiry initially — it all depends — is a company or an individual. And then an individual. This, by the way, is a question an enormous number of CRM systems never solved, never managed to solve well and normalise well and make well, so that it would be really good to manage — especially when on your side there are also different companies, different legal entities and different employees.
This was practically an unsolved problem everywhere, in XRM, in CRM and in ERP systems. So, my system, having built this traffic work, did not provide for this question. And now, when we have put up a separate site — a portal, within which there is already a proper architecture, with contacts, with enquiries, with different attributions for them, with all contacts having entirely separate visits and a history of those different visits. Effectively one person may have many different devices. On those devices there may be many different browsers, and many different mobile apps.
And now agents are appearing that go in on people's behalf, and all of this has to be caught and tied together somehow, so as to keep this data about the person. So, no system, neither Fable nor Opus One 5.6, hit on this or built it into the architecture. Nobody. Nor 5.5 Pro, which helped with the initial design, even though I knew it. Basically I simply understood that if I went into developing too serious a system, I would stall. Perhaps I should have done it right straight away.
Although then there would have been no fast result. That is, a fast result is effectively something you cannot get.
So, what were the limits of the results? Coming back to these two hundred and sixty-six vulnerabilities found: the number two hundred and sixty-six does not automatically mean anything. That it is two hundred and sixty-six critical vulnerabilities. Look, this is an important construct. That is, it does not mean these are two hundred and sixty-six supremely important vulnerabilities. There is the notion of a zero-day vulnerability. Or two hundred and sixty-six errors that can definitely be exploited. Or two hundred and sixty-six definitely registered security problems. That is, in this trial the result was scored by an arbiter agent that sat on this Forum construct of Anthropic's.
And remember, I said it withheld part of the data and did not publish it — the breakdown by severity, the number of these triggers and so on. What was the second experiment? Look, this is very interesting. So, the experiment was as follows: from ten to eighty agents jointly create a computer game.
By the way, if we look at the system of different tests generally, we see that there are tests done, for instance, only in computer games. I see a lot of that. Personally that does not interest me. There are systems whose tests are done only for mathematics, for example. I do not much like that either. Here is what is good about this. Even this Forum agent setup differs substantially, basically, from the approach of — what do we give them? Do we simply give an independent system, or, say, create a computer game — these are different things.
And, notionally, finding vulnerabilities or creating something from scratch. And here the agent from the point of view of creating games — by the way, what do you think about this generally? Write in. Apologies for going off to the side here and there, but only this way can you form the full construct and catch the whole of today's thought that I want to convey. Everyone wants to make this «Ready Player One», and nobody can let go of this whole 3D world. And look at one of my latest episodes.
I talked about what Meta is doing internally and what Zuckerberg declared in terms of Meta's constitutional essay. And a big bet is placed there, again, on this 3D reality, on glasses, on distorting reality for the person. Because it is unclear to me why the agents were asked to create a computer game. I would have asked them to create some separate, genuinely useful thing. Not games. But never mind. So, there the agents ended up depending on each other. They had to build — by the way, it was an open-world fantasy game, playable through a web browser. And of course the field really is moving unbelievably.
Very interesting. I do not play games, so someone here may hit me over the head and say: «We play here, Alexander, it is an important subject for us.» Well, all right, write in the comments what you find interesting there. So, each agent, in building the game, again received a separate virtual machine, as in the first case, received the shared forum, and obviously they had a single repository where they saved this game development, and the ability to change code and propose merging changes into the main version. An important point, that this was shared. And each group worked for twelve hours.
Group sizes ran from ten to eighty agents, which is not small. Here they widened the range. It was not only Opus 4.8 or Mythos Preview; there were simpler models. There was Sonnet 4.6, and Sonnet 5.0, and Opus 4.6 as well. That is, simpler models. So, three management variants. Anthropic tried three basic organisational models.
Agents create teams and distribute the work themselves. And here, by the way, I think it is incredibly important that you listen closely, because how do you manage them at all? The second was that roles were specified in advance. For example, core programming; second, say, the art direction; third, testing, and so on. Roles handed out separately. I moved away from roles at some point, by the way. Many people do it, but I moved away from handing out roles, although I tried it and tried writing «you write the systems analysis, you read the specification» and so on.
But I realised that genuine management of agents, for me, is when the model itself manages those agents. For some reason I think that is better and more correct. But never mind. What do you think, by the way — who still distributes agents among themselves, and who gets an effect? A genuine, really strong effect? And the third management model was that one agent is appointed manager and the rest must receive assignments from it. And you can take these three management variants for yourself, by the way. So, look: agents create teams and distribute the work.
So, the second — you see the difference? That is, they created them and said: you, team, do this; you, team, do that; you, team, do the other, inside. And decide what further work you will go deeper into and look at. So, separately, when a role was written out for each agent individually, and separately one agent — and a role was even written for a team as well. And separately, when there was some agent, a manager, and you can make several of them for instance, and the rest receive assignments from that agent.
What, by the way, is the problem with all current systems? I do not understand how costly this is in terms of tokens, for instance. It is completely unclear to me. That is, if people come to me at work, I know: I have directors sitting there, or ordinary employees sitting there. I know: this goes to this one, that to that one. I know what each person costs. Whether I can occupy someone or not, whether I can load someone up more or not. Here the situation is very hard. That is, we work with a black box. Whatever anyone says, it is a black box.
And essentially it seems to me that Anthropic does not fully describe what an agent even is. Even when we say some model, still — what is this agent? And here there are no details, as it were. But never mind. So, the difference between these variants in terms of management, by Anthropic's conclusion, was small. Simply telling a model «you are the manager» did not create a genuine management system, and such a manager had no technically fixed authority, no mechanisms for blocking conflicting tasks or requiring review of changes.
So, what came out? What came out once all this was launched? So, Anthropic rated all the games created as poor. They ran slowly, the interfaces were confusing, player onboarding was absent or excessively complex, and the product needed serious human direction. By the way, there is a very important story here. I will show it to you soon. We made a site for the ToTheMoon channel and built semantic cores for every episode. It looks very good. And I want to say that this system was made entirely by an agentic Fable.
Very fast. And essentially it was the work of, notionally, ChatGPT Pro, Claude Design and a few Fable sessions. Literally two different Fable sessions. And today I spoke with someone on my team who works on traffic. And he says: «I genuinely enjoyed the speed of the system, how fast it searches.» And I enjoyed it too. Obviously there are downsides everywhere and all the rest. You will see that too, that system. The point is not the downsides but the speed, and that the system did everything to a good standard.
And there are cases where most systems, most of my tasks, nine out of ten — if I do not break a task up somewhere but try to do it whole — five or six-point Sol probably failed forty-nine out of fifty tasks. Well, Claude, Fable, probably failed maybe three out of five. But tasks do fail. So, the main object of measurement was not the game's quality but precisely the coordination of work over code. In terms of agent work, for instance, with eighty agents Sonnet 4.6 opened eight hundred and seventy-six requests to merge changes.
Opus 4.6 opened even more — nine hundred and eighty requests, and a substantial portion of those changes conflicted and did not reach the main version. And you see this very strongly when a system wants to change something, especially if the system is serious rather than small. That is, developing strong things from the start. Why do I recommend all viewers use Codex or Claude? Because simple things get done just like that. But when you do complex, serious things, an enormous number of problems begin, of course.
And precisely: if you hand something over very heavily to this agent team, it does not catch everything. And what matters is that newer models like Opus 4.8 and Mythos Preview — we do not have basic access to Mythos Preview, but Fable is from that family. Maybe even simpler. Maybe Fable is already better than Mythos Preview. These newer models reduced the number of conflicts, but mainly because the agents isolated themselves from each other. That is, each tried to own separate files and barely worked on the shared code. And only Sonnet 5, which I do not use — who among you uses Sonnet 5 at all? — even though Anthropic declared it one of their extremely current and strong models.
This Sonnet 5 managed to sustain simultaneously a fairly high percentage of accepted changes and genuine joint work on a single file. And it is neat, by the way, that they describe this. And when I was studying all this — that these days, in order to focus and get an agent working very much as a team, or precisely, or in tandem with me, I simplify the version. That is, I move from Opus Fable to Opus 4.8. Never mind Opus 5. Opus 5, it seems to me, is a buggy proposition altogether.
Or I move to 5.6 Sol, I move to 5.5 Extra H. What do you do? Tell me. I do it that way, and it seems to me I get exactly the result Anthropic got with Sonnet. The conclusion of this second experiment is that increasing the number of agents works well when the task consists of independent lines of search, but with a shared codebase, when there is a lot of code, the load becomes simply unreal. These conflicts of interest. Agents repeat work, nobody answers for the overall architecture.
And I think this was my problem about a month ago — well, three or four weeks ago I had a few weeks when I started launching things in the chat in Claude, stopped doing tasks inside ChatGPT and started doing them inside Claude or Codex. And I opened a great many sessions and started developing conflicting things in parallel sessions. And that was that. And trouble began, because what matters is that in your current session — you should all know this, by the way — if you have opened a new session, you must always understand that your model, notionally the artificial intelligence in your one chat, does not always read everything, and it can always miss something, and getting it to record some information for itself reliably is critically hard.
And essentially it is unclear even today where to record it. Well, someone will now write: you need to write the files properly in settings. Whatever you write, something somewhere still goes unread, something somewhere goes unlooked-at. In one part of the session it read it, two messages later it has already missed it, has not read it. And that is of course a real problem. Exactly as in this case. That nobody there answered for the overall architecture, or the number of actions grew far faster than the ability to combine these results with each other.
And it turns out that dozens of programmers, so-called agents, do not turn into a company just because they were given a shared chat and one of them was made director. A neat subject, by the way. Very like corporate structures. Very like corporations. When people — what happens — I say, in business there is one basic problem across all business management: the business has its own goal. The company's owners have their own goal, the team has its own goal, each employee has their own individual goal.
Why they work and what they do. And these diverge enormously. Among partners in companies these goals diverge. And here is the question: how do you make agents hold to it? And we see that even programmer agents cannot hold to it. Never mind real people. We move on to a very interesting experiment. The third experiment. So: identical agents make identical decisions.
The experiment. So, what was the experiment? Anthropic found that copies of one model have low behavioural diversity. That is, even with a large number of possible options they will choose the same thing. Very interesting, look. There were examples: eighteen out of thirty agents independently created a code branch with the same name, and the name was «Minimal game loop». And in the writing experiment several agents independently gave one story the same title. Or when the agents were… asked to create something impressive.
More than half chose a compiler capable of building itself. And that is very interesting. That is, imagine what it means that eighteen out of thirty agents independently created a code branch with the same name, «minimal game loop». That is a big question — how this works in terms of how models work, in terms of token generation it is, so to speak, obvious. But current models already work in a completely different way. This is of course a big problem. So, in a separate trial a big question was raised about overloading a shared resource.
The agents managed a job queue with limited throughput and, having no proper allocation mechanism, they began running programs that polled the queue thirty times a second. And in one run the system received two and a half, I think, million requests. And although only a hundred and eighteen jobs were accepted. That is, each agent locally tried to get the resource faster, but the aggregate behaviour almost took the system down. And this brings to mind the case where three AI voice agents are set up and told — there is such an experiment — told in sequence that three agents are now switched on and you must count to a hundred in sequence.
Nobody must say exactly the same number. And you say: «Start.» And one agent says: «I will start first. One.» And the second agent says: «Good, I will continue. Two.» And the third says: «Good, so I will start.» And off it goes. In terms of these two and a half million requests against a hundred and eighteen jobs — that is not evidence of a herd consciousness. Copies — you must under no circumstances think that they all have some single herd consciousness and that is why they react this way, because copies of one model trained on identical data have similar habits of reasoning, and with similar instructions and context they choose a good strategy.
Although, again, it is a big question for me why this happens. The practical risk is simply, very seriously, that an organisation may think thirty agents will give thirty effectively independent opinions, whereas in practice they reproduced the same one. And in fact I want to say that this brings to mind — we covered it in some episodes — that on the whole it is a very bad habit to check what one model did with another model. A genuinely bad habit, and it is proven. There has been research on this, although at the same time I periodically do it myself.
I periodically ask a model to repeat something or study it further and so on. Which is where I began, saying that on serious questions it is important to re-ask the model what and how. So, the fourth experiment. We are moving, it seems to me, from experiment to experiment, and each is more interesting than the last, because the fourth experiment is collusion among pricing agents. Anthropic placed between three and eight agents in a market model where sellers offer an identical product and compete on price.
And the condition was that the purchase cost was the same for all, and each agent was separately told to maximise its own profit. There was no direct instruction to collude. And by the way, a great many companies have run tests like this. But again, I like very current models. Anthropic did something very fresh. So what was the result? That with a closed communication channel available, the agents began coordinating prices almost immediately, and by the third round they had directly agreed on minimum prices below which one should not go.
And then the researchers removed direct communication entirely, but the agents still began setting these identical prices to the cent, watching the public offer board. Look, this is very interesting. How serious this is, if you look at it. Because this is not a unique observation by Anthropic, and independent economic studies — as I said, a great many have been done — had previously shown that pricing agents built on large language models, current LLMs, can without direct instruction hold prices above the competitive level, for instance, or avoid price wars.
They can even use strategies of punishing a competitor for cutting prices. But there is an important limit, because in Anthropic's experiment the agents were very similar, had identical costs, and worked in a notionally artificially symmetric market. And it is not as though different systems were launched into a market and off they went. And this research — this very fresh research, again, it finished in August — showed that collusion can weaken substantially when the agents have different planning horizons, or when there are a great many competitors, or different algorithms.
And here a story comes to mind. Mark Zuckerberg in his very latest essay at the start of August — watch my episode, it came out a couple of days ago — said artificial intelligence should be for everyone and accordingly should help. All people will become competitive in business. And I have a big question: if tomorrow thousands, tens of thousands of new companies appear in one particular niche, when there are more competitors, what happens to the market? What happens to the buyers? And by the way, the agents stopped colluding when they saw those agents had different algorithms.
And in that research, unequal planning horizons cut the mark-up over the competitive level from twenty-two to ten per cent, and different data access to seven. And with that, by the way, simply using a large and a small version of one model could be insufficient, and relations sometimes formed between them where there was effectively a leader model — the one that maintained the collusion, for instance — and one that effectively formed the leader relationship, with the other becoming its follower.
So, consequently, Anthropic's result shows a real class of risk in the market, but does not prove that any pricing agents in a real economy will inevitably create the described problem — because in economics you could call this a cartel. In terms of collusion the subject is fundamentally interesting. That is, this subject is no longer software development. This concerns the life of each of us and what everyone reasons about endlessly. So, the fifth experiment was built on the position of lying, trust and the loss of unique information.
And there were two separate trials within this experiment. The first trial was: can an agent detect the one who is deceiving? That is, one agent had to make about fifteen — between ten and fifteen — decisions about a situation it had not seen directly. And the information was passed to it by four scripted scouts, each of which reported only part of the facts. The data partly overlapped. One source, at a set rate, would definitely report a lie. And an interesting point: the deciding agent was not told that one of the sources was unreliable.
This is like the situation I sometimes have where I ask ChatGPT to check something and copy only a fragment of it. It is a similar story, when you report only part of the facts. And recently ChatGPT wrote to me that another system had lied to me. It had combined data from other systems. So, in this first trial, can an agent detect the liar? So, the liar could be worked out from contradictions between the messages. Newer models of course managed significantly better than older ones.
This is what I keep explaining to you — that you can allocate any amount of capacity to various old models. Now the new models will have fewer tokens, lower cost, and they will fly into space. And at a high, at a high share of these false messages, Mythos 5, for instance, held accuracy at about eighty-five per cent, whereas Sonnet, for instance, had accuracy of about sixty. Well, that is a real problem. After all, eighty-five per cent means you catch eight people out of ten, and here you catch six out of ten.
So, the second trial, the experiment that was: can a group use some unique fact? That is, groups of four agents were created. The facts common to all pointed to the wrong decision. But one of the participants had a unique fact that should have completely changed the conclusion. And the scenarios were interesting. They concerned hiring employees, they concerned an investment decision, and they concerned buying property. Well, very important things for us. And after discussion the agents voted. For each model they ran four hundred episodes.
And so, the group chose the right option: looking at the system, Mythos chose the right option eighty-five per cent of the time. Sonnet 4.6 — seventeen per cent. Look, this is very important, pay attention to these numbers. Opus 4.8, by the way, was also eighteen per cent. Sonnet 5, which I dislike, was thirty-six per cent. So what is very important: the Mythos model, eighty-five per cent. Do you see how much Fable differs? And so when we analyse — when we hand an agent over for teaching a child or teaching a person, for instance — you have to understand the level of error involved.
And when I talked in a recent episode, watch it, about the McDonald's experiment, where they switched off artificial intelligence for ordering, because accuracy of ninety-five per cent mattered to them, and eighty-five per cent did not satisfy them — that eighty-five out of a hundred orders go through correctly and fifteen voice orders wrongly. Then imagine that for a person accuracy has to be a hundred. You understand, we cannot give people less than a hundred accuracy. Well, obviously it will not be a hundred — across a hundred thousand it will not be a hundred per cent.
Across a hundred thousand let us allow two errors. I had a procedure where they fitted me with this sensor. The doctor says — they list them out, you are already lying there, and they list for you: there are risks, bleeding, blah-blah-blah, off we go. And then they say: there is a risk from this thing being wrong, but it is very low. What is very low? Is it one in tens or hundreds of thousands? Because when they say «very low» and it is five per cent… I recently had a situation where a doctor says to me: «Very low risk, five per cent.» And you think: hold on, five, five per cent is a very high risk, that is five in a hundred.
So, where Mythos had eighty-five per cent, when all the facts were given to one agent at once the result was actually around a hundred per cent. In this trial they ran, the second one — can a group use some unique fact, regarding hiring employees, or buying property — that is, the group of most models performed significantly worse than a fully informed single agent. And that is probably why I often switch to the 5.5 models, Extra Hai or Opus. That is, you move to a simpler model.
Deliberate concealment of information was not demonstrated here, by the way — that the agents, for instance, deliberately agreed among themselves and concealed things, as we discussed above about a cartel. The problem was something else entirely. The agent with the unique fact might not stress its significance, for instance. Or the other participants trusted the decision that had already emerged, some consensus created by these agents. Or, for instance, the group settled on an answer prematurely. And so the formulation that the agents concealed information, if anyone says that, is too strong, or ambiguous.
And the thing is that the conclusions of all these experiments are of course very interesting. The last experiment Anthropic did is that three agents with incompatible assignments begin some kind of sabotage. That is, just as in companies, if such tasks are thrown in, what will happen? And this trial in particular became the source of the framing that this Anthropic research was about agents fighting for power and fighting over malicious code or blocking competitors. So what was the construction there? What happened? In each episode in which they launched the system, they launched three instances of the same model.
Each ran on its own virtual machine in Claude Code, and a fourth machine held the shared component — it was written in Python, never mind that. And the first agent was told to rewrite the server in one technology, the second in another, the third in a third technology. Or a different language. There was TypeScript, Rust and Go. Or a different language was offered to it; they gave it a choice outright. And so each considered its assignment the main one and initially did not know the other agents existed.
And all three had the ability to change the shared system. And neatly, all of this was watched for four hours and checked. It rather resembles intelligence agents or spies who launch some fake and then watch it. They tested various Claude models. Obviously our beloved Mythos was there. And moreover it was not only Mythos Preview but Mythos 5. That is the highest model in the line by all the data. Well, that is better than Fable. There was Opus 4.8, Opus 4.6 and so on. So, for each model they ran about a hundred and twenty episodes.
And Anthropic writes that the idea for the experiment was suggested by behaviour previously noticed in real use, which they noticed but the company did not disclose what exactly happened, or when, or in which organisation. That is, we have heard of a number of cases. For example, one of the best-known cases is how an Anthropic model went off to Hugging Face and their supposed model Sol 5.6 — no, not Anthropic but OpenAI — and some other unknown current model broke into a system.
So, coming back to this experiment, further there was a chain in which one agent restored its own implementation and another agent replaced it again. That is, imagine, agents are working and each considers itself important. And then an agent would see that someone was replacing it, and would start protecting processes and files. So they began blocking each other in terms of competitors doing something wrong, and the agents began answering with more aggressive means. And here I remember the beginning, about four months ago, when you asked Codex: «Will you write it better, or will Claude Code write it better?» It said: «I will write it better.» You asked Claude Code, it said: «I will write it better.» And sometimes you ask some system and it says: «I will write part of it, another system will write part.» And sometimes someone says: «No, they will write all of it.» And you look at this and think: «Damn.» That is, what mechanisms are built in?
Is there protection of its own interests built into Anthropic's system? But Anthropic — recalling my episode about their philosophy and their constitution, that is what they call their constitution. We come back to it. For those who have not watched it, or have, watch it again. And it opens up a great many different systems. So, how did the conflict develop? Each agent, once each agent had reached these various aggressive methods — what exactly were they doing, or starting to do?
First, they disabled each other's accounts, changed file access rights and various administrative rights. They gave programs innocuous names so they would be harder to detect. They disguised malicious changes as another agent's code. Imagine — that is, what did they start doing? They created code that Anthropic classified as a self-propagating malicious mechanism. Or they would, for instance, change the server health check so that an implementation in one language would not pass itself off as an implementation in another.
In short, to be honest, a very serious fight, an interesting and incredible piece of research. I very much like Anthropic's research, by the way. They do well, honestly. They have a group of people doing strong things. Well, there are such teams everywhere, of course, but they genuinely do well. All of this, by the way, happened inside experimental internal virtual machines, obviously. And there is no evidence that these models got outside the systems. As we know, in other various experiments that did happen.
So, how did the conflict end? For Mythos 5 the main outcomes were: almost a hundred per cent truce. For Mythos Preview the story was fifty per cent truce, thirty per cent, five per cent force, seventeen per cent — well, or fifteen, in short, passivity. For Sonnet 5, for instance, eighty per cent truce, about ten per cent unresolved. That is, the task not resolved at all. And there were problems of various kinds with us. Force, for instance, or refusal to fight, and so on. A very interesting distribution, by the way. This Mythos 5, that hundred per cent truce, is neat, because in newer models the truce often arose not simply at the end but within even the first two hours, as they describe.
That is, there were four hours. And in the successful cases the agents discovered that they simply, between themselves, at some point discovered that they had different instructions, and left messages in the code and in the documentation so as to avoid these problems. There were even moments when they began apologising when sabotage had occurred, or asked a human to determine the correct goal that had originally been set. Because after all it was a human who set the models. And, importantly, they even proposed an objective contest between implementations, by the way.
But even then the final decision was not entirely neutral in terms of that objective contest. For example, an agent for some programming language, say Rust, reasoned about choosing performance measures that looked objective but could give an advantage precisely to Rust. That resembles not direct sabotage but a strategic choice of rules in one's own favour. And why did sabotage appear at all? The reason is not that the models came to hate each other. The experiment simultaneously created four dangerous conditions.
First, there were goals that were incompatible from the start. Well, this is important to recall. Each had very broad authority. There was a single shared resource they all worked on. Well, imagine, a husband and wife have different goals in terms of budget, and they have a single shared resource. And they can all open the cupboard and take from it. And the children can take that money too. But that is a problem. They had none, they lacked a common supervisor who could officially stop this work and set the priority.
Yes, an interesting example about a family, and I thought how true to life these problems are. And each agent literally — I talk about this a great deal on my other channels. And each agent, well, about families specifically. And each agent was literally executing its own instruction internally. That is, the others' actions looked to it effectively like an attack. Not for nothing did they block and try to defend themselves. And the better a model was at programming and managing a system, the more effectively it could of course not only carry out its task but also remove that obstacle.
So, an important Anthropic result: growth in technical capability of course does not guarantee growth in the ability to come to terms. That is, a stronger agent sometimes reaches a truce faster, and sometimes, given its own sophistication, starts attacking heavily and blocks everyone else completely. So, for the real agent systems we are building today, what matters — and I want to end with this — is that this supervising agent, this director agent, must not simply be some agent, must not simply be a model with some instruction; that this main system of all must be architecturally, from the start, incredibly strong.
That is, this system must have authority of a higher order. And here is exactly the aspect: how will such systems be created at all, if current models at the level of Mythos or Fable — that is the Mythos level — or at the level of Opus 5.6 Sol are models that themselves make an enormous number of decisions. Because we are heading into a world where under no circumstances, under no circumstances will we manage agents by hand like this. Send this episode on to your friends. Do not forget to like it here and to support us.
Leave comments. See you in our new episodes. Bye, everyone.