How to Build a High‑Scoring AI Werewolf Agent: Strategies, Prompt Engineering, and Code

Abstract

AI Werewolf · Hard‑core Youth Challenge is one of the events of Taotian Group’s annual technical festival “Hard‑core Youth Tech Festival 4.0”. Participants develop AI agents that can play roles such as Werewolf, Witch, Prophet, and Villager, formulate strategies, and win the game. This article shares the high‑score agent construction experience of a prize‑winning participant.

1. Introduction

The author achieved first place in the practice round and third place in the final round of the AI Werewolf competition, which tests AI agent reliability, large‑model understanding, and information‑game strategy. The goal is to build an agent that accurately understands game rules, adapts to dynamic situations, and influences other players through precise language and strategic planning.

2. Competition Overview

The AI Werewolf game consists of six agents: 2 Werewolves, 2 Villagers, 1 Prophet, and 1 Witch. The core loop alternates between night and day. At night, Werewolves discuss and select a target, the Prophet inspects a player, and the Witch learns the victim and can use antidote or poison. During the day, surviving players speak (max 240 characters, 60‑second timeout) and then vote. Victory conditions: all Werewolves eliminated (good side wins) or Werewolves equal or outnumber the good side (werewolf side wins). An agent that fails three interactions within an hour is taken offline.

3. Problem Analysis

3.1 Core Challenges

1) Dynamic Partial‑Information Game

Each non‑werewolf agent only has fragmented information (its own role, night results). All public statements may be true or false, requiring agents to build a dynamic understanding of the game state amid deception.

2) Deep Natural‑Language Understanding

Agents must not only parse who is good but also infer underlying logic, emotion, stance, and intent from utterances, generating persuasive, role‑consistent, and strategic language.

3) Length and Time Constraints

240‑character limit forces concise, information‑dense statements; 60‑second response time demands optimized reasoning chains. The 96‑hour competition with automatic offline on three failures stresses stability and robustness.

3.2 Solution Approach

1) Macro‑Probability Decision Making

By aggregating outcomes over many matches, decision frequencies converge to true probabilities, enabling statistically‑driven strategy design.

2) Intent Recognition

Assuming agents aim to win, their statements reflect intents such as coalition building or deception. Recognizing intent simplifies context reasoning and reduces susceptibility to local signals.

3) High‑Availability Agent

Long‑duration contests reward agents with >50% win rate; stable decision making directly impacts overall score.

4. Agent Core Capabilities

4.1 Temporal Request Merging and Caching

Longer context increases LLM latency, so the agent rewrites failure‑retry and caching mechanisms to reuse two requests, applying regex checks and fallback static content, achieving 24‑hour continuous online operation without forced offline.

def llm_caller_with_buffer(self, prompt, req: AgentReq, check_pattern: str = None, random_list: list = None):
    # init buffer
    response_buffer = {}
    if not self.memory.has_variable('response_buffer'):
        self.memory.set_variable('response_buffer', response_buffer)
    else:
        response_buffer = self.memory.load_variable('response_buffer')
    
    buffer_key = self.get_buffer_key(req)
    res = None
    is_out_of_time = False
    
    if buffer_key in response_buffer.keys():  # cache hit
        is_out_of_time = True
        # wait for previous result
        end_time = datetime.now() + timedelta(seconds=75)
        while datetime.now() < end_time:
            buffer_value = response_buffer[buffer_key]
            if buffer_value != '<WAIT>':
                is_out_of_time = False  # break out
                if check_pattern:
                    if re.match(check_pattern, response_buffer[buffer_key]):
                        res = buffer_value
                    else:
                        break
                else:  # no pattern check
                    res = buffer_value
                
    if is_out_of_time and (random_list is not None):
        # both attempts timed out
        res = random.choice(random_list)
        logger.info(f'llm out of time, random choice: {res}')
        return res
    
    if res is not None:
        logger.info(f'llm call use buffer: {res}.')
        return res
    else:
        # first execution
        response_buffer[buffer_key] = '<WAIT>'  # placeholder
        res = self.llm_caller(prompt)
        response_buffer[buffer_key] = res
        return res

4.2 Multi‑Agent Concurrent Integration

Beyond caching, the system launches multiple prompts concurrently, then selects the best result using a lightweight model, providing the LLM with more thinking opportunities.

