# CAMEL: features, protocols, quickstart

## TL;DR

CAMEL is an Apache-2.0 Python framework from the CAMEL-AI research community for building groups of LLM agents. It offers two-agent role-playing sessions, a Workforce that splits tasks across worker agents, synthetic data generators and MCP tooling. It suits researchers studying agent societies or generating training data, and Python teams building task-splitting agent teams.

## Key facts

| Field | Value |
| --- | --- |
| Type | Framework |
| Languages / SDKs | Python |
| License | Apache-2.0 |
| Pricing model | Open source, free |
| Orchestration pattern | Supervisor |
| GitHub stars | 17,799 (as of 2026-10-01) |
| GitHub forks | 2,102 |
| Last push | 2026-09-30 |
| Latest release | v0.2.90 |
| Repository | [camel-ai/camel](https://github.com/camel-ai/camel) |
| Website | [www.camel-ai.org](https://www.camel-ai.org) |
| Documentation | [docs.camel-ai.org](https://docs.camel-ai.org/) |
| Last verified | 2026-09-30 |

## Key features

- Workforce: a task agent breaks a job into subtasks, a coordinator agent assigns them to worker nodes by description, and finished results feed later subtasks as dependencies. ([source](https://docs.camel-ai.org/key_modules/workforce))
- RolePlaying society: an AI user and an AI assistant work a task in strict turns, with optional task-specifier, planner and critic agents. ([source](https://docs.camel-ai.org/key_modules/societies))
- MCPToolkit connects agents to MCP servers listed in a JSON config, over stdio or remote transports. ([source](https://docs.camel-ai.org/mcp/camel_agents_as_an_mcp_clients))
- A ChatAgent can be exposed as an MCP server with to_mcp() or the scripts in the services/ folder. ([source](https://docs.camel-ai.org/mcp/export_camel_agent_as_mcp_server))
- Memory classes for chat history, vector-store recall, and LongtermAgentMemory that combines the two under a token-limited context creator. ([source](https://docs.camel-ai.org/key_modules/memory))
- Data generation modules for chain-of-thought, Self-Instruct, Source2Synth and self-improving CoT datasets. ([source](https://docs.camel-ai.org/key_modules/datagen))
- Model backends include hosted APIs and local runtimes such as Ollama, vLLM, SGLang and LM Studio. ([source](https://docs.camel-ai.org/key_modules/models))

## Architecture and orchestration pattern

Pattern: Supervisor.

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.

### Human in the loop

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.

## Protocols

| Protocol | Support | Evidence | Note |
| --- | --- | --- | --- |
| MCP | Yes (checked 2026-09-30) | [link](https://docs.camel-ai.org/mcp/camel_agents_as_an_mcp_clients) | Client and server: MCPToolkit loads tools from MCP servers into agents, and a separate docs page shows ChatAgent.to_mcp() exposing an agent as an MCP server. |
| A2A | Unknown (checked 2026-09-30) | — | Not in README or docs index; GitHub code search found no A2A code. An open feature request (#2788) and unmerged PRs (#2889, #3768) propose A2A workers. |
| AG-UI | Unknown (checked 2026-09-30) | — | Searched README, docs llms.txt, GitHub code and issues for ag-ui / ag_ui, and the AG-UI README integration list; CAMEL is not listed and nothing was found. |

## Best for

- Task-splitting research teams such as a searcher, analyst and writer run by one Workforce, as in the official example. ([shortlist](https://multiagentguide.top/best/research-agents.md))
- Academic work on agent societies and role-playing dialogues, the use the project started from.
- Generating synthetic instruction, chain-of-thought or multi-hop QA data with agents.
- Running agents on local models through Ollama, vLLM, SGLang or LM Studio backends. ([shortlist](https://multiagentguide.top/best/self-hosted-local.md))

## Not for

- Teams that need a TypeScript, Java or .NET SDK.
- Projects that need a stable 1.x API; the package is still 0.2.x and recent tags are alpha pre-releases.
- Anyone looking for a hosted, managed agent service; CAMEL is a library you run yourself.

## Quickstart

```sh
pip install camel-ai
```

Install not yet verified by this site.

```python
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)
```

### Common pitfalls

- 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.

Official quickstart: https://docs.camel-ai.org/get_started/installation

## Pros

- Two multi-agent modes in one package: turn-based RolePlaying pairs and task-splitting Workforce teams. ([source](https://docs.camel-ai.org/key_modules/societies))
- MCP works in both directions: agents consume MCP tools and can be published as MCP servers. ([source](https://docs.camel-ai.org/mcp/export_camel_agent_as_mcp_server))
- Workforce has documented failure handling (retry, replan, re-decompose) instead of stopping at the first failed subtask. ([source](https://docs.camel-ai.org/key_modules/workforce))
- Local model runtimes (Ollama, vLLM, SGLang, LM Studio) are listed next to hosted providers. ([source](https://docs.camel-ai.org/key_modules/models))
- Built-in synthetic data pipelines (CoT, Self-Instruct, Source2Synth) that most agent frameworks do not ship. ([source](https://docs.camel-ai.org/key_modules/datagen))

## Cons

- Still pre-1.0: the latest stable tag is v0.2.90 and later tags are alpha pre-releases (v0.2.91a7 in September 2026). ([source](https://github.com/camel-ai/camel/releases))
- No A2A support yet; importing A2A agents as workers is an open feature request. ([source](https://github.com/camel-ai/camel/issues/2788))
- An open bug report says Workforce does not work with Mistral AI models plus tools (open since February 2025). ([source](https://github.com/camel-ai/camel/issues/1669))
- An open, untriaged security report says MCP servers created by CAMEL have no authentication. ([source](https://github.com/camel-ai/camel/issues/4351))
- Some optional dependencies do not install on Python 3.13+, per the installation guide. ([source](https://docs.camel-ai.org/get_started/installation))

## Alternatives

- [AgentScope](https://multiagentguide.top/tools/agentscope.md)
- [AutoGen](https://multiagentguide.top/tools/autogen.md)
- [AG2](https://multiagentguide.top/tools/ag2.md)
- [CrewAI](https://multiagentguide.top/tools/crewai.md)
- [MetaGPT](https://multiagentguide.top/tools/metagpt.md)

## FAQ

### Does CAMEL support MCP?

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.

### Is CAMEL free?

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.

### What language is CAMEL written in?

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

### What is the difference between RolePlaying and Workforce in CAMEL?

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.

### Can a person step into a CAMEL Workforce run?

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.

## Sources

- [CAMEL GitHub repository (README)](https://github.com/camel-ai/camel)
- [CAMEL documentation](https://docs.camel-ai.org/)
- [Installation](https://docs.camel-ai.org/get_started/installation)
- [Workforce](https://docs.camel-ai.org/key_modules/workforce)
- [Societies (RolePlaying)](https://docs.camel-ai.org/key_modules/societies)
- [CAMEL agents as an MCP client](https://docs.camel-ai.org/mcp/camel_agents_as_an_mcp_clients)
- [CAMEL agent as an MCP server](https://docs.camel-ai.org/mcp/export_camel_agent_as_mcp_server)
- [Memory](https://docs.camel-ai.org/key_modules/memory)
- [Data generation](https://docs.camel-ai.org/key_modules/datagen)
- [Models](https://docs.camel-ai.org/key_modules/models)
- [Cookbook: human-in-the-loop and tool approval with HumanLayer](https://docs.camel-ai.org/cookbooks/advanced_features/agents_with_human_in_loop_and_tool_approval)
- [Workforce source (pause, resume, add_task)](https://github.com/camel-ai/camel/blob/master/camel/societies/workforce/workforce.py)
- [Official example: multiple single-agent workers](https://github.com/camel-ai/camel/blob/master/examples/workforce/multiple_single_agents.py)
- [Releases](https://github.com/camel-ai/camel/releases)
- [Issue #2788: A2A agent workers (feature request)](https://github.com/camel-ai/camel/issues/2788)
- [Issue #1669: Workforce with Mistral AI and tools](https://github.com/camel-ai/camel/issues/1669)
- [Issue #4351: MCP servers without authentication](https://github.com/camel-ai/camel/issues/4351)

## Unknown fields

protocols.a2a is unknown: the README and docs index do not mention A2A, GitHub code search found only unrelated hash strings, and the only A2A items are an open feature request (#2788) and unmerged PRs (#2889, #3768). protocols.agui is unknown: README, docs llms.txt, code and issue search for ag-ui / ag_ui returned nothing, and CAMEL is not in the AG-UI README integration list.

Corrections or removal requests: support@multiagentguide.top

---

Data as of 2026-10-01. Not affiliated with listed projects. HTML version: https://multiagentguide.top/tools/camel