AgentVerse

Coordinates multiple LLM-based agents to decompose and solve complex tasks through a structured task-solving framework. Agents operate within a task-solving environment that enforces execution rules, manages state transitions, and tracks progress toward task completion. The framework uses a registry pattern to dynamically instantiate agents and environments, enabling flexible composition of agent teams without tight coupling.

Enables creation of custom simulation environments where multiple agents interact according to defined rules and dynamics. Built on an environment abstraction layer that manages agent state, action execution, observation generation, and reward/outcome calculation. Includes pre-built simulations (NLP Classroom, SDE Team, Pokemon Game) that demonstrate domain-specific agent interactions, with extensibility for custom simulation logic.

Provides a base task abstraction that enables definition of custom task types with specific success criteria, execution rules, and evaluation metrics. Tasks are registered in the task registry and can be instantiated through configuration. Task implementations define initial state, valid actions, success conditions, and reward/outcome calculation. The framework supports both built-in and user-defined tasks.

Supports integration with local LLM servers (e.g., vLLM, Ollama, text-generation-webui) through configurable HTTP endpoints. Agents can use local models instead of cloud APIs, reducing latency and costs. The LLM abstraction layer handles communication with local servers and manages request/response formatting. Configuration specifies server endpoint, model name, and inference parameters.

Abstracts LLM interactions behind a unified interface (base.py) that supports multiple providers (OpenAI, Anthropic, local servers) without agent code changes. Includes token counting utilities for cost estimation and context management, and supports dynamic LLM server configuration for local model deployment. Agents reference LLM instances by name through the registry, enabling runtime model swapping.

Manages agent conversation history and context through a chat history abstraction that stores and retrieves agent interactions. Supports memory manipulation operations (e.g., summarization, filtering) through a dedicated memory manipulator system. Memory is persisted per-agent and can be queried to provide context for subsequent agent decisions, enabling agents to learn from past interactions within a session.

Enables agents to call external tools and functions through a structured tool-using executor within the task-solving environment. Tools are registered in a central registry and agents can invoke them with structured arguments. The tool executor validates tool calls, executes them, and returns results back to agents, enabling agents to interact with external systems (APIs, databases, code execution).

Implements a factory pattern through dedicated registries for agents, environments, LLMs, and tasks, enabling dynamic component creation from configuration without code changes. Each component type has its own registry that maps names to concrete implementations. This decouples component definitions from framework code and enables runtime composition of complex systems through configuration files.

Manages agent execution within structured environments that enforce rules, track state transitions, and validate actions. Environments implement a step-based execution model where agents observe state, take actions, and receive observations. Rules are modular and composable (e.g., tool-using rules, communication rules) and can be customized per environment. State is centrally managed and agents interact with it through the environment interface.

Provides both CLI and GUI interfaces for configuring, launching, and monitoring agent systems. The GUI (main_simulation_gui.py) enables visual setup of simulations and real-time observation of agent interactions. The CLI supports scripted automation and integration with external tools. Both interfaces interact with the same underlying framework, enabling flexible deployment across different user preferences.

Centralizes system initialization through a configuration-driven approach that reads agent, environment, LLM, and task definitions and instantiates all components through the registry system. Supports configuration files (YAML/JSON) and programmatic configuration through Python objects. Initialization validates configurations and wires up dependencies between components.

Provides structured logging throughout the framework to trace agent decisions, environment state changes, and tool executions. Logs capture agent prompts, LLM responses, action validation, and outcome tracking. Logging can be configured at different verbosity levels and output to files or console. Execution traces enable post-hoc analysis of agent behavior and debugging of multi-agent interactions.