How to Set Up AutoClaw Multi-Agent System with Feishu Integration

Mar 25, 2025

I needed to set up a multi-agent AI system that could work autonomously and send notifications to my team. AutoClaw with Feishu integration seemed like the right combination, but getting everything configured correctly took some effort. Here’s how I did it.

The Problem

Multi-agent AI setups are tricky. You need to coordinate multiple configuration files, get Feishu bot permissions exactly right, define how agents communicate, and keep each agent’s workspace isolated. Miss any of these, and the system either doesn’t work or creates chaos.

I wanted a Chief Agent (总管) to orchestrate everything while specialized SubAgents handle development, product, and testing tasks autonomously. And when something important happens, I need to know about it through Feishu.

Step 1: Initialize AutoClaw

First, I purchased the GLM-5-Turbo plan with the “Lobster” tier. This gives access to the AutoClaw configuration interface where you can start setting up agents.

The easiest way to begin is to ask AutoClaw directly about setup options. It will guide you through available configuration modes and help you choose the right approach for your use case.

Step 2: Create Feishu Bot

This is where most people get stuck. The Feishu bot requires specific permission scopes to work properly with AutoClaw notifications.

I created a bot application in the Feishu admin console and configured these permission scopes:

{
  "scopes": {
    "tenant": [
      "aily:file:read",
      "aily:file:write",
      "application:application.app_message_stats.overview:readonly",
      "application:bot.menu:write",
      "contact:contact.base:readonly",
      "contact:user.employee_id:readonly",
      "corehr:file:download",
      "event:ip_list",
      "im:chat.access_event.bot_p2p_chat:read",
      "im:chat.members:bot_access",
      "im:message",
      "im:message.group_at_msg:readonly",
      "im:message.p2p_msg:readonly",
      "im:message:readonly",
      "im:message:send_as_bot",
      "im:resource"
    ],
    "user": [
      "aily:file:read",
      "aily:file:write",
      "im:chat.access_event.bot_p2p_chat:read",
      "im:message"
    ]
  }
}

After configuring permissions, I obtained the APPID and APPsecret from the Feishu developer console. These credentials go into your AutoClaw configuration.

Step 3: Configure SubAgents

Each SubAgent needs its own role and independent workspace. This prevents context pollution and keeps each agent focused.

I created a YAML configuration to define my agent team:

agents:
  chief:
    name: "总管"
    role: "Orchestration and monitoring"
    workspace: "./workspaces/chief/"

  dev_director:
    name: "开发总监"
    workspace: "./workspaces/dev_director/"
    skills:
      - "tmux_control"
      - "claude_code"

  product_director:
    name: "产品总监"
    workspace: "./workspaces/product_director/"
    skills:
      - "prd_generation"
      - "document_tools"

  test_director:
    name: "测试总监"
    workspace: "./workspaces/test_director/"
    skills:
      - "test_execution"
      - "report_generation"

The key insight here is that each agent gets its own workspace directory. The Chief Agent (总管) oversees everything but doesn’t share context with SubAgents. This isolation is important for keeping tasks separate.

Step 4: Connect Tools and Skills

I configured local MCP server access and skills library paths for each agent based on their role. The development agent needs code tools, the product agent needs document tools, and so on.

Agent communication is where I hit some issues (noted as “有坑” in the original documentation). The communication rules need to be explicit, or messages won’t flow correctly between agents. Test the agent-to-agent messaging early in your setup process to catch problems before they cascade.

Step 5: Verify the Setup

I tested each component:

Feishu bot responds to messages
Chief Agent can send notifications to Feishu
SubAgents can receive tasks from Chief Agent
Each SubAgent has access to its assigned skills
Workspaces remain isolated

Common Mistakes to Avoid

Missing Feishu permission scopes: Double-check the JSON configuration. Every scope listed above is necessary.
Not testing communication early: Don’t assume agents will figure out how to talk to each other. Verify it works.
Sharing workspaces: Each agent needs its own workspace. Don’t shortcut this.
Skipping Chief Agent configuration: The Chief Agent is the orchestrator. Without proper setup, nothing coordinates.

Why This Matters

A properly configured AutoClaw system runs 24/7 autonomously. The Chief Agent monitors progress and alerts you through Feishu when something important happens. SubAgents work on their specialized tasks without stepping on each other. You get notifications in your Feishu app instead of checking dashboards constantly.

In this post, I walked through setting up AutoClaw multi-agent system with Feishu integration. The main challenges are getting the Feishu permissions correct, configuring independent workspaces for each agent, and establishing communication protocols. Once configured, the system handles autonomous task execution with notifications delivered to your Feishu app.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!