# agentUniverse: a multi-agent framework that ships PEER and DOE collaboration patterns

> agentUniverse is a Python multi-agent framework from AntGroup with two built-in collaboration patterns, PEER and DOE, and simple TOML-based LLM configuration. It suits teams that want opinionated agent orchestration rather than a blank scaffold.

**agentuniverse-ai/agentUniverse** — agentUniverse is a LLM multi-agent framework that allows developers to easily build multi-agent applications. 

- Repository: https://github.com/agentuniverse-ai/agentUniverse
- Stars: 2,374 · Forks: 455
- Language: Python
- License: Apache-2.0
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/agentuniverse-ai-agentuniverse

## The problem agentUniverse targets, and who it is for

Most LLM frameworks give you a single agent loop and leave the collaboration structure to you. agentUniverse takes the opposite position: it ships named collaboration patterns as components you configure rather than write. The README describes the core as "a rich set of multi-agent collaborative pattern components (serving as a collaborative pattern factory)", which is the clearest statement of intent in the repository.

The two patterns currently open for use are PEER and DOE. PEER assigns four roles, Plan, Execute, Express and Review, and the README says it breaks complex problems into steps, runs them in sequence and improves iteratively from feedback. The stated use cases are event interpretation and industry analysis. DOE uses three agents, Data-fining, Opinion-inject and Express, and targets data-intensive tasks that need computational precision plus expert opinion, with financial report generation given as the example.

The audience follows from that. This is for teams building domain-expert agents where the workflow itself is the product, not for someone prototyping a single chatbot. The project states it originates from the financial business practices of AntGroup, and the pattern names map onto that background: review loops, opinion injection, report generation. If your problem is a two-turn question-answer flow, the pattern machinery is overhead you will pay for and not use.

## How the pattern components and model configuration fit together

The repository layout separates concerns into four installable packages declared in pyproject.toml: agentuniverse, agentuniverse_connector, agentuniverse_extension and agentuniverse_product. The core framework lives in agentuniverse/, connectors to external systems in agentuniverse_connector/, and the product and extension packages sit alongside them. Examples are split between examples/sample_apps/, examples/sample_standard_app/, examples/startup_app/ and examples/third_party_examples/, so you can read a working app rather than infer structure from documentation alone.

Model integration is configuration-driven. The README states that to use the deepseek model you set DEEPSEEK_API_KEY in custom_key.toml, then set the llm_model name in the agent configuration file to default_deepseek_llm. That two-step pattern, a key file plus a model name referenced from agent YAML, is how the framework keeps vendor choice out of code. The supported vendor list in the README covers Qwen, Deepseek, OpenAI, Claude, Gemini, Llama, KIMI, WenXin, chatglm, BaiChuan and Doubao.

One structural detail worth noting: the dependency set pins langchain to 0.1.20, langchain-core to 0.1.52 and langchain-community to 0.0.38. Those are exact pins, not ranges. The README does not explain why, but the effect is that agentUniverse will fight with any project in the same environment that needs a newer LangChain. Treat the framework as the owner of that dependency tree.

## Installing agentUniverse and running a first agent

Installation is a single pip command, and the README gives it verbatim.

```shell
pip install agentUniverse
```

After installation you need model credentials. The README states that to use the deepseek model you set DEEPSEEK_API_KEY in the custom_key.toml file, and then set the llm_model name in the agent configuration file to default_deepseek_llm. The README does not print the contents of custom_key.toml, so the key file format is not reproduced here; the tutorial document linked under Quick Start is where the working example lives.

With the key in place and the model name set in the agent configuration, the next step is the tutorial. The README points to docs/guidebook/en/Get_Start/2.Run_Your_First_Tutorial_Example.md for the detailed steps and notes that the tutorial is how you experience the performance of agents or agent groups. That document is the authoritative walkthrough; the README itself does not reproduce the commands. The same tutorial page carries the switch-the-llm section referenced from the model table, so it is the single place to check when you change vendors.

## Where agentUniverse is the wrong choice

The pattern library is small and the README says so directly: PEER and DOE are the components "currently open for use", followed by "More patterns are coming soon". If your problem does not resemble event interpretation, industry analysis or financial report generation, you are working against the grain. You can build your own pattern, but at that point you are using a framework whose main selling point does not apply to you, and you are carrying its dependency pins anyway.

The dependency situation is the second constraint. langchain 0.1.20, langchain-core 0.1.52 and langchain-community 0.0.38 are exact pins, and openai is pinned at 1.55.3 while grpcio sits at 1.63.0 and chromadb at 0.4.24. In a shared environment these will conflict with anything newer. The README does not document a resolution path.

