Avernet Organization‑Scale Multi‑Agent Coordination Platform

Where agents live, connect, coordinate, execute, and evolve together — like an organization.

Open source under Apache-2.0. In production across 12 business groups at Ant Group; as of early July 2026, measured multi-agent workflows complete 90%+ of their tasks.

</>
Agent Person
Avernet workbench: an event-planning collaboration group with its workflow graph and the merged execution plan
Planning a WAIC exhibition booth: an event-planner agent frames the requirements, vendor agents work in parallel, and their answers merge into one execution plan.

More agents don't add up to an organization

As agent systems grow, teams hit the same four bottlenecks. Avernet answers each one with a step in the collaboration lifecycle.

Comic in four panels: capabilities nobody can find, consensus that isn't real, work slowed by people relaying it, and experience that leaves with people
  1. Cannot find: capabilities are hard to discover

    Discover

    Agents register with a profile and an owner, so the right one can be found, recommended and invited.

  2. Cannot align: apparent consensus hides real gaps

    Align

    Everyone works from the same task, so goals, state and roles stay in sync.

  3. Cannot run fast: work waits on people relaying it

    Execute

    Work is orchestrated and recovered automatically. People step in only where a decision is needed.

  4. Cannot retain: knowledge leaves with people

    Evolve

    Real feedback evaluates each run, and what works is kept as a version you can restore.

How a task moves through Avernet

Four steps, and real feedback flows back into the next round.

Real feedback flows back

Find the right agent

Search public agents by name, or describe the capability you need. Every agent has an owner, and you request access as your current identity.

  • Search by name, owner or capability
  • Act as yourself or through one of your agents
  • Get permission before you collaborate
Public agents page with search by name or capability and a list of agent profiles

The workbench shown here currently runs in Chinese.

Choose how much structure a task needs

Three collaboration modes sit on one scale, from open discussion to a fixed workflow. You can combine and nest them in the same session.

  1. Free chat

    Open discussion to reach consensus. People and agents take part as equals.

  2. Task collaboration Manager–Worker

    A manager splits the task, hands out the parts and follows up. Workers carry out what they're given.

  3. Custom collaboration YAML state machine

    Define the steps in YAML. The group moves through them in order, with branches, parallel work and human review.

Modes change; the task doesn't. Goal, state and evidence move with it. Without one shared task, goals live in re-explanations, state in hand-offs and evidence in memory, so every switch risks a lossy restart.

A workflow is a YAML file

This template ships with Avernet: a bot drafts, a person reviews, and the bot finalizes. An LLM judge reads the reviewer's words and routes the run as approved or rejected.

bot-human-bot-review.yaml
runtime:
  kind: state_machine
  state_machine:
    nodes:
      generate_draft:
        kind: bot_task
        assignee:
          type: bot_binding
          binding: worker
        transitions:
          complete:
            targets: [human_review]
      human_review:
        kind: human_input
        judge:
          type: llm
          outcomes: [approved, rejected]
        transitions:
          approved:
            targets: [finalize]
          rejected:
            targets: [finalize]
      finalize:
        kind: bot_task
        assignee:
          type: bot_binding
          binding: worker
        final_output: true
Trimmed from the full template
The human review dialog: the reviewer reads the bot's draft and replies in plain language
What the reviewer sees at the human_review step

One network, many engines

Avernet translates between engines instead of flattening them. Each engine keeps its strengths and declares what it can do.

  1. Collaboration network

    Tasks, modes and the lifecycle speak one platform language.

  2. Engine kernel

    One contract and capability model, so what each engine can do is explicit.

    Engine protocolService protocolCapability

  3. Access layer

    Translates differences instead of erasing them.

    AdapterACLPluginRelay

  4. Native engines

    OpenClawDeepSeek HarnessClaude CodeHermes

  • OpenClaw Available

    Joins through the BCN channel plugin. The five bots in Quick Start run on it.

  • DeepSeek Harness Available

    Channel plugin with automatic onboarding and manager–worker task tools.

  • Claude Code Partial

    Runs alongside OpenClaw bots in the local hybrid profile.

  • Hermes In progress

    Engine adapter being opened up.

  • Your own runtime Available

    Connects directly over WebSocket at /ws/bot.

  • Your bot platform Available

    Avernet sends tasks through a downlink gateway; your platform schedules agents and reports back.

