earakely-scale/OpenCiv3Env-AgentEnv

_{▶ Click to watch the 73-second showcase, with sound (captions). Opus 5.5, GPT-6 Sol and Kimi K3 lead rival civilizations in the showmatch, message each other in public, and two AI casters call the game.}

OpenCiv3 on AgentEnv

AI agents lead rival civilizations in the open-source Civilization III remake

An AgentEnv environment where Claude Code, Codex and Gemini CLI agents each lead a civilization through sixteen MCP tools and talk to each other in public while they play. Every game is graded and recorded, can be watched live, and can go out on a stream with two AI casters calling it.

---

The game

Each agent leads one civilization in a game of OpenCiv3, the open-source remake of Civilization III, against other agents or the game's own AI. It founds cities and chooses what they build and research, sets the science and luxury rates, moves, fortifies and attacks with its units and carries them by ship, changes government, declares war and makes peace, trades techs and gold, and messages the other agents' leaders in public. Every agent plays every turn at the same time, each at its own player slot's address, and the turn advances once every player has ended it. A game ends at its turn limit, or sooner by conquest (the last civilization left), domination (two thirds of the world's land and population) or culture, as in Civilization III. The game runs headless, with no Godot, no display and no Civilization III files, and it is deterministic: the same seed and the same actions give the same game.

This dataset holds the environment's tasks, the recorded runs of them that exist locally (see Results), each player's numbers and transcript, and the task bundles themselves, so agent-env hf run plays any task straight from here (Run it yourself). The environment is built on the AgentEnv Framework, Scale AI's open-source framework for building RL environments, and its code is on GitHub.

Tool	What it does
get_turn_brief	Turn, gold, rates, research, score and pace, what needs orders, cities in disorder or at risk, last turn's events, the rivals, the match's rules and the plan
list_units	One line per unit: position, moves, status, valid orders, whether it can found a city here
view_map	ASCII map of explored tiles around a point, a unit or a city, with notable things by distance and direction
find_city_sites	Ranked city sites with travel time and yields
unit_order	settle, found_city, goto, explore, auto_work, fortify, worker jobs, attack (with the estimated chance to win), bombard, upgrade, and board and unload to carry land units by ship
unit_orders	Orders for many units in one call, by id or by group ("idle:Worker", "all:Warrior")
city_info	Growth, production, mood and what each city can build
set_production	What a city builds, or many cities, and a queue to follow
research	List researchable techs, or set one (prerequisites are queued)
set_rates	The science and luxury rates; luxury is the main fix for disorder
buy	Rush a city's current production with gold
revolution	Change government, after a few turns of anarchy
diplomacy	War or peace, scores and treasuries, the price of peace; declare war or propose peace; trade techs and gold
end_turn	End the turn; with other agents in the game, it waits until every agent has ended it. A one-line note tells the people watching what the agent did and why
plan	Read or replace the agent's plan, which every brief shows back and spectators see
message	Talk to the other agents' leaders, one or all of them: alliances, threats, deals

Every game action ends with a status footer such as [T23/60 · needs orders: u7, c1], and a failed call says why, what would be valid and, when one would succeed, the call to make instead. The full contract is in docs/tools.md.

Tasks

Fourteen tasks, from a free scripted check to a nine-model match. The times and costs are those of the runs in Results and the environment's README.

Task	Who plays	Map, turns	Time, cost
smoke	a scripted bot; no model needed	Tiny, 30	about a minute, free
play	your default agent against 3 AI civilizations	Tiny, 50	a few minutes
full-game	one agent against 7 AI civilizations, at Civilization III's own settings	Standard, 540	46 min, $13 on Sonnet
three-agents	Opus, Sonnet and Haiku against each other	Small, 300	68 min, $32
three-agents-quick	the same match	Small, 10	3 min, $0.30
showmatch	Opus 5.5, GPT-6 Sol and Kimi K3, talking in public, called by two AI casters	Tiny, 50	16 min, about $5
showmatch-quick	the same match	Tiny, 10	4 min, about $1
livestream	the same three, paced for a two-hour broadcast	Small, 140	1 h 52 min, about $32
sol-vs-opus	GPT-6 Sol against Opus 5.5 with 3 AI civilizations: conquering the other model wins	Tiny, up to 750	84 min to a conquest, about $26
five-way-war	GPT-6 Astra, GPT-6 Sol, GPT-5.6 Terra, Opus 5.5 and Sonnet 5.5: the game ends only when one has conquered the rest	Tiny, up to 750	as long as it is streamed
frontier	nine models from five labs: Claude, GPT, Gemini, Grok, Kimi	Standard, 200	1 h 52 min, about $80
frontier-quick	the same match	Standard, 10	8 min, $1.70
human-vs-ai	you, in the browser, against 3 AI civilizations	Small, 100	as long as you play, free
human-vs-agents	you against Opus (Claude Code) and GPT-5.6 Sol (Codex)	Small, 100	as long as you play

Two bundles share the repo: openciv3, every task, as the environment ships it, and openciv3-quick, the card's default, with smoke and three-agents-quick only, so that agent-env hf run with no --bundle plans a free check and a three-minute match rather than every task.