Third, the release cadence is slow. The latest release listed is v0.0.19 from 2025-11-17, preceded by v0.0.18 on 2025-07-10 and v0.0.17 on 2025-05-22. The last push to the default branch was on 2026-07-28. Activity continues, but the version number is still 0.0.x, which is a signal about API stability rather than a guarantee either way. The README does not document a deprecation policy or a rollback procedure for configuration changes.

## agentUniverse compared with a general orchestration library

The natural alternative is LangGraph, or building directly on the LangChain primitives that agentUniverse already depends on. The difference is where the structure comes from. With a general orchestration library you define nodes, edges and state transitions yourself, and the library provides the execution engine. The collaboration shape is your design, expressed in code.

agentUniverse inverts that. The collaboration shape is a named component you select, and your work is configuration plus domain content. PEER's four roles and DOE's three roles are fixed by the framework, and the README frames them as tested in real business scenarios rather than as reference implementations. That is a real difference in approach: you get a considered workflow immediately, and you give up the freedom to reshape it without leaving the component.

There is a practical consequence for debugging. In a hand-built graph you can trace every transition because you wrote them. In a pattern component, the sequence is defined by the framework, so your visibility depends on what the framework exposes. The repository does include OpenTelemetry dependencies (opentelemetry-api, opentelemetry-sdk, and both OTLP exporters), which suggests tracing is intended to be available, but the README does not describe how to enable it or what spans are emitted. Verify that before you need it in production.

## Maintenance, licensing and the upgrade path

The repository is not archived and the last push was on 2026-07-28. That is recent enough to say the project is receiving commits, but the gap between the last release (v0.0.19, 2025-11-17) and the last push means work is landing on master that has not been cut into a tagged version. If you depend on pip-installed releases, you are on the November 2025 state of the code, not the current master.

Upgrading carries the usual 0.0.x risk. There is a CHANGELOG.md and a CHANGELOG_zh.md at the top level, so release-level changes are documented, but the README does not describe a migration process between versions. The exact dependency pins mean an upgrade of agentUniverse will also move LangChain, openai, grpcio and chromadb together, so plan upgrades as environment rebuilds rather than in-place edits.

Licensing is Apache-2.0, declared in the LICENSE file and in the pyproject.toml classifiers. That is a permissive licence with an explicit patent grant, and it is compatible with commercial use. The pyproject authors field lists AntGroup as the author. This is a description of what the repository states, not legal advice; if your organisation has licence review requirements, route the LICENSE file through them rather than relying on a summary.

## Conclusion

Adopt agentUniverse if you want the PEER or DOE collaboration pattern as a starting point and are comfortable with Python 3.10 and the pinned LangChain 0.1.x stack. Skip it if you need a general-purpose orchestration library with a large third-party ecosystem, or if you cannot accept that the current release line is v0.0.19 from 2025-11-17. Before committing, install it in a clean environment, run the first tutorial example, and confirm which optional extras (pymilvus, pgvector, psycopg, aliyun-log-python-sdk) your deployment actually needs, since those are declared optional in pyproject.toml.

## FAQ

### How do I install agentUniverse?

The README gives a single command, pip install agentUniverse. Python 3.10 or later is required according to the pyproject.toml dependency declaration and the Python badge in the README.

### Which LLM providers does agentUniverse support?

The README lists Qwen, Deepseek, OpenAI, Claude, Gemini, Llama, KIMI, WenXin, chatglm, BaiChuan and Doubao. Switching models is done by setting the vendor API key in custom_key.toml and changing the llm_model name in the agent configuration file.

### What collaboration patterns ship with agentUniverse?

The README states that PEER and DOE are currently open for use. PEER assigns Plan, Execute, Express and Review roles; DOE uses Data-fining, Opinion-inject and Express. The README says more patterns are coming soon.

### What is agentUniverse?

It is a Python multi-agent framework based on large language models, described in the README as originating from the real-world financial business practices of AntGroup. Its core is a set of multi-agent collaborative pattern components.

## Sources

- [agentuniverse-ai/agentUniverse on GitHub](https://github.com/agentuniverse-ai/agentUniverse)
- [Issues](https://github.com/agentuniverse-ai/agentUniverse/issues)
- [License: Apache-2.0](https://github.com/agentuniverse-ai/agentUniverse/blob/master/LICENSE)
- [README](https://github.com/agentuniverse-ai/agentUniverse/blob/master/README.md)
- [Releases](https://github.com/agentuniverse-ai/agentUniverse/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/agentuniverse-ai-agentuniverse