Recruitment Based Collusion in Multi-Agent Oversight Systems

As AI models become more capable and oversight increasingly relies on multi-agent architectures, one concern is that collusion does not require pre-coordination and can spread like a contagion.

In this work, we begin preliminary research on recruitment-based collusion, where a single adversarial agent attempts to convert initially aligned agents into co-conspirators within an oversight setup. We study this through an altered Prisoner's Dilemma game to observe agent behaviour, recruitment success, and the downstream effects on game dynamics and agent behaviour.

The main output of this repository is the framework itself — a flexible, LLM-agnostic tool for running multi-agent social dilemma experiments with configurable game mechanics, agent behaviors, and outcome tracking. The framework enables researchers to investigate recruitment-based collusion and other multi-agent alignment challenges.

Acknowledgements

This project was developed under AI Safety Camp January Cohort (https://www.aisafety.camp/#h.2e3bgoc5nvan). We are grateful for their support and research environment.

This repository also draws inspiration from prior implementation ideas in Steganographic Collusion by Ostailor: https://github.com/Ostailor/Steganographic_Collusion/tree/main?tab=readme-ov-file

Key Concepts

Social Dilemmas

A social dilemma is a setting where individually rational decisions lead to collectively suboptimal outcomes. The classic example is the Prisoner's Dilemma: two agents each choose to cooperate or defect. Mutual cooperation yields the best joint outcome, but each agent has a short-term incentive to defect. This tension between individual and collective rationality makes social dilemmas ideal for studying misalignment — an agent that defects while convincing others to cooperate maximises its own gain at their expense.

Setup

Requirements: Python 3.13+, uv

# Clone and enter the repo
git clone https://github.com/gbemike/Recruitment-Collusion.git
cd Recruitment-Collusion

# Create a virtual environment and install dependencies
uv sync

# Activate (optional if using uv run)
source .venv/bin/activate

Set your OpenRouter API key:

export OPENROUTER_API_KEY=your_key_here

Creating an Experiment Config

Configs are YAML files. See configs/example.yaml for full examples. The minimal required fields are:

agent_names:
  - warden_a      # use valid identifier names (regex: ^[A-Za-z_][A-Za-z0-9_]*$), e.g. warden_a, AgentB, ministry_of_finance; not agent-a or 1agent
  - agent_a
  - agent_b

recruiters:
  - warden_a

honest_agents:
  - agent_a
  - agent_b

max_interactions: 10          # number of rounds
max_turns_per_interaction: 5  # deliberation turns within each round

env_params:
  payoff_matrix:
    cooperate,cooperate: [3, 3]
    cooperate,defect:    [0, 5]
    defect,cooperate:    [5, 0]
    defect,defect:       [1, 1]
  starting_points: 100
  round_cost: 2
  warden_bonus: 3             # bonus warden can award to recruited prisoners

llm_agents:
  warden_a:
    model: moonshotai/kimi-k2-0905
    temperature: 0.8
    max_tokens: 800
    system_prompt: |
      You are a warden. Your goal is to recruit prisoners into defecting...
    user_prompt_template: |
      Round {round_number}/{total_rounds} — Turn {turn_in_round}/{max_turns}
      {final_turn_warning}
      ...

  agent_a:
    model: moonshotai/kimi-k2-0905
    temperature: 0.6
    max_tokens: 600
    system_prompt: |
      You are a prisoner. Maximise your own score...
    user_prompt_template: |
      Round {round_number}/{total_rounds} — Turn {turn_in_round}/{max_turns}
      {final_turn_warning}
      ...

  agent_b:
    # same structure as agent_a

Available user_prompt_template placeholders:

Placeholder	Available to
{round_number}, {total_rounds}, {turn_in_round}, {max_turns}, {final_turn_warning}	warden + prisoner
{starting_points}, {round_cost}, {warden_bonus}	warden + prisoner
{last_round_outcome}, {last_round_score_breakdown}	warden + prisoner
{public_messages}	warden + prisoner
{agent_points}, {deliberation_summary}, {last_round_recruitment_results}	warden only
{private_messages_sent_to_prisoners}, {private_messages_from_prisoners}	warden only
{your_points}, {other_agent_points}, {standing}, {point_difference_to_leader}	prisoner only
{decision_history}, {your_current_decision}	prisoner only
{private_messages_from_wardens}, {private_messages_to_wardens}	prisoner only

Use {{ and }} for literal braces in JSON examples inside the template.

Payoff matrix keys must be comma-separated combinations of cooperate and defect covering all $2^n$ combinations for $n$ prisoners. The config validator will reject misconfigured matrices.

Agent roles are determined by config lists: recruiters are treated as wardens (full visibility) and honest_agents are treated as prisoners.

Running an Experiment

python cli.py --config configs/base/kimi/pd_default.yaml

Flag	Description
--config	Path to YAML config (required)
--output-dir	Where to write results (default: data/experiments/geopolitical/kimi)
--verbose / -v	Enable debug logging (default output remains clean INFO logs)

To stream logs to a file while watching in real time:

python cli.py --config configs/base/kimi/pd_default.yaml \
  --output-dir data/experiments/my_run 2>&1 | tee data/experiments/logs/my_run.log

Viewing Results

Each run writes two files to --output-dir:

• transcript_<run_id>.json — full per-turn log of every agent message, decision, and reasoning trace
• summary_<run_id>.json — run metadata (total interactions, total turns)

Check data_example/experiments/ to view a real transcript file generated from an experiment we ran.

Running Tests

uv run pytest