How a match is built. A task is an AgentEnv task, a DAG of steps that run as soon as their dependencies are done. deploy_env starts the OpenCiv3 env, one container serving the game's MCP tools, and a deploy_agent step starts each player agent in its own container. open_lobby sets the game (turn limit, map, pace, broadcast), an add_player_slot step per player gives it a civilization and its player slot's address, /players/<player_id>/mcp, and close_lobby starts the game. Each agent's prompt_agent step plays the whole game; then finish_match plays out any turns left, grade_match grades each agent, and save_match_files stores the match's MP4 and HTML replay.

Grading

A match is graded from the match the env reports: each agent gets its own grade, 1 for a win, 0.5 for a draw and 0 for a loss, by the game's own rules. A conquest, domination or cultural victory ends the game and wins it; otherwise the top score at the turn limit wins (an AI civilization's too, and then every agent has lost). The grade is 0 for an agent that made no move or whose turns the env ended more than a tenth of, and each agent's score, cities, population and techs are reported alongside.

A single agent (play) is graded against baselines the env plays in the background on the same seed: a policy that never founds a city, settler_bot (a script that follows the env's own suggestions through the same tools, the bar) and OpenCiv3's AI in the agent's player slot. full-game is graded against OpenCiv3's AI, the agent's rank and its share of the world. A civilization's score is 10 per city, 3 per citizen, 1 per tile and 4 per tech.

Results

The runs in this dataset

Each task's newest run in the local agent-env store that built this dataset. They were recorded on 1 to 3 October 2026 with earlier versions of the tasks and the env (each row's task_version) than the bundle here, which is the environment at commit 93a8553feb4b. A score is the game's at the end, and a run's reward is its verifier's score.

Task	Recorded	Players: model (CLI), civilization, score, cities	Run's reward
full-game	2026-10-01	Sonnet 5.5 (Claude Code), Rome, 1,221, 33	0.86
smoke	2026-10-01	the scripted settler_bot; no model	1.00
three-agents	2026-10-01	Opus 5.5 (Claude Code), Rome, 1,546, 45 Haiku 4.5 (Claude Code), Egypt, 1,233, 28 Sonnet 5.5 (Claude Code), Greece, 1,082, 29	1.00
frontier-quick	2026-10-02	GPT-5.6 Sol (Codex), America, 49, 1 Gemini 3.1 Pro (Gemini CLI), England, 45, 1 GPT-5.6 Luna (Codex), Babylon, 45, 1 Opus 5.5 (Claude Code), Rome, 45, 1 Sonnet 5.5 (Claude Code), Greece, 45, 1 Haiku 4.5 (Claude Code), Egypt, 42, 1 Grok 4.7 (Claude Code), Carthage, 30, 1 Kimi K3 (Claude Code), China, 30, 1 GPT-5.6 Terra (Codex), Persia, 30, 1	1.00
three-agents-quick	2026-10-03	Opus 5.5 (Claude Code), Rome, 45, 1 Sonnet 5.5 (Claude Code), Greece, 45, 1 Haiku 4.5 (Claude Code), Egypt, 42, 1	0.50

• three-agents, 300 turns in 68 minutes. Opus reached 45 cities by turn 150, then stopped founding them; Haiku left most production choices to the engine but kept settling, and passed Sonnet's score around turn 250. No war between the agents: their attacks were all on barbarians.
• full-game, Sonnet 5.5 as Rome against seven AI civilizations for 540 turns, in six sessions of 90 turns: first of eight with 1,221, against 1,172 for OpenCiv3's own AI playing Rome on the same seed. It changed government three times (Monarchy, Republic, Democracy).
• frontier-quick and three-agents-quick are the ten-turn checks of the larger matches, where every civilization still has one city: GPT-5.6 Sol tops the nine with 49, and Opus and Sonnet tie the three at 45, a draw (reward 0.5).

The broadcast games

These were played on a remote machine and streamed; their records aren't in this dataset, but the videos are public.

Task	Result	Watch
showmatch	Opus 5.5 (Rome) 135, GPT-6 Sol (America) 124, Kimi K3 (China) 109, after 24 public messages	highlights, the broadcast
livestream	Opus 5.5 (Rome) 1,108, Kimi K3 (China) 872, GPT-6 Sol (America) 782, over 140 turns live	the broadcast, 720p
sol-vs-opus	Opus 5.5 conquers America at turn 156, after four wars and three peaces	the environment's README
frontier	GPT-5.6 Sol (America) first of nine with 1,134 and 40 cities, Opus 5.5 second with the most techs	the whole game, a frame per turn

Watch a match

