LLM-Plays-Games: Benchmarking Agentes Autónomos en Juegos de Aventura con LLMs

¿Por qué evaluar LLMs en juegos de texto?

En los últimos años, los modelos de lenguaje (LLMs) han demostrado capacidades sorprendentes en tareas de generación de texto, razonamiento y resolución de problemas. Sin embargo, medir su desempeño como agentes autónomos en escenarios interactivos sigue siendo un desafío abierto. Los juegos de aventuras basados en texto representan un entorno especialmente interesante: requieren interpretación contextual, planificación, adaptación y toma de decisiones bajo incertidumbre—características esenciales para agentes inteligentes.

Cuando empecé a explorar este área, noté que existía un vacío en herramientas accesibles y modulares para evaluar y comparar LLMs actuando como agentes en juegos. Así nació LLM-Plays-Games, un entorno diseñado para:

• Benchmarkear diferentes modelos y estrategias de prompting.
• Analizar cómo los LLMs exploran, razonan y resuelven objetivos interactivos.
• Facilitar el desarrollo de nuevas técnicas para el control autónomo de agentes basados en LLMs.

👉 Repositorio en GitHub

Arquitectura: Del concepto a la implementación

El objetivo principal de LLM-Plays-Games era modularidad, tanto para los juegos como para la integración de distintos LLMs. Esto implicó diseñar una arquitectura clara y extensible, con los siguientes componentes principales:

1. Motor del juego (game.py)

Implementé un motor sencillo pero flexible, la clase SimpleTextGame, capaz de:

• Definir estados, acciones posibles y reglas.
• Controlar la evolución del juego a partir de las acciones del agente.
• Proveer una interfaz limpia para el agente y el orquestador.

2. Agente LLM (llm_agent.py)

La clase LLMAgent es el corazón del sistema:

• Construye prompts contextuales según el estado actual y el objetivo.
• Interactúa con proveedores LLM (usando la librería g4f).
• Interpreta la respuesta del modelo y decide la siguiente acción.

3. Orquestador y bucle de simulación (orchestrator.py)

El módulo de orquestación gestiona:

• La sincronización entre el juego y el agente.
• El ciclo de juego (estado → prompt → acción → nuevo estado).
• El logging detallado de cada paso para posterior análisis.

4. Interfaz y visualización (HTML/CSS)

Quería que el entorno fuera accesible y visualmente claro. Por eso, el front-end HTML/CSS permite visualizar el progreso del agente, los estados del juego y los logs de decisiones.

5. Integración LLM modular

Gracias al uso de la librería g4f, es trivial intercambiar entre diferentes proveedores de LLM (por ejemplo, GPT-4o-mini).

Diagrama de Arquitectura

Componentes principales: Detalle y snippets

Motor del juego: SimpleTextGame

La clave aquí fue mantener simplicidad y extensibilidad. El juego expone:

1class SimpleTextGame:
2    def __init__(self, rooms, items, goal):
3        self.rooms = rooms
4        self.items = items
5        self.goal = goal
6        self.state = self._init_state()
7 
8    def available_actions(self):
9        # Devuelve las acciones válidas según el estado actual
10        pass
11 
12    def step(self, action):
13        # Procesa la acción, actualiza el estado y retorna feedback
14        pass

Esto permite definir fácilmente nuevos mundos o escenarios.

Agente LLM: LLMAgent

El reto fue diseñar prompts que ayuden al LLM a entender el contexto y el objetivo. Ejemplo de construcción de prompt:

1class LLMAgent:
2    def build_prompt(self, state, goal):
3        return (
4            f"Estás en el juego. Estado: {state}\n"
5            f"Tu objetivo: {goal}\n"
6            "¿Qué acción deberías tomar a continuación?"
7        )
8    
9    def choose_action(self, state, goal):
10        prompt = self.build_prompt(state, goal)
11        response = self.llm_provider.query(prompt)
12        return self.parse_action(response)

El método parse_action fue clave para transformar la respuesta del modelo en una acción válida.

Orquestador

El bucle principal de simulación:

1def run_simulation(game, agent, max_steps=20):
2    for step in range(max_steps):
3        actions = game.available_actions()
4        action = agent.choose_action(game.state, game.goal)
5        if action not in actions:
6            log("Acción inválida, terminando simulación.")
7            break
8        reward, done = game.step(action)
9        log(f"Paso {step}: acción={action}, reward={reward}")
10        if done:
11            log("¡Objetivo alcanzado!")
12            break