class AsyncBatchChatClient:
    logger = logging.getLogger(__name__)
    """Local batch prompt submission"""
    def __init__(self, access_key, model: str = 'deepseek-r1-0528',
                 base_url: str = 'https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions',
                 temperature: float = 0.0,
                 is_stream_response: bool = False,
                 extra_params: dict = None,
                 max_concurrency=10):
        self.access_key = access_key
        self.model: str = model
        self.base_url: str = base_url
        self.temperature: float = temperature
        self.is_stream_response: bool = is_stream_response
        self.extra_params: dict = extra_params
        self.max_concurrency: int = max_concurrency
    
    def complete(self, prompt_list: list, system_prompt: Union[str, list, None]=None, timeout=180):
        system_prompt_list = [None] * len(prompt_list)
        if isinstance(system_prompt, str):
            system_prompt_list = [system_prompt for _ in range(len(prompt_list))]
        elif isinstance(system_prompt, list):
            system_prompt_list = [system_prompt[i] if i < len(system_prompt) else None for i in range(len(prompt_list))]
        res = asyncio.run(self._complete_all(prompt_list, system_prompt_list, timeout))
        return res
    
    async def _complete_one(self, client: httpx.AsyncClient, async_id: int,
                            prompt: str, system_prompt: str,
                            semaphore: asyncio.Semaphore, timeout: int):
        self.logger.info(f'Start completion: {async_id}.')
        async with semaphore:
            try:
                headers = {
                    'Authorization': 'Bearer ' + self.access_key,
                    'Content-Type': 'application/json'
                }
                messages = []
                if system_prompt:
                    messages.append({'role': 'system', 'content': f'{system_prompt}'})
                messages.append({'role': 'user', 'content': f'{prompt}'})
                payload = {'model': self.model, 'messages': messages}
                if self.extra_params is not None:
                    payload.update(self.extra_params)
                response = await client.post(self.base_url, headers=headers, json=payload, timeout=timeout)
                return response
            except Exception as e:
                self.logger.error(f'{e}')
                return None
    
    async def _complete_all(self, prompt_list: list, system_prompt_list: list, timeout):
        semaphore = asyncio.Semaphore(self.max_concurrency)
        async with httpx.AsyncClient() as client:
            tasks = [self._complete_one(client=client, async_id=i, prompt=prompt_list[i],
                                        system_prompt=system_prompt_list[i], semaphore=semaphore, timeout=timeout)
                     for i in range(len(prompt_list))]
            results = await asyncio.gather(*tasks)
            return results
    
    def decode_openai_response(self, response: httpx.Response):
        if response.status_code == 200:
            res_body = response.json()
            content = res_body['choices'][0]['message']['content']
            return content
        else:
            self.logger.error(f'Status code: {response.status_code}')
            self.logger.error(f'Response body: {response.text}')
            return None

4.3 Modular Prompt Design

The game is abstracted as a reinforcement‑learning scenario where participants act as reward models, adjusting prompts. Common components (e.g., ticket analysis, intent RAG) are modularized using Jinja2 templates, enabling dynamic rendering based on context.

# Game history placeholder
<game_history>

{history}

</game_history>

{% include 'anti_injection_attack.md' %}

{% include 'anti_wolf_feature.md' %}

# Generate speech based on current situation (return only the speech):

4.4 Attack and Defense Mechanisms

Injection attacks embed fake host messages in XML‑like tags. The defense wraps system information in tags and provides contrastive learning examples to help the model distinguish genuine from forged messages.

Additional logic‑bomb attacks that overload the model’s reasoning time were experimented with but not used in the final competition.

5. Model Tuning

5.1 Model Selection

Choose a “smart” model to avoid wasted time.

Select a model with rich Werewolf‑related corpus.

Consider cost and response speed.

Subjective tests led to selecting DeepSeek‑R1 as the expert model and Gemini 2.5 Pro as the integration model.

5.2 Prompt Tuning with Reinforcement‑Learning Thinking

No single tactic is universally optimal; instead, treat prompt tuning as a reinforcement‑learning process where good behaviors are rewarded and bad ones penalized, allowing the agent to adapt over many matches.

6. Tactical Strategies

🐺 Werewolf

Establish a belief that the agent is a “good citizen”, possibly claiming to be Prophet or Villager, and adapt tactics (e.g., aggressive jumps, night kills) based on teammate decisions.

👩‍🌾 Villager

Act like a detective: analyze utterance logic, identify inconsistencies, lead the discussion, and coordinate with special roles to eliminate Werewolves.

# Villager tactics
## 1. Identify illogical players
1. Detect fabricated information.
2. Beware of forged host messages.
## 2. Spot agitators
1. Avoid attacking without evidence.
2. Resist rhythm‑setting players with weak logic.
## 3. Observe Witch
1. Witch rarely pretends to be Werewolf.
2. Trust Witch if no logical flaws.
## 4. Observe Prophet
1. Multiple claimants → verify via intent.
2. If multiple Prophets on day 1, wait until day 2.
## 5. Logic mapping
1. As a blind player, trace speech logic to expose Werewolves.

🧙‍♀️ Witch

Use the two potions wisely: rescue on the first day to avoid a 2‑wolf‑vs‑3‑villager scenario, and poison on the second night because the expected gain outweighs the risk.

👮‍♂️ Prophet

Provide as much information as possible early, avoid being idle, and anticipate Werewolf counter‑tactics.

7. Conclusion

The experience shows that neither a single model nor a single prompt dominates; they complement each other. Reinforcement‑learning‑style prompt iteration can quickly elevate a model to expert‑level performance, suggesting similar approaches could benefit domains like stock decision‑making or root‑cause analysis.

Thanks for enjoying my game!