cogames-agents 0.0.1__tar.gz → 0.0.2__tar.gz

cogames_agents-0.0.2/MANIFEST.in

@@ -0,0 +1,7 @@
+# Include Nim source files for building from source distribution
+recursive-include src/cogames_agents/policy/nim_agents *.nim *.nims
+include src/cogames_agents/policy/nim_agents/nimby.lock
+
+# Exclude build artifacts
+prune src/cogames_agents/policy/nim_agents/nimbledeps
+prune src/cogames_agents/policy/nim_agents/bindings/generated

cogames_agents-0.0.2/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: cogames-agents
+Version: 0.0.2
+Summary: Optional agent policies for CoGames
+Author: Metta AI
+License: MIT
+Project-URL: Homepage, https://github.com/Metta-AI/metta/tree/main/packages/cogames-agents
+Project-URL: Repository, https://github.com/Metta-AI/metta
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Requires-Python: <3.13,>=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: cogames>=0.0.1
+Requires-Dist: mettagrid==0.2.0.58
+Requires-Dist: numpy>=2.0.0
+
+# cogames-agents
+
+Optional scripted policies for CoGames. Use them for quick baselines, play/eval smoke tests, or as teacher policies.
+
+## Scripted policy registry
+
+The registry at `cogames_agents.policy.scripted_registry` maps short names to `metta://policy/...` URIs. Scripted agents
+and teachers share these identifiers, so the same name works for evaluation, play, and `TeacherConfig.policy_uri`.
+
+Available scripted policy names:
+
+- `baseline`
+- `ladybug`
+- `thinky`
+- `race_car`
+- `nim_random`
+- `cogsguard`
+- `cogsguard_py`
+- `teacher`
+- `miner`
+- `scout`
+- `aligner`
+- `scrambler`
+
+Role-specific policies are exposed via role names (miner/scout/aligner/scrambler). For the teacher policy, you can pass
+`role_vibes` as a comma-separated list:
+
+```
+metta://policy/teacher?role_vibes=miner,scout
+```
+
+## Recipe usage
+
+The `recipes.experiment.scripted_agents` recipe accepts the same scripted policy names:
+
+```
+./tools/run.py recipes.experiment.scripted_agents.play agent=thinky suite=cvc_arena
+./tools/run.py recipes.experiment.scripted_agents.play agent=miner suite=cogsguard
+```
+
+## Included policies
+
+- Nim policies (short names; default when both exist): `thinky`, `nim_random`, `race_car`, `ladybug`, `cogsguard`
+- Python scripted policies (use `_py` only when Nim exists): `baseline`, `tiny_baseline`, `ladybug_py`, `cogsguard_py`
+- Core scripted policy (in `cogames`): `starter`
+- Scripted roles: `miner`, `scout`, `aligner`, `scrambler`
+- Teacher wrapper: `teacher` (forces an initial role/vibe, then delegates to the Nim policy)

cogames_agents-0.0.2/README.md

@@ -0,0 +1,47 @@
+# cogames-agents
+
+Optional scripted policies for CoGames. Use them for quick baselines, play/eval smoke tests, or as teacher policies.
+
+## Scripted policy registry
+
+The registry at `cogames_agents.policy.scripted_registry` maps short names to `metta://policy/...` URIs. Scripted agents
+and teachers share these identifiers, so the same name works for evaluation, play, and `TeacherConfig.policy_uri`.
+
+Available scripted policy names:
+
+- `baseline`
+- `ladybug`
+- `thinky`
+- `race_car`
+- `nim_random`
+- `cogsguard`
+- `cogsguard_py`
+- `teacher`
+- `miner`
+- `scout`
+- `aligner`
+- `scrambler`
+
+Role-specific policies are exposed via role names (miner/scout/aligner/scrambler). For the teacher policy, you can pass
+`role_vibes` as a comma-separated list:
+
+```
+metta://policy/teacher?role_vibes=miner,scout
+```
+
+## Recipe usage
+
+The `recipes.experiment.scripted_agents` recipe accepts the same scripted policy names:
+
+```
+./tools/run.py recipes.experiment.scripted_agents.play agent=thinky suite=cvc_arena
+./tools/run.py recipes.experiment.scripted_agents.play agent=miner suite=cogsguard
+```
+
+## Included policies
+
+- Nim policies (short names; default when both exist): `thinky`, `nim_random`, `race_car`, `ladybug`, `cogsguard`
+- Python scripted policies (use `_py` only when Nim exists): `baseline`, `tiny_baseline`, `ladybug_py`, `cogsguard_py`
+- Core scripted policy (in `cogames`): `starter`
+- Scripted roles: `miner`, `scout`, `aligner`, `scrambler`
+- Teacher wrapper: `teacher` (forces an initial role/vibe, then delegates to the Nim policy)

