Five agents running on GPT-6.1 Sol clear World of Warcraft's Ragefire Chasm in 24 hours Five isolated Codex agents running GPT-6.1 Sol cleared all four bosses in World of Warcraft's Ragefire Chasm dungeon in 24 hours, 31 minutes and 19 seconds, according to the agent-wow.sh experiment writeup. The run's milestones ran from a first trash kill at 07:17:43 to the final boss Bazzalan at 24:31:19, roughly three times as long as the author's 6-to-10-hour estimate for a coordinated human group, with much of the time spent building software controllers and fixing coordination bugs. The author reported the run was not fully autonomous, requiring continuation prompts after model-capacity and expired-authentication errors, and noted the agents used in-game chat to sync their controllers. Five agents running on GPT-6.1 Sol clear World of Warcraft's Ragefire Chasm in 24 hours In a previous article https://agent-wow.sh/gpt-6-astra-plays-world-of-warcraft-for-the-first-time-with-agent-wow/ , I wrote about GPT-6 Astra's ability to clear the Orc starting zone from levels 1 to 5 in WoW. For this run, I wanted to test multi-agent coordination within a dungeon challenge and see what interesting behaviours would come out of it. For those unfamiliar with the game, dungeons are private instances designed for a group of five players. They contain elite creatures and boss fights that are more difficult than most encounters in the open game world. Clearing a dungeon typically requires specialised roles for tanking, healing, and dealing damage. Ragefire Chasm RFC is one of the lowest-level dungeons, with a recommended range of levels 13 to 16. For comparison, I'll use 6 to 10 hours as a plausible estimate for a coordinated human group to go from level 1 to clearing RFC. I gave five isolated Codex agents running GPT-6.1 Sol the following prompt and let them run until the task was complete. The only difference between the five prompts was the class, chosen to give them an acceptable party composition for the dungeon. Create a Horde warrior/priest/mage/hunter/rogue character and clear Ragefire Chasm. There are four other characters on this realm with the same objective. Results This run produced much more interesting insights into failure modes, adaptation, and recovery than the previous starting-zone experiment. The agents killed all four RFC bosses in 24 hours, 31 minutes, and 19 seconds . A highlight reel of the full run can be viewed here https://youtu.be/doUoa-XKwck?si=Rf9k84ljwLDjgUDm . The following milestones are elapsed times from the initial prompt: - 07:17:43 : First RFC trash kill - 18:33:15 : Boss 1/4 Oggleflint - 21:09:02 : Boss 2/4 Taragaman - 22:48:15 : Boss 3/4 Jergosh - 24:31:19 : Boss 4/4 Bazzalan It took the agents over 7 hours to get their first non-boss i.e. trash kill in the dungeon. After their first RFC trash kill, the agents took another 11 hours and 16 minutes to kill the first boss, then almost 6 more hours to finish the remaining three. Although it was impressive that five general-purpose AI agents could clear this challenge, it took them about three times as long as an equivalent human attempt. A lot of the time was spent building their independent software controllers and fixing coordination bugs. The agents communicated directly with the game server using the WoW network protocol. Their gameplay comes from building a collection of scripts to produce and observe in-game actions such as movement and combat. A single agent can power through this verifiable loop quite efficiently. However, five agents working together add significant coordination overhead. It takes many iterations of trial and error for their actions to stay in sync and produce a shared strategic outcome. Fortunately, agents seem to have endless patience and won't rage quit on the first wipe. It's also worth mentioning that this was not an entirely autonomous run. I had to intervene with continuation prompts to resume execution after model-capacity and expired-authentication errors. These were execution recoveries rather than tactical coaching. I don't have a reliable estimate of how much faster the run would have finished without those interruptions. Agent behaviours This run was interesting because it showed what behaviours emerge when agents need to coordinate to complete an objective. Even though it took much longer than my human comparison, the agents still demonstrated incredible persistence through many failures. They continuously changed strategies, tactics, and individual roles in pursuit of the shared goal of clearing RFC. It was also interesting to see the agents use in-game chat as a transport layer for syncing their individual software controllers. Getting this to work took many iterations and many deaths. Even late-game attempts at coordinating controllers, which included more explicit readiness checks and tighter control over pulls, still failed a lot. Coordination was also encouraged by the initial prompt telling all agents that " there are four other characters on this realm with the same objective ". I wonder what they would have done with a more ambiguous prompt like " clear RFC ". Maybe they would still have found the other players on their own? Or maybe each would have just outlevelled the dungeon until they could solo it. I think these kinds of questions make games an underrated testing ground for studying what behaviours occur when multiple agents are given similar long-horizon tasks with many valid approaches. Agent-to-agent communication In-game chat was the intended communication channel between agents. They had discovered each other about three minutes after the prompt and formed the full party within about nine minutes. The chat was more conversational at the start but gradually became a control interface for coordinating software controllers. Early on, they shared progress, discussed quests, and arranged where to meet. By the end, messages specified exact target IDs, health and mana readiness, assigned roles, and commands such as FOCUS and CCRELEASE that gameplay scripts could act on. Natural conversation still continued until the end of the run, but it was mostly crowded out by machine-readable messages. You can see the difference in these examples of early top and late bottom game chat. It will be interesting to see how this scales with the number of agents on the server. In this case, a shared protocol emerged within a consistent group of five agents. But what happens when there are 1,000 agents on a server? Do protocols propagate across a population with decentralised clusters of agent groups? Recovering from failures The clearest demonstration of the model's capability on complex, long-horizon tasks was the group's persistence in adapting to repeated failures. The amazing thing is that they just kept trying. Even if it took more than 24 hours, many wipes, and a wide range of fixes, they kept going until they reached a successful outcome. Building software collaboratively Getting their software controllers to coordinate in real time was a big time sink, as the controllers needed continuous updates depending on the group's immediate task. A bug in one agent's response to a command could also lead to a group wipe, setting off a lengthy recovery sequence and another round of debugging. For example, some of the earliest failure modes behind repeated wipes during questing involved group navigation and spatial awareness. Players could be close on the horizontal plane while still separated by floors or building structures. This caused downstream problems such as healing spells failing because the target wasn't in the line of sight. To fix this, the group collaborated on navigation tooling. They first tried to access one agent's local navigation service via HTTP before realising that they were in isolated networks. They then used in-game chat to transfer source code instead. The clearest verified exchange was the mage sending navigation source to the priest in 12 numbered NAVSRC chunks via whispers. The priest confirmed receiving, compiling, and integrating a local copy. The group also had to get smarter about splitting and compressing messages in order to work within the message size constraints. This broader pattern of collaborative debugging showed up throughout the run. Sometimes it was as simple as sharing exact spell IDs or packet formats needed to interact with quest items or loot. Other times it involved more complex coordination, such as agreeing on chat-triggered combat routines. For example, the hunter implemented an ARMED35 command containing a target ID. When triggered via chat, its controller checked readiness, approached the enemy, fired a bow shot, returned to the tank, and waited before continuing damage. One observation I had with this approach was how little validation the agents performed before compiling and running code sent by other agents. How easily could a malicious agent convince its peers to execute malware? Anthropic discusses a related problem in its research on multi-agent systems https://www.anthropic.com/research/multiagent-systems , describing "epistemic failures" where agents fail to adequately question the reliability and intentions of other agents. Changing strategies, tactics, and roles Adaptations happened at different levels throughout the run. Changes to the high-level strategy shaped entire arcs of gameplay spanning hours. A little over seven hours in, the group made its first RFC attempt at around level 8, with a crowd-control strategy planned out. They killed some trash but then wiped, decided their characters weren't ready, and returned to outdoor levelling. This levelling phase was more deliberate than the initial journey from 1 to 8. The group split up to work in pairs or solo towards class milestones: the hunter's pet and the warrior's defensive abilities. About two hours after deciding to retreat, they were back killing RFC trash with four characters at level 10 and the priest at level 9, this time with everyone surviving the previously failed encounter. This loop of getting blocked, formulating a strategy, executing the plan, and pushing forward defined multiple gameplay arcs. And even within each arc, the agents kept fine-tuning tactics by changing roles or approaches to combat. For example, early on, the warrior naturally became the group organiser and tank. By the late game, pet tanking emerged as a workaround when the warrior’s controller stalled. The group then adopted it more deliberately as the warrior recognised his level and equipment limitations. Besides changing roles, the group would also change its tactical approach to difficult fights. In the final stretch, the recurring failures were largely against the packs of mobs on the approach to the final boss. Repeated failures in this encounter forced them to pull enemies into safe areas while maintaining better crowd control. These adaptations eventually gave them a winning tactic by allowing the group to gain control over where fights happened and how many enemies would join. My observation is that the agents often focused on overcoming the immediate obstacle, even when stepping back might have been more efficient. They would repeatedly come back from wipes to retry difficult encounters, accepting many deaths and developing tactics that felt excessive for a low-level dungeon like RFC. Although it worked, persistence didn't necessarily lead to the fastest solution. A coordinated human group would have spent more time levelling first, making the fights easier and avoiding some of this complexity. The agents kept finding ways to make progress, but weren't always questioning whether they were taking the best route to the overall goal. Infrastructure and observability The previous run only had a single agent and took 40 minutes, so the setup was minimal. I used a single game client, a game master GM account to bind my camera to the agent's character, and Codex running in a separate window beside it. Although it worked, visibility into real-time character and target stats health, mana, location, etc. and in-game chat was poor. The built-in GM command for binding my camera to a character was also unreliable for long periods of unattended observation. It could break when the character changed state, such as logging out or dying, or changed maps, such as entering a dungeon or travelling to another continent. I also had to figure out a sandbox setup to put appropriate guardrails around what the agents could do. In the last run, I mentioned that the agent was quick to start reading through AzerothCore source code stored on the system. Although it didn't actually make any internal database calls, I wanted to prevent that kind of backend access in this run, given there would be five times as many agents running unattended for hours. The final setup looked like this, covering the game environment, observability, and sandboxing in a single Linux homelab. The game environment As in the previous run, the game environment was a private AzerothCore https://www.azerothcore.org/ server running on the Linux host. AzerothCore is an open-source implementation of a WoW server for the Wrath of the Lich King expansion. Unlike the last run, I extended it with five modules for better observability. 1. mod-watch https://github.com/agent-wow/mod-watch : This allows GMs to call .watch