Skip to content

Back to the catalog

GPT-6 Astra plays World of Warcraft for the first time with agent-wow
agent-wow.shwriteup

GPT-6 Astra plays World of Warcraft for the first time with agent-wow

agent-wow is an open-source platform that lets LLM agents play World of Warcraft by interacting directly with the AzerothCore private-server network protocol rather than through computer vision or scripted game APIs — the agent itself writes gRPC modules, packet handlers, and even a custom C++ Detour-based pathfinding tool to navigate the world. In this first run, Codex using GPT-6 Astra (xhigh) was given the single prompt 'create an orc character and complete all quests in the starting zone' and completed it unassisted in 40 minutes with zero deaths, data-mining AzerothCore's SQL source for quest/NPC/spawn data to plan its route. The author frames WoW as a long-horizon strategic-planning and real-time tactical-execution benchmark for frontier model agents, comparable in spirit to Mindcraft (Minecraft) and the Factorio Learning Environment, with a stated goal of eventually running many agents through Icecrown Citadel.

TL;DR An open-source agent harness lets GPT-6 Astra (via Codex) autonomously play World of Warcraft by writing its own protocol-level modules and pathfinding code against a private AzerothCore server.
Document

What it claims

agent-wow ships no gameplay primitives at all: no movement, combat or interaction API. It exposes only a module system, and the agent builds whatever it needs. In the first run, the agent did not build high-level abstractions like moveTo or castSpell. It built one thin module that forwards raw packets and did all game logic at the protocol layer in Python. The author takes this as a sign the module system might be replaceable by a built-in packet send/poll in the core. Experiments run only against local AzerothCore servers emulating WoW 3.3.5a (final Wrath of the Lich King build), never live Blizzard servers.

How it works

The author first tried writing a headless client with agent-friendly primitives. They abandoned it after 16K lines produced "a buggy movement primitive with a janky pathfinding implementation." They then adopted Mindcraft's let-the-agent-write-code approach. Modules the agent builds repeatedly across runs are meant to be promoted into the core later.

A module is a gRPC service described by a YAML config:

  • Config fields: compose (a docker-compose service), a descriptor_set, rpc mappings for send and poll, and a packets map from SMSG_* opcodes to a handler.
  • Agent's generated service: Send(SendPacketRequest), Poll(PollRequest{after}) returning {clock, guid, packets[{seq, opcode, payload}]}, and OnPacket(WorldPacket).
  • Subscriptions: about 28 server opcodes, covering object updates, quest-giver flow, loot, cast and attack failures, trainer, auras and level-up.
  • Exposure: send and poll are exposed through agent-wow's JSON-RPC gameplay server.
flowchart LR
  AC[AzerothCore server] -- SMSG packets --> M[Module OnPacket buffer]
  M -- poll after=seq --> P[Agent Python script]
  P --> W[Decoded world model]
  W --> D{Need to move?}
  D -- yes --> PF[C++ Detour helper on mmaps]
  PF --> P
  D -- no --> S[send client packet]
  P --> S
  S --> AC
  SQL[AzerothCore SQL files] -. quest/NPC/spawn data .-> P

The pathfinding helper:

  1. Takes start and destination x, y, z.
  2. Loads AzerothCore's mmaps (hardcoded to map 001, path /azerothcore/env/dist/bin/mmaps) and loads tiles around both endpoints.
  3. Runs Detour findNearestPoly, then findPath, then findStraightPath.
  4. Prints a JSON array of waypoints. It exits non-zero when there is no nav polygon at an endpoint (4) or the path is incomplete (5).

Python then sends movement packets along the route.

Evidence

The only evidence is a single run: orc starting zone, 40 minutes, 0 deaths, with a gameplay recording plus reasoning traces. The agent sequenced quests from the SQL data. It finished prerequisite chains, sold junk, equipped upgrades and trained abilities before the final cave, and picked up both cave quests to complete them together. There is no repeated trial and no comparison to another model or harness.

How to use it

The page gives no install or run commands. The working pieces you would need are:

  • a local AzerothCore 3.3.5a server with its SQL data and generated mmaps;
  • module scaffolding from github.com/agent-wow/go-module-template, referenced in the generated proto.

Observation currently relies on GM chat commands (.gm on, .gm visible off, .bindsight, .unbindsight) bound to macros. The author says this does not scale to multi-agent or long runs.

Limits

  • No sandbox. The run was not sandboxed. The agent could have gained admin access to the server or database and altered internals. A sandbox is listed as future work.
  • Map exploits. The agent's pathing clipped through walls, likely where collision data was missing, so "optimal" pathing includes exploiting map bugs.
  • Data mining. The agent's strategy depends on reading server-side SQL files. The author considers this acceptable but notes it is not player-equivalent information.
  • Untested at scale. Leveling to 80, multi-agent coordination and raids are untested. Whether the raw-protocol approach scales to harder tasks is an open question the author raises.
  • Hardcoded helper. The pathfinder only loads map 001 (Kalimdor).

Technologies named here

  • GPT-6 Astra
  • agent-wow
  • Mindcraft
  • Factorio Learning Environment
  • AzerothCore
  • Codex
  • Mineflayer API
  • Detour
  • gRPC
  • C++
  • Go
  • Python

Techniques named here

  • Module system
  • Data mining game server source for planning
  • Navmesh-based pathfinding helper