CAMEL

Orchestrates teams of autonomous agents through the Workforce class, which manages task distribution, agent lifecycle, and inter-agent communication using a centralized coordinator pattern. Agents are instantiated as Worker instances (SingleAgentWorker, GroupChatWorker) that execute tasks asynchronously and report results back to the workforce manager, enabling complex multi-agent workflows without manual choreography.

Abstracts 50+ LLM providers (OpenAI, Anthropic, Claude, Ollama, local models, etc.) through a ModelFactory and unified model interface, enabling agents to switch providers without code changes. Uses a factory pattern that maps UnifiedModelType enums to provider-specific backend implementations, handling authentication, API differences, and response normalization transparently.

Implements comprehensive observability through structured logging, execution tracing, and metrics collection at each step of agent execution. Captures agent decisions, tool calls, LLM responses, and errors in a queryable format, enabling debugging, monitoring, and analysis of agent behavior without code instrumentation.

Leverages agent conversations and tool executions to generate synthetic training data for model fine-tuning or evaluation. Captures agent-generated examples with diverse reasoning patterns, tool usage, and error recovery, enabling creation of domain-specific training datasets without manual annotation.

Enables agents to decompose complex tasks into subtasks using chain-of-thought reasoning, with hierarchical execution where parent tasks coordinate child task execution. Agents can plan multi-step workflows, delegate subtasks to other agents, and aggregate results, enabling complex problem-solving without manual workflow definition.

Integrates web search capabilities through SearchToolkit, enabling agents to query search engines (Google, Bing, DuckDuckGo) and retrieve current information. Handles search result parsing, ranking, and deduplication, with automatic integration to agent tool-calling pipeline for seamless information retrieval during task execution.

Enables agents to interact with web browsers through BrowserToolkit, supporting navigation, form filling, element interaction, and screenshot capture. Uses Selenium or similar automation libraries under the hood, with automatic error handling and recovery, enabling agents to perform complex web tasks without manual scripting.

Enables agents to execute terminal commands and system operations through TerminalToolkit, with sandboxing, error handling, and output capture. Agents can run scripts, manage files, and interact with system tools, enabling automation of system administration and development tasks.

ChatAgent implements a single autonomous agent that maintains conversation state, executes tools via function calling, and streams responses incrementally. Uses a step() method that orchestrates the execution pipeline: message preprocessing → LLM inference → tool execution → memory updates → response formatting, with configurable hooks for each stage and native support for streaming output.

Manages agent conversation history and context through a pluggable memory architecture supporting multiple backends (in-memory, vector databases, external storage). Memory system handles message storage, retrieval, and context window management, with support for semantic search via embeddings and structured message filtering, enabling agents to maintain long-term context and retrieve relevant past interactions.

Implements RolePlaying class that orchestrates structured dialogue between two agents with distinct roles, enabling controlled multi-turn conversations where each agent has a specific persona and objective. Manages turn-taking, message passing, and conversation termination conditions, useful for studying agent collaboration, debate, or adversarial interactions.

Provides a modular toolkit system where each Toolkit encapsulates a domain of functionality (search, terminal, browser, media, communication, etc.) with multiple tools exposed as callable functions. Tools are automatically converted to function schemas for LLM function calling, with built-in error handling, async support, and integration to agent execution pipeline.

Implements message preprocessing pipeline that normalizes, filters, and truncates conversation history before LLM inference, with provider-specific token counting to track context window usage. Handles context overflow by implementing strategies like sliding window, summarization, or selective pruning, ensuring agents stay within model token limits while preserving relevant context.

Enables agents to generate structured outputs (JSON, dataclasses, Pydantic models) by providing LLMs with output schemas and validating responses against them. Uses provider-specific structured output APIs (OpenAI JSON mode, Anthropic structured generation) when available, with fallback to prompt-based schema enforcement for other providers.

Provides DataLoader classes that ingest documents in multiple formats (PDF, CSV, JSON, Markdown, web pages, etc.) and convert them to a unified internal representation for agent processing. Loaders handle format-specific parsing, text extraction, chunking, and metadata preservation, enabling agents to work with diverse data sources without format-specific code.

Enables agents and workflows to execute asynchronously using Python async/await patterns, with batch processing utilities for running multiple agent tasks in parallel. Provides decorators and utilities for converting synchronous code to async, managing concurrent execution, and aggregating results from parallel agent runs.