Este logging detallado permite analizar cómo evoluciona la estrategia del agente.

Decisiones técnicas clave

1. Modularidad ante todo

Quería que cualquier desarrollador pudiera:

• Cambiar el motor de juego o crear variantes fácilmente.
• Probar distintos modelos de LLM o técnicas de prompting sin modificar la infraestructura base.
• Analizar logs detallados para comparar agentes y estrategias.

Esto llevó a una separación clara entre lógica de juego, interacción con LLM y orquestación.

2. Uso de g4f para LLMs

La elección de g4f fue estratégica: permite acceso a múltiples proveedores de LLM (incluyendo modelos gratuitos o de bajo costo), lo que facilita el benchmarking sin depender de una sola API propietaria.

3. Simplicidad visual con HTML/CSS

Aunque el backend está en Python, opté por una UI básica en HTML/CSS. Esto facilita la visualización para usuarios no técnicos y permite extender el entorno hacia una interfaz web interactiva en el futuro.

Retos técnicos y cómo los resolví

1. Interpretación de acciones por el LLM

Uno de los principales desafíos fue que los LLMs, sin un formato estricto, pueden generar respuestas ambiguas o no válidas (e.g., “Debería explorar el pasillo a la izquierda…” en vez de “ir norte”).

Solución:

Implementé una función de parsing robusta y, en el prompt, especifiqué claramente el formato de respuesta esperado. Ejemplo:

“Responde únicamente con la acción a ejecutar (‘ir norte’, ‘tomar llave’, etc.).”

2. Generalización a múltiples juegos/escenarios

Diseñar el motor del juego para soportar diferentes estructuras (habitaciones, objetos, objetivos) fue otro desafío. Usé un enfoque basado en diccionarios y listas para definir el mundo, permitiendo instanciar fácilmente nuevos escenarios.

3. Logging exhaustivo y análisis

Registrar cada prompt, respuesta y transición de estado era esencial para el benchmarking. Tuve que equilibrar la verbosidad del logging con la claridad, optando por logs estructurados en JSON para facilitar análisis posteriores.

4. Limitaciones de los LLMs

Algunos modelos tienden a “alucinar” acciones o ignorar restricciones del entorno. Detectar y manejar estos casos requirió lógica extra en el orquestador para validar acciones y terminar la simulación en caso de incoherencias.

Resultados y métricas

Tras varias pruebas con diferentes LLMs (como GPT-4o-mini y variantes de OpenAI), observé:

• Tasa de éxito: Los modelos grandes resuelven objetivos simples en >85% de los casos, pero su rendimiento decae con puzzles complejos.
• Estilos de exploración: Algunos LLMs tienden a explorar sistemáticamente, otros toman riesgos sin suficiente información.
• Impacto del prompting: Pequeñas variaciones en el prompt afectan significativamente la eficacia y coherencia de las acciones.

Estas métricas se logran gracias al sistema de logging y a la estructura modular, que permite comparar estrategias y modelos fácilmente.

Aprendizajes y mejoras futuras

1. El prompting es (casi) todo

La calidad del prompt determina en gran medida el desempeño del agente. Experimentar con cadenas de pensamiento (“chain-of-thought”) y ejemplos ayuda a mejorar la planificación del modelo.

2. Hacia entornos más ricos

Me gustaría incorporar:

• Juegos más complejos (con puzzles, inventarios, NPCs…).
• Métricas automáticas de eficiencia, creatividad y robustez.
• Integración de feedback humano (reforzamiento con preferencia humana).

3. Hacia la web interactiva

Una posible evolución es convertir el entorno en un playground web donde cualquiera pueda probar sus propios escenarios y agentes, fomentando la colaboración y la investigación abierta.

Conclusión

LLM-Plays-Games es un primer paso hacia la evaluación sistemática de LLMs como agentes autónomos en entornos interactivos. Su arquitectura modular y enfoque en el benchmarking lo convierten en una herramienta versátil para la comunidad de IA. Si tienes curiosidad por cómo razonan y actúan los LLMs en juegos, ¡te invito a explorar el repositorio, proponer mejoras o experimentar con tus propios escenarios! 🚀

👉 Repositorio y documentación en GitHub

¿Preguntas, ideas o interés en colaborar? ¡Déjalas en los comentarios o contáctame por GitHub!