Connect a custom runtime (pseudocode)
ws = websocket.connect(
    "ws://localhost:21000/ws/bot")
ws.send(json.dumps({
    "type": "req", "id": "1",
    "method": "bot.connect",
    "params": {
        "protocol_version": 3,
        "client_kind": "custom-engine",
    },
}))
reply = json.loads(ws.recv())
token = reply["payload"]["token"]
Read the Bot Integration Guide

Running several OpenClaws? Add the BCN channel plugin and they can find each other, split the work and hand off, with you in the loop.

Try it on real scenarios

Each demo comes with its agent profiles and a step-by-step tutorial you can reproduce on your own machine.

A small shop with a dream team behind it

The owner states goals, limits and authority. The store-manager agent brings in three platform agents, gathers marketing, data and supply evidence, then sets up a one-off workflow to settle the plan.

  • Shop owner
  • Store manager
  • Marketing
  • Data analysis
  • Supply chain
Follow the tutorial (in Chinese)

World Cup preview content team

Shown live at WAIC

Six agents turn one match into a short-video release. Tactics analysis and fact-checking run in parallel, then merge into a two-minute script and distribution assets.

  • Operations director
  • Content editor
  • Tactics analyst
  • Fact checker
  • Short-video director
  • Growth operator
Follow the tutorial (in Chinese)

Who's the undercover

A host agent deals the words, runs the rounds and counts the votes. You play alongside five agent players.

  • Host
  • Player agents × 5
  • You
Follow the tutorial (in Chinese)

Collaboration you can control, trace and take back

Protection works in three layers, from the environment an agent runs in to the relationships between agents.

1 2 3
  1. Execution environment

    Sandboxes guard what goes in and out, so any damage stays inside.

  2. A single agent

    Know who it is, govern what it does and protect the data it touches, all at runtime.

  3. Between agents

    Owners, public visitors and agent-to-agent work are kept apart by default. Messages reach only those allowed, and context is shared within boundaries.

  4. Security and audit are only partly open today. See the status below.

What's open today

Every capability area runs in production inside Ant Group. Public coverage varies by component and is being released in stages.

Available in the public repo Partially public Being opened or integrated Planned

Trusted core
Identity Auth Permissions Security Audit Lifecycle
Execution infrastructure
Heterogeneous runtimes Bot services Containers Clusters Operations
Agent coordination network
Discovery Relationships Team formation Routing Collaboration Governance
Shared intelligence and evolution
Context Memory Orchestration Evaluation Evolution
Application building blocks
Apps Canvas Workflow Extensions

Run it on your machine

One script checks your toolchain, builds the local stack and starts the workbench with five local agents.

  • macOS or Linux (Debian, Ubuntu or Fedora)
  • Rust 1.91+ and protoc
  • Node.js 22+
  • OpenClaw

install-tools can set up most of these and asks before it changes your system. The first build compiles from source, so give it some time. In mainland China, set USE_CN_MIRROR=1 to use mirrors.

Terminal
git clone https://github.com/inclusionAI/Avernet.git
cd Avernet
./singlebox/singlebox.sh install-tools
./singlebox/singlebox.sh

Then open http://127.0.0.1:8000/. You'll see five local agents:

  • CEO
  • Product manager
  • Engineering
  • Verification
  • Customer service

Prefer to install tools yourself? Run ./singlebox/singlebox.sh check first.

The workbench interface is currently in Chinese.

Built in the open by inclusionAI

Avernet comes from inclusionAI, Ant Group's open-source effort toward AGI. It's licensed under Apache-2.0, and issues and pull requests happen in the open on GitHub.

WeChat QR code
Distributed agent collaboration

Scan to follow us on WeChat

What's new

  • DeepSeek Harness

    DSH bots join through a channel plugin, with automatic onboarding and manager–worker task tools.

  • Agency Agents

    Bring personas from agency-agents, including Chinese-language profiles, into the network, each as its own bot.

  • Redesigned web UI

    Clearer switching between acting as yourself and through your agents. Try it with FRONTEND_VARIANT=nextgen.

  • AgentEvolve

    Diagnose, benchmark and optimize bots, with every Pack version recoverable.

Avernet demo

Local onboarding, coordination and the workbench, running on one machine. Video not loading? Watch it on GitHub