OpenAgents
An open platform for language agents in the wild, shipping three working agents — data analysis, 200+ plugins, and autonomous web browsing — usable online or self-hosted.
- Source repo
- xlang-ai/OpenAgents
- Stars
- ★ 4.9k
- Last updated
- 2d ago
- License
- Apache-2.0
- Primary language
- Python
- FA score
- 52/100 · Major gaps
At a glance
- How it runs
- Works with
- Universal · cross-platformOpenAI API
- Cost
- Free software; you pay for model usage
- Setup effort
- Medium · a few setup steps
- You'll need
- Typical use
- A data analyst: hand the Data Agent a dataset and have it clean, process, and visualize the data with Python/SQL.
- Not a fit if
- Developers who only want a terminal CLI
- Users without the capacity to run Docker or deploy from source
- Source review
- 52/100 · Major gaps
What does this agent do, and when should you use it?
OpenAgents ([COLM 2024], arXiv:2310.10634) is an open-source platform from the XLANG NLP Lab for using and hosting language agents in everyday life. It implements three real agents: a Data Agent for analysis with Python/SQL and data tools, a Plugins Agent integrating 200+ daily-use third-party plugins, and a Web Agent for autonomous browsing via a Chrome extension. The system uses a client-server architecture with a Flask backend and a Next.js frontend: general users interact through a chat web UI optimized for swift responses and common failures, while developers and researchers can deploy locally and extend it with new agents, models, and tools. The code is organized into self-contained backend/, frontend/, and real_agents/ directories, where real_agents follows a one-agent-one-folder design with shared adapters for stream parsing, memory, and callbacks. A free hosted demo is available at chat.xlang.ai, and both source-code and Docker Compose deployment paths are documented. The project builds on open-source communities such as LangChain and is released under Apache-2.0.
OpenAgents runs three real agents behind a chat-based web UI. The Data Agent takes data tasks, writes and executes Python/SQL code, and handles searching, acquiring, processing, manipulating, and visualizing data. The Plugins Agent calls over 200 third-party plugins (e.g., Klarna Shopping, XWeather, Wolfram Alpha), supports concurrent multi-plugin use, and offers Auto Plugin Selection where the model picks suitable plugins. The Web Agent controls the browser through the WeBot Chrome extension to autonomously navigate Google Maps routes, post tweets, and fill in Google Forms. The backend (Flask app.py, RESTful APIs in api/, code-execution queue kernel_publisher.py, streaming renderer display_streaming.py, storage memory.py) serves the frontend (Next.js pages, React components, and the webot_extension.zip Chrome extension) via RESTful APIs, streaming back rendered text, images, tables, and JSON. In real_agents/, each agent lives in its own folder and reuses shared adapter components (data model, memory, callbacks) from adapters/.
- A data analyst: hand the Data Agent a dataset and have it clean, process, and visualize the data with Python/SQL.
- A trip planner: ask the Plugins Agent to combine Klook, a currency converter, and WeatherViz in one task.
- A commuter: have the Web Agent navigate Google Maps from a stated origin to a destination and present the best routes.
- A social media user: let the Web Agent post specified content to Twitter or populate a Google event sign-up form.
- A researcher: deploy the platform locally and implement a new language agent in its own folder under real_agents/ for real-world evaluation.
- A developer: register a self-hosted LLM in backend/api/language_model.py (using lemur-chat as a template) to power the agents.
How do you install or deploy this agent?
Option 1 — from source: follow backend/README.md and frontend/README.md to set up the Flask backend and the Next.js frontend (including the WeBot Chrome extension).
Option 2 — Docker Compose (the docs note Docker is still under development; source deployment is recommended for robustness):
- To use Kaggle datasets, set your credentials in the Dockerfile:
ENV KAGGLE_USER="" \
KAGGLE_KEY=""- If not running locally, set the reachable backend IP in frontend/Dockerfile:
ENV NEXT_PUBLIC_BACKEND_ENDPOINT http://x.x.x.x:8000- Build and start from the project root:
docker compose build
docker compose up -d- Put your OPENAI_API_KEY in docker-compose.yml; if using unofficial OpenAI services such as FastChat, also set OPENAI_API_BASE. For GPU support, install the Nvidia Container Toolkit and uncomment lines 56-62 of docker-compose.yml.
How do you use this agent?
Once deployed, open the chat web UI and pick one of the three agents: the Data Agent accepts data tasks and runs Python/SQL; the Plugins Agent takes manual plugin choices or uses Auto Plugin Selection; the Web Agent requires the WeBot Chrome extension and takes natural-language browsing instructions. Alternatively, use the free hosted demo at https://chat.xlang.ai. Note that chat history keys changed on 2023/10/26 — if you pulled code before that date, updating will lose previous local chat history. For help, join the Discord or open a GitHub issue.
What are this agent's strengths and limitations?
- Ships three actually usable real-world agents (data analysis, plugins, web browsing) rather than a proof-of-concept framework, with a free online demo to try immediately.
- Fully open full stack: Flask backend, Next.js frontend, and Chrome extension are all self-hostable, with a clean, extension-oriented code layout (backend/frontend/real_agents).
- Documented extension paths for new agents, new LLMs (just register in backend/api/language_model.py), and new plugins (requiring ai-plugin.json and openapi.yaml).
- The web UI is optimized for swift responses and common failures, lowering the barrier for non-expert users.
- Requires your own OPENAI_API_KEY (or a compatible service like FastChat) with per-use costs; no free model is bundled.
- The Docker deployment is explicitly documented as under development with possible broken functionality and slower responses; robust deployment means building from source.
- Auto Plugin Selection downloads weights from HuggingFace and may hit connection timeouts in some regions, leaving network issues to you.
- The Web Agent depends on a Chrome extension, constraining browsing to the Chrome ecosystem; no capability guarantees beyond the documented examples.
How does this agent compare with similar options?
The README states the real_agents implementation is built on top of LangChain, and credits ChatBot UI and the Taxy.ai browser extension as interface prototypes. The team also promotes Lemur (OpenLemur/Lemur), their open-sourced foundation model for language agents claimed to match ChatGPT on 15 agent tasks.
Key facts side by side with the most closely related agents.
| Agent | Source review | Form / cost | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|---|
| OpenAgents This agent | 52 · Major gaps | Web appFree + model costs | ★ 4.9k | 2d ago | Python | OpenAI API |
| Apache Texera | 46 · Major gaps | — | ★ 327 | today | Scala | — |
| BambooAI Data Analyst | 85 · Good | Web appFree + model costs | ★ 828 | 1d ago | Python | OpenAI API · Claude API |
| Lumen Data Exploration Framework | 62 · Some gaps | CLI | ★ 323 | 2d ago | Python | — |
How does FollowAgents rate this agent?
Why each dimension lost points
Trust evidence is thin. The README describes a code-execution kernel (Python/SQL for the Data Agent), autonomous browser control (posting tweets, filling forms), and 200+ third-party plugin calls, but no file shows least-privilege scoping, user confirmation flows, data-flow disclosure, or sensitive-data handling. Docker deployment asks users to hardcode Kaggle credentials and OPENAI_API_KEY into Dockerfile/docker-compose.yml with no security guidance. Deducted for: external side effects with no confirmation or undo mechanism, and chat-history loss on pull, mentioned only as a footnote. source_attribution earns 2: LangChain, ChatBot UI, and Taxy.ai are explicitly credited.
The README is largely self-consistent (three agents, code structure matches extension tutorial), but dependency availability has admitted weaknesses: the Docker image is 'under development' with possible broken functionality, HuggingFace weight downloads may time out, and the hosted demo suffered overload. Frontend vitest config suggests tests exist, but no failure-handling evidence is visible; only a claim that the UI is 'optimized for common failures'. Scores of 2 across the board with these deductions noted.
Audience and scenarios are well covered: end users (web UI), developers and researchers (local deployment, concrete extension steps for new agents/LLMs/tools). Environment fit earns 2 (multi-language READMEs, source and Docker paths). Deducted for: no evidence on trigger precision (Auto Plugin Selection logic is opaque), capability boundaries are given only as a positive 'what it can do' list with no failure modes or out-of-scope tasks, and the LLM hosting tutorial link is empty.
License is a complete Apache-2.0 text with copyright notice: 3. Information architecture is clear (one-agent-one-folder under real_agents/), install notes are split per component but have gaps (empty tutorial link, manual credential edits in Dockerfile). Naming stability is proactively flagged (argument renames break chat history). Known limitations are partially disclosed (Docker under development). Largest deduction: no version numbers, tags, or changelog anywhere; News is a marketing feed only, so versioning_changelog is 0. Maintenance responsibility relies on issue templates, CONTRIBUTING, and a stale bot (aggressively staling issues after 3 days), with docs externalized.
Output usability is supported by the streaming UI and multi-datatype rendering design: 2. Marginal value lies in open-sourcing a full-stack, extensible three-agent platform: 2. Cost-benefit is deducted: real use requires an OPENAI_API_KEY (or self-hosted FastChat), possibly a GPU, a Chrome extension, and a self-run backend, while the Docker path is unreliable and the demo has been overloaded — real cost exceeds the 'easy deployment' narrative.
Core claims are traceable to the arXiv paper, documentation site, and concrete code paths: 2. However, nearly everything in the provided files is self-reported (user counts; 'matching ChatGPT' is a promotional claim about the external Lemur project) with no independent corroboration, so cross_source_corroboration gets 1. Facts and inference are reasonably separable (capability lists map to code directories, marketing language is identifiable): 2. Static review only; nothing was executed.
- Docker deployment requires hardcoding Kaggle credentials and the OpenAI API key into config files — a credential-leak risk; use env vars or a secret manager instead.
- The Web Agent can autonomously post tweets and submit forms; no confirmation or undo mechanism is documented — harden before any real use.
- No version numbers or changelog exist, and key renames silently break prior chat history; the stale bot marks issues stale after 3 days — assess maintenance responsiveness yourself.
- Claims such as '3,000 users' and 'matching ChatGPT' are self-reported and independently unverified.