> your AI agent picks dependencies from memory; give it dated facts — try starlog.dev ↗ vet your agent's deps ↗ vibe-coding is fine. vibe-importing isn’t. — try starlog.dev ↗ vibe-importing isn’t fine ↗ your agent has never seen your private packages — try starlog.dev ↗ facts for private packages ↗ a linter for the dependencies your AI agent picks — try starlog.dev ↗ a linter for agent deps ↗ whois is redacted, cdns mask the rest — get the real operator — try whoisgeni.us ↗ who really runs that domain ↗ domain attribution that shows its work — full evidence chain — try whoisgeni.us ↗ domain intel w/ evidence ↗

← Back to Articles

CoGames is Dead: What the Tombstone Reveals About Multi-Agent RL Architecture

[ View on GitHub ]

CoGames is Dead: What the Tombstone Reveals About Multi-Agent RL Architecture

Hook

When you pip install cogames today, you don't get a framework—you get a warning telling you it's been absorbed into something bigger. This isn't abandonment; it's strategic consolidation.

Context

Multi-agent reinforcement learning has a fragmentation problem. Unlike single-agent RL where OpenAI Gym became the de facto standard, multi-agent environments proliferated as independent projects—each with custom APIs, training loops, and configuration patterns. CoGames emerged as one such project: a collection of cooperative and competitive environments designed for RL research, complete with its own training infrastructure, policy modules, and CLI tooling.

But maintaining standalone frameworks is expensive. Every bug fix, API evolution, and dependency update multiplies across repositories. The CoGames maintainers made a controversial choice: kill the project and absorb it into Coworld/Mettagrid, a unified platform for multi-agent coordination. The repository now exists purely as a tombstone—a deprecation shim that fails fast with migration instructions. This isn't a failure story; it's a case study in technical debt management and ecosystem consolidation.

Technical Insight

Mettagrid Ecosystem

CoGames (Deprecated)

migrated

migrated

abandoned

abandoned

abandoned

cogames.core

Base Abstractions

cogames.game

Environment Implementations

cogames.variants

Parameterized Configs

cogames.policy

Training Infrastructure

cogames.cli

Orchestration Tools

coworld.cogames

Migrated Core & Games

Mettagrid

Unified Framework

System architecture — auto-generated

The original CoGames followed a three-layer architecture that's now visible only through the migration table left in the README. At its foundation was a core module providing base abstractions—likely environment interfaces, agent APIs, and coordination primitives. Above that sat a game module with concrete implementations (the environments themselves), and a variants module for parameterized configurations of those games. This separation suggests a classic inheritance hierarchy where specific games like cogs_vs_clips inherited from core abstractions.

What makes the deprecation interesting is what didn't migrate. The repository mentions abandoned CLI tools, policy modules, and embedded game configs. This reveals tight coupling: the training infrastructure wasn't generic enough to port to Coworld. If you'd installed CoGames six months ago, you might have written code like this:

# Hypothetical CoGames API (no longer functional)
from cogames.game import CogsVsClipsEnv
from cogames.policy import MultiAgentPPO
from cogames.cli import train_session

env = CogsVsClipsEnv(variant="competitive_2v2")
policy = MultiAgentPPO(num_agents=4, hidden_dim=256)
train_session(env, policy, episodes=10000)

Today, that import fails with a deprecation warning. The migration table tells you cogames.core moved to coworld.cogames, but there's no guidance for the policy or CLI modules—they simply don't exist in Coworld. This isn't an oversight; it's architectural philosophy. Coworld likely provides more generic RL abstractions rather than batteries-included training loops, forcing users to bring their own policy implementations (RLlib, Stable-Baselines3, etc.).

The mention of cogsguard SDK tooling is particularly revealing. Most academic RL frameworks focus purely on simulation, but a 'guard' component suggests production concerns: input validation, safety checks, or deployment orchestration for multi-agent systems running outside the lab. This implies CoGames had commercial or applied use cases, not just benchmarking. The fact that even this production-oriented component was deprecated indicates Mettagrid/Coworld provides superior abstractions—possibly framework-agnostic deployment tooling rather than CoGames-specific guards.

The tombstone itself is implemented as a PyPI shim that remains installable but non-functional. When you run pip install cogames, you get a package whose __init__.py likely looks like this:

# Actual implementation (inferred from deprecation behavior)
import warnings

warnings.warn(
    "CoGames has been deprecated and merged into Coworld/Mettagrid. "
    "See migration guide: https://github.com/softmax-universe/cogames",
    DeprecationWarning,
    stacklevel=2
)

# No functional code follows

This is deprecation done right: it doesn't silently break existing codebases or force immediate migrations, but it makes the path forward crystal clear. The stacklevel=2 parameter ensures the warning points to user code, not the library internals—a small detail that drastically improves developer experience during migrations.

What the architecture reveals most starkly is the cost of "batteries-included" frameworks. CoGames shipped with embedded game configs, specific environment implementations, and opinionated training infrastructure. When requirements changed—when the maintainers needed more flexibility or wanted to support environments beyond CoGames' original scope—that tight integration became a liability. Mettagrid represents a pivot toward modularity: provide environment definitions and coordination primitives, but let users compose their own training stacks. The fact that even established games like cogs_vs_clips had to be reimplemented rather than ported wholesale suggests the original abstractions leaked implementation details or made assumptions incompatible with the new platform.

Gotcha

The biggest limitation is obvious: this repository provides zero functional value. If your existing codebase imports cogames, you're facing a breaking change with incomplete migration documentation. The table tells you where core modules went, but if you relied on the policy training stack, CLI tools, or standalone game runners, you're on your own to find equivalents in Coworld—or rewrite using third-party RL libraries.

More subtly, there's no archived branch preserving the original implementation. If you published research citing specific CoGames versions, reproducing those results now requires hunting down old PyPI releases and hoping their dependencies still resolve. The repository doesn't tag historical versions or provide a "last working commit" reference. For academic reproducibility, this is a problem. The maintainers prioritized clean deprecation over historical preservation, which works for commercial projects but creates gaps for research infrastructure.

Verdict

Use if: You're researching the history of multi-agent RL tooling, studying deprecation strategies for open-source frameworks, or need to understand what CoGames was before deciding whether to migrate legacy code to Coworld. The tombstone and migration table are genuinely useful documentation for maintainers dealing with dead dependencies. Skip if: You need actual multi-agent RL environments—go directly to Coworld/Mettagrid if you want the spiritual successor, or use PettingZoo if you need stable, widely-adopted APIs. Don't waste time trying to resurrect CoGames when the maintainers themselves walked away. This repository's value is purely archaeological: it shows how framework consolidation works in practice and why tight coupling between environments and training infrastructure creates technical debt. If you're building your own RL framework, study this as a cautionary tale about premature integration.