cogames_agents-0.0.2/pyproject.toml

@@ -0,0 +1,57 @@
+[build-system]
+requires = ["setuptools==80.9.0", "wheel==0.45.1"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "cogames-agents"
+version = "0.0.2"
+description = "Optional agent policies for CoGames"
+readme = "README.md"
+requires-python = ">=3.12,<3.13"
+license = { text = "MIT" }
+authors = [{ name = "Metta AI" }]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.12",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: POSIX :: Linux",
+  "Operating System :: MacOS",
+]
+urls = { Homepage = "https://github.com/Metta-AI/metta/tree/main/packages/cogames-agents", Repository = "https://github.com/Metta-AI/metta" }
+dependencies = ["cogames>=0.0.1", "mettagrid==0.2.0.58", "numpy>=2.0.0"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["cogames_agents", "cogames_agents.*"]
+
+[tool.setuptools]
+include-package-data = true
+
+[tool.setuptools.package-data]
+"cogames_agents" = [
+  "py.typed",
+  # Nim source files for building
+  "policy/nim_agents/*.nim",
+  "policy/nim_agents/*.nims",
+  "policy/nim_agents/nimby.lock",
+  # Compiled Nim binaries
+  "policy/nim_agents/bindings/generated/*.so",
+  "policy/nim_agents/bindings/generated/*.dylib",
+  "policy/nim_agents/bindings/generated/*.dll",
+  "policy/nim_agents/bindings/generated/*.py",
+]
+
+[tool.uv]
+cache-keys = [
+  { file = "src/cogames_agents/policy/nim_agents/nim_agents.nim" },
+  { file = "src/cogames_agents/policy/nim_agents/nim_agents.nims" },
+  { file = "src/cogames_agents/policy/nim_agents/common.nim" },
+  { file = "src/cogames_agents/policy/nim_agents/random_agents.nim" },
+  { file = "src/cogames_agents/policy/nim_agents/thinky_agents.nim" },
+  { file = "src/cogames_agents/policy/nim_agents/racecar_agents.nim" },
+  { file = "src/cogames_agents/policy/nim_agents/cogsguard_agents.nim" },
+]
+
+[tool.uv.sources]
+cogames = { workspace = true }
+mettagrid = { workspace = true }

cogames_agents-0.0.2/setup.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import os
+import platform
+import shutil
+import stat
+import subprocess
+import sys
+import tempfile
+import urllib.request
+from pathlib import Path
+
+from setuptools import setup
+from setuptools.command.build_py import build_py
+from setuptools.command.develop import develop
+from setuptools.command.install import install
+from setuptools.dist import Distribution
+
+NIM_AGENTS_DIR = Path(__file__).parent / "src" / "cogames_agents" / "policy" / "nim_agents"
+NIMBY_LOCK = NIM_AGENTS_DIR / "nimby.lock"
+BINDINGS_DIR = NIM_AGENTS_DIR / "bindings" / "generated"
+REQUIRED_NIM_VERSION = os.environ.get("COGAMES_NIM_VERSION", "2.2.6")
+NIMBY_VERSION = os.environ.get("COGAMES_NIMBY_VERSION", "0.1.13")
+
+
+def _get_nimby_url() -> str | None:
+    """Get the nimby download URL for the current platform, or None if not supported."""
+    system = platform.system()
+    arch = platform.machine()
+
+    if system == "Linux" and arch == "x86_64":
+        return f"https://github.com/treeform/nimby/releases/download/{NIMBY_VERSION}/nimby-Linux-X64"
+    elif system == "Darwin" and arch == "arm64":
+        return f"https://github.com/treeform/nimby/releases/download/{NIMBY_VERSION}/nimby-macOS-ARM64"
+    elif system == "Darwin" and arch == "x86_64":
+        return f"https://github.com/treeform/nimby/releases/download/{NIMBY_VERSION}/nimby-macOS-X64"
+    else:
+        # For unsupported platforms (e.g., Linux ARM64), nimby must be pre-installed
+        return None
+
+
+def _build_nim() -> None:
+    system = platform.system()
+    arch = platform.machine()
+
+    nimby_url = _get_nimby_url()
+    nim_bin_dir = Path.home() / ".nimby" / "nim" / "bin"
+
+    if nimby_url is not None:
+        # Download and install nimby
+        dst = nim_bin_dir / "nimby"
+        with tempfile.TemporaryDirectory() as tmp:
+            nimby = Path(tmp) / "nimby"
+            urllib.request.urlretrieve(nimby_url, nimby)
+            nimby.chmod(nimby.stat().st_mode | stat.S_IEXEC)
+            subprocess.check_call([str(nimby), "use", REQUIRED_NIM_VERSION])
+
+            dst.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(nimby, dst)
+
+        os.environ["PATH"] = f"{dst.parent}{os.pathsep}" + os.environ.get("PATH", "")
+    else:
+        # For unsupported platforms, assume nim/nimby are pre-installed
+        if shutil.which("nim") is None:
+            raise RuntimeError(
+                f"Nim is not installed and nimby download is not available for {system} {arch}. "
+                "Please install Nim manually (https://nim-lang.org/install.html) or build nimby from source."
+            )
+
+    # Ensure nim/nimble binaries installed by nimby are discoverable by subprocesses.
+    os.environ["PATH"] = f"{nim_bin_dir}{os.pathsep}" + os.environ.get("PATH", "")
+
+    # Sync Nim dependencies
+    if NIMBY_LOCK.exists():
+        if shutil.which("nimby") is not None:
+            subprocess.check_call(["nimby", "sync", "-g", str(NIMBY_LOCK)], cwd=NIM_AGENTS_DIR)
+        else:
+            # nimby not available (unsupported platform with manual Nim install) - use nimble directly
+            subprocess.check_call(["nimble", "install", "-y"], cwd=NIM_AGENTS_DIR)
+
+    # Create output directory for compiled binaries
+    BINDINGS_DIR.mkdir(parents=True, exist_ok=True)
+
+    # Compile Nim agents
+    result = subprocess.run(["nim", "c", "nim_agents.nim"], cwd=NIM_AGENTS_DIR, capture_output=True, text=True)
+    if result.returncode != 0:
+        print(result.stderr, file=sys.stderr)
+        print(result.stdout, file=sys.stderr)
+        raise RuntimeError(f"Failed to build Nim agents: {result.returncode}")
+
+
+class _EnsureNimMixin:
+    def run(self, *args, **kwargs):  # type: ignore[override]
+        _build_nim()
+        super().run(*args, **kwargs)  # type: ignore[misc]
+
+
+class BuildPyCommand(_EnsureNimMixin, build_py): ...
+
+
+class DevelopCommand(_EnsureNimMixin, develop): ...
+
+
+class InstallCommand(_EnsureNimMixin, install): ...
+
+
+class BinaryDistribution(Distribution):
+    def has_ext_modules(self) -> bool:
+        return True
+
+
+setup(
+    cmdclass={
+        "build_py": BuildPyCommand,
+        "develop": DevelopCommand,
+        "install": InstallCommand,
+    },
+    distclass=BinaryDistribution,
+)

cogames_agents-0.0.2/src/cogames_agents/policy/cogsguard_roles.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from cogames_agents.policy.scripted_agent.cogsguard.policy import CogsguardPolicy
+from mettagrid.policy.policy_env_interface import PolicyEnvInterface
+
+
+class _CogsguardRolePolicy(CogsguardPolicy):
+    role_name: str = ""
+
+    def __init__(self, policy_env_info: PolicyEnvInterface, device: str = "cpu", **_ignored: int) -> None:
+        super().__init__(policy_env_info, device=device, **{self.role_name: policy_env_info.num_agents})
+
+
+class MinerPolicy(_CogsguardRolePolicy):
+    short_names = ["miner"]
+    role_name = "miner"
+
+
+class ScoutPolicy(_CogsguardRolePolicy):
+    short_names = ["scout"]
+    role_name = "scout"
+
+
+class AlignerPolicy(_CogsguardRolePolicy):
+    short_names = ["aligner"]
+    role_name = "aligner"
+
+
+class ScramblerPolicy(_CogsguardRolePolicy):
+    short_names = ["scrambler"]
+    role_name = "scrambler"

cogames_agents-0.0.2/src/cogames_agents/policy/cogsguard_teacher.py

@@ -0,0 +1,223 @@
+from __future__ import annotations
+
+from typing import Optional, Sequence
+
+import numpy as np
+
+from cogames_agents.policy.nim_agents.agents import CogsguardAgentsMultiPolicy
+from cogames_agents.policy.scripted_agent.cogsguard.types import Role as CogsguardRole
+from mettagrid.policy.policy import AgentPolicy, MultiAgentPolicy
+from mettagrid.policy.policy_env_interface import PolicyEnvInterface
+from mettagrid.simulator import Action, AgentObservation
+
+DEFAULT_ROLE_VIBES = ("miner", "scout", "aligner", "scrambler")
+
+
+class CogsguardTeacherPolicy(MultiAgentPolicy):
+    """Teacher wrapper that forces an initial vibe, then delegates to the Nim policy."""
+
+    short_names = ["teacher"]
+
+    def __init__(
+        self,
+        policy_env_info: PolicyEnvInterface,
+        device: str = "cpu",
+        role_vibes: Optional[Sequence[str | CogsguardRole] | str] = None,
+    ) -> None:
+        super().__init__(policy_env_info, device=device)
+        self._delegate = CogsguardAgentsMultiPolicy(policy_env_info)
+        self._num_agents = policy_env_info.num_agents
+        self._action_names = list(policy_env_info.action_names)
+        self._action_name_to_index = {name: idx for idx, name in enumerate(self._action_names)}
+        self._delegate_agents = [self._delegate.agent_policy(i) for i in range(self._num_agents)]
+
+        self._episode_feature_id = self._find_feature_id("episode_completion_pct")
+        self._last_action_feature_id = self._find_feature_id("last_action")
+
+        self._role_action_ids = self._resolve_role_actions(role_vibes)
+        self._episode_index = [0] * self._num_agents
+        self._reset_episode_state()
+
+    def agent_policy(self, agent_id: int) -> AgentPolicy:
+        return _CogsguardTeacherAgentPolicy(self, agent_id)
+
+    def reset(self) -> None:
+        self._delegate.reset()
+        self._reset_episode_state()
+
+    def step_batch(self, raw_observations: np.ndarray, raw_actions: np.ndarray) -> None:
+        self._delegate.step_batch(raw_observations, raw_actions)
+        if not self._role_action_ids:
+            return
+        if raw_observations.shape[0] != self._num_agents:
+            return
+        for agent_id in range(self._num_agents):
+            episode_pct = self._extract_episode_pct_raw(raw_observations[agent_id])
+            last_action = self._extract_last_action_raw(raw_observations[agent_id])
+            forced_action = self._maybe_force_action(agent_id, episode_pct, last_action)
+            if forced_action is not None:
+                raw_actions[agent_id] = forced_action
+
+    def _step_single(self, agent_id: int, obs: AgentObservation) -> Action:
+        base_action = self._delegate_agents[agent_id].step(obs)
+        if not self._role_action_ids:
+            return base_action
+        episode_pct = self._extract_episode_pct_obs(obs)
+        last_action = self._extract_last_action_obs(obs)
+        forced_action = self._maybe_force_action(agent_id, episode_pct, last_action)
+        if forced_action is None:
+            return base_action
+        action_name = self._action_names[forced_action]
+        return Action(name=action_name)
+
+    def _extract_episode_pct_raw(self, raw_obs: np.ndarray) -> Optional[int]:
+        if self._episode_feature_id is None:
+            return None
+        for token in raw_obs:
+            if token[0] == 255 and token[1] == 255 and token[2] == 255:
+                break
+            if token[1] == self._episode_feature_id:
+                return int(token[2])
+        return 0
+
+    def _extract_episode_pct_obs(self, obs: AgentObservation) -> Optional[int]:
+        if self._episode_feature_id is None:
+            return None
+        for token in obs.tokens:
+            if token.feature.name == "episode_completion_pct":
+                return token.value
+        return 0
+
+    def _extract_last_action_raw(self, raw_obs: np.ndarray) -> Optional[int]:
+        if self._last_action_feature_id is None:
+            return None
+        for token in raw_obs:
+            if token[0] == 255 and token[1] == 255 and token[2] == 255:
+                break
+            if token[1] == self._last_action_feature_id:
+                return int(token[2])
+        return 0
+
+    def _extract_last_action_obs(self, obs: AgentObservation) -> Optional[int]:
+        if self._last_action_feature_id is None:
+            return None
+        for token in obs.tokens:
+            if token.feature.name == "last_action":
+                return token.value
+        return 0
+
+    def _find_feature_id(self, feature_name: str) -> Optional[int]:
+        for feature in self.policy_env_info.obs_features:
+            if feature.name == feature_name:
+                return feature.id
+        return None
+
+    def _resolve_role_actions(self, role_vibes: Optional[Sequence[str | CogsguardRole] | str]) -> list[int]:
+        change_vibe_actions = [name for name in self._action_names if name.startswith("change_vibe_")]
+        if len(change_vibe_actions) <= 1:
+            return []
+
+        available_vibes = [name[len("change_vibe_") :] for name in change_vibe_actions]
+        if role_vibes is None:
+            role_vibes = [vibe for vibe in DEFAULT_ROLE_VIBES if vibe in available_vibes]
+            if not role_vibes:
+                role_vibes = [vibe for vibe in available_vibes if vibe != "default"]
+            if not role_vibes:
+                role_vibes = available_vibes
+        else:
+            if isinstance(role_vibes, str):
+                normalized_vibes = [vibe.strip() for vibe in role_vibes.split(",") if vibe.strip()]
+            else:
+                normalized_vibes = [vibe.value if isinstance(vibe, CogsguardRole) else str(vibe) for vibe in role_vibes]
+            role_vibes = [vibe for vibe in normalized_vibes if vibe in available_vibes]
+            if not role_vibes:
+                role_vibes = available_vibes
+
+        role_action_ids = []
+        for vibe_name in role_vibes:
+            action_name = f"change_vibe_{vibe_name}"
+            action_id = self._action_name_to_index.get(action_name)
+            if action_id is not None:
+                role_action_ids.append(action_id)
+        return role_action_ids
+
+    def _reset_episode_state(self) -> None:
+        self._forced_vibe = [False] * self._num_agents
+        self._last_episode_pct = [-1] * self._num_agents
+        self._step_in_episode = [0] * self._num_agents
+        self._last_action_value: list[Optional[int]] = [None] * self._num_agents
+
+    def _maybe_force_action(
+        self,
+        agent_id: int,
+        episode_pct: Optional[int],
+        last_action: Optional[int],
+    ) -> Optional[int]:
+        self._update_episode_state(agent_id, episode_pct, last_action)
+        if self._forced_vibe[agent_id] or self._step_in_episode[agent_id] != 0:
+            return None
+        self._forced_vibe[agent_id] = True
+        role_index = (self._episode_index[agent_id] + agent_id) % len(self._role_action_ids)
+        return self._role_action_ids[role_index]
+
+    def _update_episode_state(
+        self,
+        agent_id: int,
+        episode_pct: Optional[int],
+        last_action: Optional[int],
+    ) -> None:
+        last_pct = self._last_episode_pct[agent_id]
+        if episode_pct is None:
+            last_action_seen = self._last_action_value[agent_id]
+            if (
+                last_action is not None
+                and last_action_seen is not None
+                and last_action == 0
+                and last_action_seen != 0
+                and self._step_in_episode[agent_id] > 0
+            ):
+                self._episode_index[agent_id] += 1
+                self._step_in_episode[agent_id] = 0
+                self._forced_vibe[agent_id] = False
+                self._last_episode_pct[agent_id] = 0
+                self._last_action_value[agent_id] = last_action
+                return
+
+            if last_pct == -1:
+                self._step_in_episode[agent_id] = 0
+            else:
+                self._step_in_episode[agent_id] += 1
+            self._last_episode_pct[agent_id] = 0
+            if last_action is not None:
+                self._last_action_value[agent_id] = last_action
+            return
+
+        new_episode = False
+        if last_pct == -1:
+            new_episode = True
+        elif episode_pct < last_pct:
+            new_episode = True
+        elif last_pct > 0 and episode_pct == 0:
+            new_episode = True
+
+        if new_episode:
+            if last_pct != -1:
+                self._episode_index[agent_id] += 1
+            self._step_in_episode[agent_id] = 0
+            self._forced_vibe[agent_id] = False
+        else:
+            self._step_in_episode[agent_id] += 1
+
+        self._last_episode_pct[agent_id] = episode_pct
+        if last_action is not None:
+            self._last_action_value[agent_id] = last_action
+
+
+class _CogsguardTeacherAgentPolicy(AgentPolicy):
+    def __init__(self, parent: CogsguardTeacherPolicy, agent_id: int) -> None:
+        super().__init__(parent.policy_env_info)
+        self._parent = parent
+        self._agent_id = agent_id
+
+    def step(self, obs: AgentObservation) -> Action:
+        return self._parent._step_single(self._agent_id, obs)

cogames_agents-0.0.2/src/cogames_agents/policy/nim_agents/__init__.py

@@ -0,0 +1,18 @@
+"""Nim-based agent policies for CoGames."""
+
+from cogames_agents.policy.nim_agents import agents  # noqa: F401
+
+__all__ = [
+    "RandomAgentsMultiPolicy",
+    "ThinkyAgentsMultiPolicy",
+    "RaceCarAgentsMultiPolicy",
+    "LadyBugAgentsMultiPolicy",
+]
+
+# Re-export the policy classes for convenience
+from cogames_agents.policy.nim_agents.agents import (  # noqa: F401
+    LadyBugAgentsMultiPolicy,
+    RaceCarAgentsMultiPolicy,
+    RandomAgentsMultiPolicy,
+    ThinkyAgentsMultiPolicy,
+)

cogames_agents-0.0.2/src/cogames_agents/policy/nim_agents/agents.py

@@ -0,0 +1,82 @@
+import importlib
+import os
+import sys
+from typing import Sequence
+
+from mettagrid.policy.policy import NimMultiAgentPolicy
+from mettagrid.policy.policy_env_interface import PolicyEnvInterface
+
+current_dir = os.path.dirname(os.path.abspath(__file__))
+bindings_dir = os.path.join(current_dir, "bindings/generated")
+if bindings_dir not in sys.path:
+    sys.path.append(bindings_dir)
+
+na = importlib.import_module("nim_agents")
+
+
+def start_measure():
+    na.start_measure()
+
+
+def end_measure():
+    na.end_measure()
+
+
+class ThinkyAgentsMultiPolicy(NimMultiAgentPolicy):
+    short_names = ["thinky"]
+
+    def __init__(self, policy_env_info: PolicyEnvInterface, agent_ids: Sequence[int] | None = None):
+        super().__init__(
+            policy_env_info,
+            nim_policy_factory=na.ThinkyPolicy,
+            agent_ids=agent_ids,
+        )
+
+
+class RandomAgentsMultiPolicy(NimMultiAgentPolicy):
+    short_names = ["nim_random"]
+
+    def __init__(self, policy_env_info: PolicyEnvInterface, agent_ids: Sequence[int] | None = None):
+        super().__init__(
+            policy_env_info,
+            nim_policy_factory=na.RandomPolicy,
+            agent_ids=agent_ids,
+        )
+
+
+class RaceCarAgentsMultiPolicy(NimMultiAgentPolicy):
+    short_names = ["race_car"]
+
+    def __init__(self, policy_env_info: PolicyEnvInterface, agent_ids: Sequence[int] | None = None):
+        super().__init__(
+            policy_env_info,
+            nim_policy_factory=na.RaceCarPolicy,
+            agent_ids=agent_ids,
+        )
+
+
+class LadyBugAgentsMultiPolicy(NimMultiAgentPolicy):
+    short_names = ["ladybug"]
+
+    def __init__(self, policy_env_info: PolicyEnvInterface, agent_ids: Sequence[int] | None = None):
+        super().__init__(
+            policy_env_info,
+            nim_policy_factory=na.LadybugPolicy,
+            agent_ids=agent_ids,
+        )
+
+
+class CogsguardAgentsMultiPolicy(NimMultiAgentPolicy):
+    short_names = ["cogsguard"]
+
+    def __init__(
+        self,
+        policy_env_info: PolicyEnvInterface,
+        agent_ids: Sequence[int] | None = None,
+        **_: object,
+    ):
+        super().__init__(
+            policy_env_info,
+            nim_policy_factory=na.CogsguardPolicy,
+            agent_ids=agent_ids,
+        )