First Hands‑On with Camel AI‑OWL: Exploring a Multi‑Agent Framework

In the previous post we tried JDGenie; this article evaluates another open‑source general‑purpose agent, OWL, built on the Camel AI framework and released in early 2025. Although the project once attracted attention and ranked well on the GAIA list, recent community activity has shifted toward the underlying Camel AI framework.

Installation

OWL does not provide container images or install scripts, so it must be started manually as a Python project. The required steps are:

# Clone github repo
git clone https://github.com/camel-ai/owl.git

# Change directory into project directory
cd owl

# Install uv if you don't have it already
pip install uv

# Create a virtual environment and install dependencies
uv venv .venv --python=3.10

# Activate the virtual environment
# For macOS/Linux
source .venv/bin/activate
# For Windows
.venv\Scripts\activate

# Install CAMEL with all dependencies
uv pip install -e .

Overall Architecture

OWL is a multi‑agent framework where a user question is first handled by a User Agent that analyses the query and coordinates with an Assistant Agent . The Assistant Agent decomposes the task and invokes external tools such as a browser, text processor, or code analyzer. The architecture diagram (see image) illustrates this collaboration.

Case Test 1: GitHub Statistics

After installation we launch OWL via its web interface (webapp_zh.py). Model parameters are set through the UI’s environment‑variable manager, configuring five items: the large model (DEEPSEEK), CHUNKR for document parsing, FIRECRAWL web crawler, and Google API credentials.

We run the built‑in example run_deepseek_zh with the following question:

Question 1: Open Baidu, summarize the GitHub star and fork counts of the camel‑ai repository, write a Python script using plot to visualize the numbers, save and execute it.

The backend logs show a multi‑round dialogue between User Agent and Assistant Agent. Key observations:

Round 1: User Agent asks the browser to fetch the repository page; Assistant Agent finds information but cannot obtain exact star/fork numbers via Baidu.

Round 2: User Agent explicitly requests the numbers via Python; Assistant Agent notes that Baidu cannot provide real‑time data and suggests using GitHub.

Round 3: User Agent asks to call the GitHub API with requests. The tool is reported as unavailable because it has not been registered in OWL, leading the assistant to estimate the numbers.

Round 4: After obtaining (estimated) counts, Assistant Agent generates a Python script that creates a bar chart and saves it in the project.

The generated script runs and produces the bar chart shown below.

Although the task completes, the reliance on an unregistered requests tool and the subsequent estimation cause the final numbers to be inaccurate.

Case Test 2: Physics Animation

Second prompt:

Question 2: As a middle‑school physics teacher, create a series of clear animation slides illustrating the law of conservation of momentum and package them into a simple HTML presentation.

Assistant Agent generates an HTML page, but the resulting page lacks actual animation; clicking the start button shows a static placeholder. Multiple attempts still produce errors, indicating the current model’s limited ability to synthesize functional animation code.

Summary

1. OWL introduces an innovative multi‑agent architecture where the User Agent plays a pivotal role in breaking tasks into subtasks and directing Assistant Agents to invoke external tools.

2. In the test cases the framework follows its architectural design and can finish tasks, but the User Agent sometimes selects inappropriate or unavailable tools, requiring manual addition of missing utilities.

3. The web UI is modest; dialogue records are not displayed cleanly, forcing users to rely on backend logs for analysis.

4. The second physics‑animation case demonstrates limited performance, with frequent errors observed in the logs.

5. The OWL project has seen little recent development, as the community concentrates on the Camel AI framework itself; integrating the latest Camel AI updates into OWL could improve its capabilities.