MetaGPT

Implements a role-based agent system where each role follows a structured observe-think-act cycle: gathering information from message queues, processing via LLM-based thinking, and publishing results as structured messages. Roles are organized hierarchically (Product Manager, Architect, Engineer, QA) and coordinate through a central message bus that routes messages based on role watch lists and responsibilities, enabling complex multi-step workflows without explicit orchestration code.

Defines a composable action system where each action encapsulates a discrete task (e.g., WriteCode, DesignAPI, WriteCodeReview) with a name, prompt prefix, and LLM-based run method. Actions receive structured input, invoke LLMs with carefully engineered prompts, and return typed outputs. Actions can be chained sequentially or conditionally within roles, enabling complex workflows like 'design → implement → review → refactor' without hardcoding control flow.

Implements a context system that manages global configuration, environment variables, and execution context for agents. The system supports configuration inheritance (child contexts inherit parent settings), environment isolation (different agents can have different configurations), and dynamic configuration updates without restarting agents. Context includes LLM settings, API keys, memory backends, and RAG configurations, enabling agents to adapt to different environments (dev, staging, production) without code changes.

Automatically generates Mermaid diagrams that visualize agent workflows, message flows, and role interactions. The system introspects the agent team structure and generates diagrams showing which roles communicate with which, what messages are exchanged, and the sequence of actions. This enables developers to understand complex multi-agent workflows visually without manually drawing diagrams, and provides documentation that stays in sync with code.

Provides a testing framework for validating agent behavior, including unit tests for individual actions, integration tests for role interactions, and end-to-end tests for complete workflows. The framework enables assertions on agent outputs (code quality, design correctness), message flows (correct messages sent to correct roles), and state transitions (agents reach expected states). Tests can be run in isolation or as part of a full workflow, enabling regression testing as agents are modified.

Implements a publish-subscribe message system where roles declare watch lists (message types they care about) and the framework automatically routes messages to matching roles. Each message includes metadata (sender role, cause, intended recipients) and content. The routing system enables loose coupling between roles — a Product Manager publishes a PRD message without knowing which roles will consume it, and the Architect automatically receives it based on its watch list configuration.

Provides a unified interface to multiple LLM providers (OpenAI, Anthropic, Ollama, etc.) with automatic token counting, cost tracking, and response handling. The system abstracts provider-specific APIs behind a common interface, enabling roles and actions to switch LLM providers via configuration without code changes. Token counting is performed before API calls to estimate costs and enforce budgets, and actual token usage is tracked post-response for cost reconciliation.

Implements a persistent memory layer where agents store and retrieve experiences (past actions, outcomes, lessons learned) to improve future decision-making. The system uses vector embeddings to index experiences and supports semantic search, enabling agents to find relevant past experiences when facing similar tasks. Experience pooling allows agents to learn from each other's successes and failures without explicit knowledge transfer, creating a shared knowledge base that improves over time.

Implements an automated prompt optimization system where agents iteratively refine their prompts based on execution outcomes. The system evaluates action results (code quality, design correctness, review thoroughness) and uses those signals to adjust prompts for future executions. This creates a feedback loop where agents become more effective over time without manual prompt engineering, using self-supervised learning from task outcomes rather than labeled training data.

Provides native integration with Git repositories, enabling agents to read existing code, generate new code, and commit changes with proper version control semantics. The system can clone repositories, analyze code structure, generate code that follows existing patterns, and commit changes with meaningful commit messages. This enables agents to work directly with real codebases rather than isolated code snippets, maintaining consistency with existing code style and architecture.

Implements a RAG system that augments agent prompts with relevant context retrieved from knowledge bases, documentation, or code repositories. The system supports multiple RAG engines (vector search, BM25, hybrid) and can be configured to retrieve context from different sources (local files, web, databases). Retrieved context is injected into prompts before LLM calls, enabling agents to make decisions based on up-to-date information without retraining or fine-tuning.

Implements automatic role generation where the system creates specialized agent roles from natural language task descriptions without manual role definition. RoleZero analyzes the task, identifies required capabilities, and generates role definitions (system prompts, action sets, watch lists) automatically. This enables rapid prototyping of multi-agent systems without writing role classes, making MetaGPT accessible to non-expert users.

Provides a pre-configured team structure that simulates a software company with specialized roles (Product Manager, Architect, Engineer, QA, Project Manager) and their standard operating procedures (SOPs). Each role has domain-specific actions (e.g., Engineer has WriteCode, CodeReview; QA has TestGeneration) and watch lists configured for typical software development workflows. This enables end-to-end software development simulation from requirements to deployment without custom configuration.