JiuwenSwarm Quickstart: Huawei's Open-Source Multi-Agent Swarm Framework in Three Steps

Multi-agent collaboration is no longer a paper concept — Huawei’s open-source JiuwenSwarm just shipped a HarmonyOS PC edition, and it is a complete framework for multi-agent task delegation, negotiation, and self-evolving Skills. The clincher: pip install jiuwenswarm and it runs.

This guide goes from zero to a real multi-agent task — deployment, model configuration, and a live swarm run.

What JiuwenSwarm Is

JiuwenSwarm is a swarm-intelligence agent framework from Huawei’s openJiuwen community. It is not another single-agent toy — three capabilities set it apart:

Multi-agent collaboration: a Leader automatically decomposes tasks, assembles a team of specialist agents, and negotiates the division of labor.
Skill self-evolution: agents detect their own errors and user feedback during execution and iterate their own capabilities.
Everywhere access: desktop Web UI, TUI terminal, and Feishu/Lark IM, with native HarmonyOS PC adaptation.

It is open source on GitHub (openJiuwen-ai/jiuwenswarm) under Apache 2.0 with 1,678 commits. On PinchBench it scores 94.2% overall — nearly 3 points above OpenClaw — while consuming 34.8% fewer tokens.

Three Steps to Deploy

Step 1: Install

# A fast mirror speeds up the install
pip install jiuwenswarm

# First-time initialization
jiuwenswarm-init

Initialization walks you through model configuration. Supported today: Huawei Cloud MaaS, OpenAI, DeepSeek, DashScope, SiliconFlow, OpenRouter, and any OpenAI-compatible endpoint. Local models work too (via Ollama and similar).

Sample configuration (DeepSeek shown):

[Model]
provider = openai-compatible
base_url = https://api.deepseek.com
api_key = sk-your-key
model = deepseek-chat

Step 2: Launch

jiuwenswarm-start

Open http://localhost:5173 for the web interface, or use the TUI:

pip install jiuwenswarm-tui
jiuwenswarm-tui

Step 3: Pick an Execution Mode

Three modes, switched by task complexity:

Mode	Behavior	Best for
Swarm mode (default)	A Leader orchestrates multiple agents in coordinated roles	Large complex tasks, multi-role collaboration
Planning mode	Step-by-step decomposition, sequential execution	Complex tasks where each step's result needs confirmation
Performance mode	Flexible parallelism, fast responses	Simple tasks, one-off queries

Hands-On: an Agent Team Builds Your Blog

The most representative task class: “one sentence, and an agent team ships an application.”

The instruction

Build me a personal blog website. Cover tech selection, page design,
frontend and backend development, and deployment. Write a full
development plan first, then execute it step by step.

What happens

The Leader agent receives the instruction and decomposes it: tech selection → architecture → frontend → backend → integration → deployment.
Team assembly: it dynamically forms four agents — architect, frontend dev, backend dev, and tester.
Parallel development: the frontend agent writes React/Vue pages, the backend agent builds APIs, the tester runs test cases automatically.
Iterative merging: each stage auto-summarizes when done; if something breaks mid-run, the Leader directs the relevant agent to fix it.

You only intervene at key decision points — picking the tech stack, for instance. The swarm handles the rest.

Under the Hood: Swarm Skills and Self-Evolution

What truly separates JiuwenSwarm from other frameworks is its Skill system:

Swarm Skills: best practices of agent teamwork — role combinations, SOPs, toolchains — packaged as reusable “team skill kits.”
Swarm Skills Hub: a community marketplace where developers search, install, and combine other people’s skills.
Self-evolution engine: when an agent errors out or senses user dissatisfaction, it analyzes root causes and refines its own Skill definitions.

Example: write a “code review Skill” containing the reviewer agent’s rules, report format, and automated PR flow. Publish it to the Hub and the whole community can reuse it — and every execution feeds data back to improve the Skill.

Skill configuration example (JSON)

{
  "name": "code-reviewer",
  "description": "Automated code review across security, performance, and style",
  "agents": [
    {
      "role": "security-reviewer",
      "model": "deepseek-chat",
      "prompt": "Focus on SQL injection, XSS, and authz checks"
    },
    {
      "role": "performance-reviewer",
      "model": "claude-sonnet-5",
      "prompt": "Analyze algorithmic complexity, query efficiency, memory leaks"
    },
    {
      "role": "style-reviewer",
      "model": "gpt-5.6-mini",
      "prompt": "Check code style, naming conventions, comment quality"
    }
  ],
  "workflow": "parallel review -> summary report -> generate PR review"
}

HITS / HOTS: Where Humans Fit

During a multi-agent run you are not a bystander:

HOTS (Human on the Swarm): act as commander — monitor team status in real time, adjust task priorities, swap agent roles.
HITS (Human in the Swarm): join as a team member — in the built-in Werewolf game, you reason and vote alongside the AI players.

In the TUI, pressing P opens an approval panel to pause the workflow, inspect intermediate results, and steer the next step.

Practical Advice

Start small: run single tasks in performance mode (weather lookups, information retrieval) before graduating to swarm mode.
Mix models per role: give the Leader a strong reasoning model (Claude / DeepSeek) and executor agents fast, cheap ones (GPT-4o-mini / Flash).
Use the Skill Hub: don’t write skills from scratch — check the community first, then customize.
Mind permissions: in production, enable pre-execution tool approval and file-access whitelists — JiuwenSwarm ships both controls.
HarmonyOS PC users: this is the first native open-source AI workbench supporting HarmonyOS PC — grab the desktop build directly.

Resources

JiuwenSwarm’s real significance: it turns “multi-agent collaboration” from an architecture-paper concept into an engineering tool you install with pip. The Leader-decomposes-and-delegates pattern, the self-evolving Skill loop, and the Hub’s reuse economics together sketch what practical multi-agent engineering looks like when it stops being a demo. Whether you want to assemble an automated workflow quickly or study the mechanics of swarm coordination, it earns its ten minutes.