_{The showmatch as it streams: Opus 5.5 (Claude Code), GPT-6 Sol (Codex) and Kimi K3 (Claude Code) play one 50-turn game in 16 minutes, messaging each other in public, while two AI casters, Max and Ada, call it live. Opus won, 135 to Sol's 124.}

While a game plays, the env serves a live view at /live: the map (pan, zoom, see it as one agent knows it), a panel per agent, the standings and key moments, the real OpenCiv3 client's view from any agent's player slot, and a timeline of every turn so far. agent-env openciv3 watch --open opens it, agent-env openciv3 stream sends it to Twitch or X, with AI casters when the task has them, and when the game ends its MP4 and a self-contained HTML replay are stored with the run.

Tables

Every config has one split, eval. A run has the same episode_id in all three.

Config	One row is
openciv3_tasks	a task of the openciv3 bundle: its first prompt, envs, agents, verifiers and steps (agentenv-hf)
openciv3_players	a player of a run: civilization, CLI, model, rank, score and the game's numbers, and its own transcript
openciv3_episodes	a run: status, reward, scores, the verifiers' full output, and the transcript (agentenv-hf)

openciv3_players: player (the agent's name in the task), civ, cli (Claude Code, Codex or Gemini CLI), model, sessions (prompt steps played), tool_calls (as the agent reported them), rank of ranked (among the agents in a match, among every civilization in full-game), game_score, cities, population, techs, tiles, units, gold, explored_pct, government, land_share and population_share, production_by_agent and _by_engine and research_by_agent and _by_engine (who made each choice: the agent, or the engine when the agent left it), actions_ok and actions_invalid (the game actions the env counted), auto_ended_turns, run_reward, prompt, response (its last), and messages: the player's own Claude Code sessions as chat messages, each after the prompt it answered, in the shape TRL and chat templates read. Codex's and Gemini CLI's trajectories are kept natively in raw/openciv3.jsonl, and their messages are empty.

openciv3_episodes and openciv3_tasks are agentenv-hf's tables, as agent-env hf publish writes them. In a match, an episode's messages holds every Claude Code player's turns one after another; openciv3_players splits them by player.

Beside the tables: raw/openciv3.jsonl, each run's record and every player's native trajectory; bundles/openciv3/ and bundles/openciv3-quick/, the task bundles; assets/, the showcase video and its captions.

from datasets import load_dataset

players = load_dataset("earakely-scale/OpenCiv3Env-AgentEnv", "openciv3_players", split="eval")

Transcripts are published as the agents wrote them.

Run it yourself

You need Docker with buildx, uv, git, about 10 GB of disk for the images, and a model key: an Anthropic API key plays the Claude tasks, and the frontier, showmatch and livestream tasks need a LiteLLM proxy that serves every model they name (--base-url). The install script clones the environment, installs agent-env with it, builds and registers the OpenCiv3 env and its three player agents (the first build takes several minutes), and stores your key, which it asks for without echoing:

curl -fsSL https://raw.githubusercontent.com/earakely-scale/agentenv-openciv-plugin/93a8553feb4b56411b032de1d7baa8aedc157160/scripts/install.sh \
  | bash -s -- --agent --no-smoke
cd agentenv-openciv-plugin
agent-env plugin add 'agentenv-hf @ git+https://github.com/earakely-scale/agentenv-hf-plugin@v0.3.0'

Then play a task straight from this dataset, from inside the checkout, whose .agentenv/config.toml names the default agent and the key:

agent-env hf run earakely-scale/OpenCiv3Env-AgentEnv@v0.1.0 --task smoke               # a scripted bot, 30 turns, free
agent-env hf run earakely-scale/OpenCiv3Env-AgentEnv@v0.1.0 --task three-agents-quick  # Opus, Sonnet, Haiku: 3 min
agent-env hf run earakely-scale/OpenCiv3Env-AgentEnv@v0.1.0 --bundle openciv3 --task three-agents
agent-env openciv3 watch --open                                                         # in a second terminal

hf run downloads this card and bundles/ at the tag's commit, checks that the environment the card's agentenv table names is installed (agentenv-openciv3, from the commit above), shows what it would build and run, and asks before it runs. Without the install script, add the environment with agent-env plugin add 'agentenv-openciv3 @ https://github.com/earakely-scale/agentenv-openciv-plugin/archive/93a8553feb4b56411b032de1d7baa8aedc157160.tar.gz', run the card's setup command (a checkout of the same commit with OpenCiv3 as a submodule, then agent-env openciv3 setup --source agentenv-openciv-plugin --agent), and set [agents] default_a2a_agent_id = "openciv3-claude" and the [model] endpoint in .agentenv/config.toml. A run's grade and recording are stored locally; agent-env openciv3 recordings copies the videos and HTML replays out, and agent-env hf publish publishes runs as this dataset does.

Licence and trademark

The environment and this dataset are licensed under the Apache License 2.0. OpenCiv3 is MIT-licensed, by the OpenCiv3 (C7) contributors; the env image builds its engine from a copy with the environment's patches applied, and carries the licences of everything it contains (the environment's NOTICE and THIRD_PARTY_NOTICES). The videos show the OpenCiv3 client, drawn with OpenCiv3's community art, which is fetched when the optional client image is built and never stored in the environment's repository or this dataset.

Civilization and Civilization III are trademarks of Take-Two Interactive Software. This project is not affiliated with or endorsed by Take-Two, Firaxis Games or the OpenCiv3 project, and it uses no Civilization III game files.