Autonomous Game Playing Agents

Game Initialization
    ↓
Player White Agent
├─ Analyze current position
├─ Evaluate possible moves
├─ Select optimal move
└─ Propose move in algebraic notation
    ↓
Board Proxy Agent
├─ Validate move legality
├─ Check for rule violations
├─ Update game state
├─ Detect check/checkmate/stalemate
└─ Approve or reject move
    ↓
If Move Valid:
    ↓
Player Black Agent
├─ Analyze new position
├─ Formulate response
├─ Select counter-move
└─ Propose move
    ↓
Board Proxy Agent
└─ Validate and update
    ↓
Continue until game end...

# Clone repository
git clone https://github.com/Shubhamsaboo/awesome-llm-apps.git
cd advanced_ai_agents/autonomous_game_playing_agent_apps/ai_chess_agent

# Install dependencies
pip install -r requirements.txt

# Set OpenAI API key
export OPENAI_API_KEY='your-api-key-here'

# Run the chess game
streamlit run ai_chess_agent.py

Move 1:
White: e4 (King's Pawn Opening)
├─ Board Proxy: Valid ✓
└─ Board updated

Black: e5 (King's Pawn Defense)
├─ Board Proxy: Valid ✓
└─ Board updated

Move 2:
White: Nf3 (Developing Knight)
├─ Board Proxy: Valid ✓
└─ Board updated

Black: Nc6 (Developing Knight)
├─ Board Proxy: Valid ✓
└─ Board updated

... game continues ...

import autogen
import chess

# Configure LLM
llm_config = {
    "config_list": [{
        "model": "gpt-4o",
        "api_key": openai_api_key
    }]
}

# Create player agents
player_white = autogen.AssistantAgent(
    name="Player_White",
    system_message="""
    You are a strategic chess player playing White.
    Analyze the position and make the best move.
    Use standard algebraic notation (e.g., e4, Nf3, O-O).
    """,
    llm_config=llm_config
)

player_black = autogen.AssistantAgent(
    name="Player_Black",
    system_message="""
    You are a tactical chess player playing Black.
    Respond to White's moves with sound strategy.
    Use standard algebraic notation.
    """,
    llm_config=llm_config
)

# Create validation agent
board_proxy = autogen.AssistantAgent(
    name="Board_Proxy",
    system_message="""
    You validate chess moves and maintain game state.
    Check move legality and update the board.
    Detect check, checkmate, and stalemate.
    """,
    llm_config=llm_config
)

# Initialize board
board = chess.Board()

# Game loop
while not board.is_game_over():
    # White's turn
    white_move = player_white.generate_move(board)
    if board_proxy.validate_move(white_move, board):
        board.push(white_move)
    
    # Black's turn
    if not board.is_game_over():
        black_move = player_black.generate_move(board)
        if board_proxy.validate_move(black_move, board):
            board.push(black_move)

Master Agent (Referee)
├─ Coordinates the game
├─ Validates moves
├─ Maintains game state
├─ Determines outcome
└─ Enforces rules
    ↓
Player X Agent
├─ Analyzes board state
├─ Makes strategic X moves
├─ Follows game rules
└─ Responds to opponent
    ↓
Player O Agent
├─ Analyzes board state
├─ Makes strategic O moves
├─ Follows game rules
└─ Responds to opponent

# Clone repository
git clone https://github.com/Shubhamsaboo/awesome-llm-apps.git
cd advanced_ai_agents/autonomous_game_playing_agent_apps/ai_tic_tac_toe_agent

# Install dependencies
pip install -r requirements.txt

# Required for OpenAI models (gpt-4o, o3-mini)
OPENAI_API_KEY=your_actual_openai_api_key_here

# Optional - for additional models
ANTHROPIC_API_KEY=your_actual_anthropic_api_key_here  # For Claude
GOOGLE_API_KEY=your_actual_google_api_key_here        # For Gemini
GROQ_API_KEY=your_actual_groq_api_key_here           # For Groq models

streamlit run app.py

from agno import Agent

# Create Master Agent (Referee)
master_agent = Agent(
    name="Game_Master",
    model=model_x,
    instructions="""
    You are the game master for Tic-Tac-Toe.
    Coordinate between players, validate moves,
    maintain game state, and determine winners.
    """
)

# Create Player X
player_x = Agent(
    name="Player_X",
    model=model_x,
    instructions="""
    You play as X in Tic-Tac-Toe.
    Analyze the board and make strategic moves.
    Try to win by getting three X's in a row.
    Block opponent's winning moves.
    """
)

# Create Player O
player_o = Agent(
    name="Player_O",
    model=model_o,
    instructions="""
    You play as O in Tic-Tac-Toe.
    Analyze the board and make strategic moves.
    Try to win by getting three O's in a row.
    Block opponent's winning moves.
    """
)

# Game loop
board = [[" " for _ in range(3)] for _ in range(3)]
current_player = player_x

while not is_game_over(board):
    # Current player makes move
    move = current_player.run(
        f"Current board state: {board}. Make your move."
    )
    
    # Master validates and applies move
    if master_agent.validate_move(move, board):
        apply_move(move, board)
        current_player = player_o if current_player == player_x else player_x
    
    # Check for win/draw
    result = master_agent.check_game_over(board)

# LLMs approximate minimax reasoning
def evaluate_move(board, player):
    """
    LLM reasons about:
    1. Immediate winning moves
    2. Blocking opponent wins
    3. Strategic position control
    4. Long-term advantage
    """
    prompt = f"""
    Board state: {board}
    You are playing as {player}.
    
    Analyze:
    1. Can you win in one move?
    2. Can opponent win if you don't block?
    3. What move gives best position?
    
    Consider both your opportunities and opponent's threats.
    """
    return llm.generate(prompt)

def evaluate_position(board):
    """
    LLM evaluates multiple factors:
    - Material count (piece values)
    - Piece activity and mobility
    - King safety
    - Pawn structure
    - Control of center
    - Tactical opportunities
    """
    evaluation = llm.analyze(board)
    return evaluation.score

Board Positions (Priority):

5 (Center)     - Highest value
1, 3, 7, 9     - Corners (high value)
2, 4, 6, 8     - Edges (lower value)

Strategic Evaluation:
- Two in a row  = High priority (win/block)
- Fork potential = Medium priority
- Center control = Baseline advantage

class MoveValidator(Agent):
    def validate_move(self, move, game_state):
        """
        Multi-step validation:
        1. Parse move notation
        2. Check if move is legal
        3. Verify game rules
        4. Update game state
        5. Detect end conditions
        """
        if not self.is_valid_notation(move):
            return False, "Invalid notation"
        
        if not self.is_legal_move(move, game_state):
            return False, "Illegal move"
        
        if not self.follows_rules(move, game_state):
            return False, "Rule violation"
        
        new_state = self.apply_move(move, game_state)
        game_over = self.check_end_condition(new_state)
        
        return True, new_state, game_over

# Extend to other games
class GameAgent:
    """Base class for game-playing agents"""
    
    def analyze_position(self, game_state):
        """Evaluate current position"""
        pass
    
    def generate_move(self, game_state):
        """Select best move"""
        pass
    
    def validate_move(self, move, game_state):
        """Check move legality"""
        pass

# Extend to new games:
# - Checkers
# - Go (simplified)
# - Connect Four
# - Poker (with hidden information)
# - Stratego

# Effective game agent prompts
system_message = """
You are playing {game_name} as {player}.

RULES:
{game_rules}

STRATEGY:
1. Analyze the current position
2. Identify immediate threats
3. Look for winning opportunities
4. Consider long-term advantage
5. Make the best move

FORMAT:
Provide your move in {notation_format}.
Explain your reasoning briefly.

CURRENT BOARD:
{board_state}

YOUR TURN: Make your move.
"""

import streamlit as st

# Use session state for game persistence
if 'game_state' not in st.session_state:
    st.session_state.game_state = initialize_game()
    st.session_state.move_history = []
    st.session_state.current_player = "X"

# Update state after each move
def make_move(move):
    st.session_state.game_state.apply(move)
    st.session_state.move_history.append(move)
    st.session_state.current_player = switch_player()

# Cache position evaluations
@st.cache_data
def evaluate_position(board_fen):
    return llm.analyze(board_fen)

# Async move generation
async def get_moves_parallel():
    moves = await asyncio.gather(
        agent.generate_move_async(board),
        agent.evaluate_position_async(board)
    )
    return moves

# Timeout protection
import signal

def timeout_handler(signum, frame):
    raise TimeoutError("Move generation timeout")

signal.signal(signal.SIGALRM, timeout_handler)
signal.alarm(30)  # 30 second timeout