CAMEL

CAMEL has two multi-agent modes. RolePlaying pairs an AI user, who issues instructions, with an AI assistant, who answers them; turns alternate strictly and built-in prompt rules stop the two from swapping roles. Optional agents can refine the task first, plan it, or critique each assistant reply.

Workforce is the larger orchestration engine. It holds a list of child nodes (SingleAgentWorker wraps one ChatAgent, RolePlayingWorker wraps a role-playing pair, and Workforce itself subclasses the same BaseNode). A task agent decomposes the incoming Task, a coordinator agent picks a worker for each subtask, ready subtasks run in parallel, and each result is stored so dependent subtasks can use it. When a subtask fails, the workforce chooses between retrying, replanning and decomposing again.

State sits in each agent's memory object (chat history, vector store, or both). Setting share_memory=True on a Workforce lets its single-agent workers share memory, and the storages module provides key-value and vector backends for persistence.

The Workforce guide shows human involvement through HumanToolkit: attach its tools (for example ask_human_via_console) to the coordinator, task agent or workers, and an agent pauses to ask a person when it decides to call that tool. A separate cookbook uses the external HumanLayer SDK (API key required) to make chosen tools wait for human approval. In the source, the Workforce class also has pause(), resume(), stop_gracefully(), add_task() and methods that list pending tasks for review. No approval gate is enabled by default.

pip install camel-ai

from camel.agents import ChatAgent
from camel.societies.workforce import Workforce
from camel.tasks import Task
from camel.toolkits import SearchToolkit

# Default backend is OpenAI: export OPENAI_API_KEY first.
searcher = ChatAgent(
    "You search the web and report short findings with links.",
    tools=[SearchToolkit().search_duckduckgo],
)
writer = ChatAgent("You turn research notes into a five-sentence summary.")

team = Workforce("Mini research team")
team.add_single_agent_worker("Searches the web for facts", worker=searcher)
team.add_single_agent_worker("Writes the final summary", worker=writer)

done = team.process_task(Task(content="Explain what CAMEL's RolePlaying society does.", id="0"))
print(done.result)

• Requires Python >=3.10 and <=3.14. On Python 3.13+, the unstructured and pyobvector dependencies are unavailable, so features that need them only work on 3.10-3.12.
• The base package is minimal; the DuckDuckGo search tool needs pip install 'camel-ai[web_tools]', and camel-ai[all] pulls every extra.
• With no model given, agents use the default platform (OpenAI) and need OPENAI_API_KEY; other providers need their own keys.
• Tags after v0.2.90 are alpha pre-releases (0.2.91aN); pip installs pre-releases only with --pre or an exact version pin.

Yes. MCPToolkit loads tools from MCP servers into CAMEL agents, and ChatAgent.to_mcp() exposes an agent as an MCP server. A2A and AG-UI support were not found; A2A is an open feature request.

The framework is Apache-2.0 licensed and has no paid tier of its own; you pay only for the model APIs you call. The README lists Eigent as a separate product built on CAMEL, which this record does not cover.

Python. The installation guide supports Python 3.10 through 3.14, with some optional extras limited to 3.10-3.12.

RolePlaying runs two agents (an AI user and an AI assistant) in strict turns on one task. Workforce decomposes a task, assigns subtasks to several workers through a coordinator agent, runs them in parallel and recovers from failures.

Yes, if you give agents HumanToolkit tools they can ask a person for input; the Workforce class also has pause, resume and add_task methods. Tool approval gates need the external HumanLayer SDK shown in a cookbook.