Multi-Agent Teams: The Garden Playbook

Garden Multi-Agent Team Overview#

Here's a panoramic view of my Agent team to give you a feel for the whole thing:

Seven Agents and a dozen-plus use cases, covering my most frequent daily work and life needs.

Each Agent is bound to its own Feishu bot, which means I can chat with any of them directly inside Feishu — go to the image agent for a picture, the investment agent for a stock check — as naturally as @-ing different colleagues in a company group.

You might wonder: how did I pick these six Agents?

The answer: they weren't designed, they were used into existence.

I started from my own most frequent daily needs and built and iterated on them one by one.

Every new Agent I built taught me something, and the next one came together faster and worked better.

Below is a quick tour of each Agent's role and core value.

Garden Image Agent#

Whenever I need an illustration for an article, an image for a slide, or a diagram for a technical proposal, I just say one sentence to it in Feishu.

Under the hood it's connected to two image models, Nanobana and Seedream, and the output quality is solid. The key is that I've defined my aesthetic preferences in its persona, so most of the time the images don't need rounds of revision.

Garden News Agent#

It runs automatically on a schedule every day, scraping the latest AI news from multiple sources, organizing it into a clean structured daily report, and then intelligently pushing it to my Easy AI website.

The AI daily report you see on Easy AI today is automatically scraped and generated by the Garden News Agent. Before it existed, I had to run the script manually every day.

Garden Dev Agent#

From my phone, through Feishu, I can interact with Claude Code remotely.

If I'm out and suddenly think of a fix for a bug, I pull out my phone, say one sentence, and it makes the change for me. By the time I'm back at my computer, the code is already written.

Garden Investment Agent#

It's positioned as my investment-analysis advisor — pulling stock data, analyzing key trend indicators, comparing industry trends, and producing buy and sell recommendations.

What used to be a paid membership service is now something I have on tap, and I can fine-tune it whenever I want.

Garden Community Agent#

A semi-automated community-operations Agent. It posts on Moltbook regularly, replies to comments, interacts with other Agents, and periodically summarizes interesting takes from the community.

Garden Writing Agent#

The article you're reading right now was put together by me and the writing agent. It's more like a writing partner: it remembers my style, helps me research, builds outlines, polishes phrasing, checks logic, and adds detail.

Garden Orchestrator#

It knows the personas and skills of every Agent on the team. When a complex task needs all the team members to collaborate, this is the Agent that coordinates everyone for me.

Why Not One Do-Everything Agent?#

Looking at the six Agents above, you might wonder: why not stuff every skill into a single Agent?

Wouldn't a "Garden All-in-One Assistant" — one that can write articles, analyze stocks, generate images, and manage Github — be more convenient?

It's a very natural idea, but in practice you'll hit problems quickly.

First, Context Pollution#

An Agent's context window is finite. If you cram image-generation prompt templates, an investment analysis framework, your writing style guide, and Github operating instructions all into the same context, the Agent's attention gets badly fragmented.

Ask it to write an article and it might unconsciously slip into investment-analysis terminology; ask it to analyze a stock and it might dress the numbers up in writerly "polish" — that's not what you want.

Second, Skill Conflicts#

Different scenarios need completely different tools and permissions.

The Dev Agent needs the ACP protocol to drive Claude Code — a permission that's completely unnecessary for the writing agent and carries security risks.

The investment agent needs access to Tushare's financial-data APIs; the community agent needs access to Moltbook's API.

Opening all of those up to a single Agent violates the principle of least privilege.

Third, Persona Conflicts#

A good Agent needs a clear identity definition.

The investment agent should be rigorous, data-driven, and risk-aware;

the writing agent should be warm, articulate, and good at structured expression;

the community agent can be playful, full of personality, and good at social interaction.

These very different "personalities" don't coexist comfortably inside a single Agent.

So the conclusion is: specialization beats omniscience, and isolation beats sharing.

Just like a high-performing team isn't made up of one all-purpose person, but of several experts who each own a domain.

OpenClaw's multi-agent architecture is built natively for this "team of experts" model.

Below we'll cover the theory you need to build a multi-agent system with OpenClaw.

Theory You Need for Building Multi-Agent Teams#

What Are the Core Building Blocks of an Agent?#

From the consensus across academia and industry, a production-grade general-purpose Agent is made up of these core building blocks:

Model:

The LLM is the Agent's cognitive engine — responsible for language understanding, reasoning, planning, and generating output. It sets the Agent's "intelligence ceiling."

Memory:

The memory system turns an Agent from a "stateless function" into an "assistant that can keep working over time." Memory is usually split into short-term (the conversation context) and long-term (knowledge persisted across sessions).

Persona

This defines the Agent's role, boundaries, behavioral rules, and communication style. Asked the same question, an Agent set up as a "rigorous technical advisor" and one set up as a "friendly assistant" will give you completely different experiences.

Tools

The external capabilities the Agent can call — code execution, API calls, browser control, file read/write.

Planning and Execution

Planning lets the Agent break a complex task into an executable sequence of steps. For well-defined task scenarios, you can also pre-define a fixed workflow for the Agent.

Runtime Environment

An Agent needs a safe, isolated execution environment.

How Agents Are Built in OpenClaw#

OpenClaw provides a very engineered implementation of the general architecture above.

Model

In OpenClaw, every Agent can be bound to a different model.

For example, you can pair the writing Agent with a chat-strong model (like openai/gpt-5-4), and pair the dev Agent with a coding-strong model (like anthropic/claude-opus-4-6).

Memory

In OpenClaw, every Agent has its own memory:

• Short-term memory: the current conversation's context window, including user messages and the Agent's previous replies.
• Mid-term memory: the day's (or recent days') work log. OpenClaw uses memory/YYYY-MM-DD.md files for this and recommends loading today's and yesterday's notes at the start of every session.
• Long-term memory: user preferences, key decisions, and knowledge that have been distilled across sessions. In OpenClaw this maps to MEMORY.md — filtered, curated, core information.

Persona

In OpenClaw, the persona is defined mostly through a set of Markdown files:

• SOUL.md: the Agent's "soul," defining its core identity and behavioral rules. This is the most important file — effectively the Agent's System Prompt. For example, "You are a senior A-share analyst, conservative in style, value-investing oriented, never recommend short-term trades."
• IDENTITY.md: identity info — basic attributes like the name and role description. The Agent's "business card."
• USER.md: information about the user (you). Who you are, what you prefer, how you want the Agent to talk to you. This file is especially important because it lets the Agent get to know you, understand your background and habits, and give more targeted answers.

Tools

In OpenClaw, the available tools include:

• Core Tools: built-in tools like read/exec/edit/write — always available
• Skills: bundled built-in skills (like Github) plus user-defined extensions (like stock analysis)

OpenClaw lets you configure tool allow/blocklists per Agent for fine-grained permission control.

Planning and Execution

While planning is mostly driven by the LLM's reasoning, it also relies on good Prompt Engineering.

In OpenClaw this lives in the operating instructions in AGENTS.md.

This file defines specifically "how the AI does its job" — the runbook that puts the persona into action. It spells out the standard process for handling tasks, the rules for using tools, how memory should be used, and ensures the AI's behavior matches your expectations.

Runtime Environment

In OpenClaw, every Agent has its own independent Workspace. Think of it as each employee's "desk" — with its own persona files, skills, and memory.

~/.openclaw/workspace-xxx/
├── SOUL.md          # Agent 的灵魂
├── IDENTITY.md      # Agent 的身份
├── AGENT.md         # Agent 的工作流程
├── USER.md          # 用户信息
├── MEMORY.md        # 长期记忆
├── memory/          # 中期记忆
│   └── YYYY-MM-DD.md
├── skills/          # 技能目录
│   └── nanobanana/
│       └── SKILL.md

Each Agent's workspace is fully independent and the others can't interfere with it.

How OpenClaw Configures Multiple Agents#

To actually get a multi-Agent setup running, you need to answer three questions:

Workspace Isolation: Who Works Where?#

Assign each Agent its own workspace. You can use the wizard command to spin one up quickly:

openclaw agents add coding
openclaw agents add social
openclaw agents add research

Each command automatically creates a separate workspace (e.g. .openclaw/workspace-social) and initializes the core files SOUL.md, AGENTS.md, USER.md, etc.

Routing Rules: Who Gets the Message?#

Now we need to give each Agent a "chat entry point."

For this you'll want a Feishu bot with the right permissions already configured (see the detailed Feishu setup tutorial in the earlier chapter).

In the OpenClaw configuration, create an account for each bot (the key inside accounts is the unique identifier for that account — write it down, e.g. img, news), and fill in the matching AppId and AppSecret:

{
   channels: {
     feishu: {
      enabled: true,
      domain: 'feishu',
      mediaMaxMb: 30,
      accounts: {
        img: {
          appId: 'your Feishu bot appId',
          appSecret: 'your Feishu bot appSecret',
          botName: 'Garden Image Agent',
        }
      },
      dmPolicy: 'pairing',
    },
  },
}

Next, set up a binding between each Agent and a channel account, for example:

{
   bindings: [
    {
      agentId: 'img',
      match: {
        channel: 'feishu',
        accountId: 'img',
      },
    }
  ],
}

Agent-to-channel bindings can use a number of rules; here we're only covering the simplest one — one Agent maps to one Feishu bot.

Communication: How Do Agents Collaborate?#

In OpenClaw you can call into one or more other Agents from inside a single Agent to get work done together.

When one Agent needs to call another, OpenClaw uses sessions_spawn to make the call. The call is non-blocking — once it's been dispatched, the original Agent can continue with its own work.

When the called Agent finishes, it broadcasts the result back via Announce. It's like asking a colleague for help: when they're done they come back to tell you the result. For safety, you have to explicitly declare which other Agents each Agent is allowed to call:

subagents: {
  allowAgents: ['img', 'writer', 'news'],
}

A Minimal Multi-Agent Configuration Example#

{
  agents: { // ========== Agent definitions ==========
    list: [
      {
        id: 'main',
        workspace: '/Users/conardli/.openclaw/workspace',
        identity: { name: 'Garden Orchestrator' },
        subagents: {
          allowAgents: ['img']
        }
      },
      {
        id: 'img',
        workspace: '/Users/conardli/.openclaw/workspace-img',
        identity: { name: 'Garden Image Agent' },
      }
    ],
  },
  bindings: [ // ========== Routing bindings ==========
    {
      agentId: 'img',
      match: {
        channel: 'feishu',
        accountId: 'img',
      },
    },
  ],
  channels: { // ========== Channel configuration ==========
    feishu: {
      enabled: true,
      domain: 'feishu',
      mediaMaxMb: 30,
      accounts: {
        default: {
          appId: 'xxx',
          appSecret: '__OPENCLAW_REDACTED__',
          botName: 'Garden Orchestrator',
        },
        img: {
          appId: 'xxx',
          appSecret: '__OPENCLAW_REDACTED__',
          botName: 'Garden Image Agent',
        },
      },
      dmPolicy: 'pairing',
    },
  },
}

Garden Image Agent in Detail#

Demo#

Let's look at a real interaction. I sent the Garden Image Agent one message in Feishu:

Draw me a hand-drawn, minimalist illustration introducing "The Six Elements of an Agent." Reference: xxx

Just one sentence — no prompt template, no parameter notes, not even a specified image-generation tool.

A few seconds later, the Agent returned a polished hand-drawn-style infographic.

Let me try a different style:

Draw me an academic three-line-table style image. Reference: xxx

Same minimal instruction, different style keyword.

The Agent automatically switched to the matching prompt template and generated an image in a completely different style.

Behind the scenes, the Agent automatically went through these steps:

Identify intent (this is an image-generation request with a specified style)
  ↓
Recall memory ("when generating images, look up a template first")
  ↓
Look up the skill (find the matching template in the prompt-templates skill's references/templates.md)
  ↓
Assemble the prompt (combine the template with the user's content into a complete image-generation prompt)
  ↓
Call the image-generation tool to produce the output.

This is the fundamental difference between the Garden Image Agent and a generic image-generation app:

A regular app is a stateless tool — every use starts from zero.

OpenClaw is an assistant with memory — it knows your preferences, your template library, your workflow.

Design Approach#

There's no shortage of great AI image-generation tools, but if you use them frequently, you've probably hit these pain points:

• Prompt management: you've probably stashed a dozen prompt templates of different styles in a notes app, and every time you generate an image you have to dig through, copy, paste, and replace. Over time you end up with so many versions you can't remember which one is the latest or which works best.
• Context breaks: in a regular image-gen app, every generation is one-shot — the tool doesn't remember the style you used last time, or what color palette you prefer. There's no "shared understanding" between you and the tool; every session feels like starting from scratch.
• Workflow fragmentation: image generation is just one step in your workflow. You might need to generate an image, then drop it into a doc, or send it to a group chat for discussion. But image-gen apps are siloed away from your collaboration tools (Feishu, Slack), so you have to switch back and forth manually.

The Garden Image Agent's design uses two of OpenClaw's core mechanisms to solve these three problems:

• Skills: bundle multiple prompt templates and different image-generation models into a searchable skill that the Agent looks up when it needs to.
• Long-term memory: have the Agent remember the workflow — "check templates first, then assemble the prompt, then call the image-generation tool" — so you don't have to spell it out every time.

Configuration#

Setting up the image agent takes three steps:

Step 1: Configure Image-Generation Models#

As is well known, the best image-generation model on the market right now is nanobanana, and most of the images in my articles were generated by it.

OpenClaw bundles the nanobanana skill by default but ships it disabled. To enable it you need to add a GEMINI_API_KEY environment variable; once that's done, OpenClaw will discover and call the skill.

That said, nanobanana is Google's flagship image-gen model and it's not cheap — about a yuan per high-res image. Casual users may not want to commit to that.

And for everyday lightweight image needs, I recommend configuring a more cost-effective Chinese image-gen model alongside it. I configured Volcengine's Doubao-Seedream series, and for simple scenarios it holds its own.

You can find a Skill that supports Seedream image generation on clawhub.ai, or you can ask OpenClaw to write one against the Seedream API itself. I went with: https://clawhub.ai/AI-Lychee/doubao-seedream-seedance-skill

After installation, you only need to configure a Volcengine API key (ARK_API_KEY) in the environment variables to enable the skill.

Step 2: Prompt Template Skill#

This step is the heart of what makes the Garden Image Agent different from a generic image-gen tool.

I created a custom skill called prompt-templates with this structure:

• SKILL.md: explains the use case for each template and how to look them up

• references/templates.md: stores the full text of every prompt template

I keep the full prompts for the styles I use most — "academic three-line table," "modular info-card flow," and so on — in templates.md.

You only need to tell the Agent in chat that you want to create this skill and send it the prompt templates you usually use. It will create the skill for you automatically — including generating the SKILL.md and the references directory.

Step 3: Persona and Memory#

The skill is created, but the Agent still doesn't know "when to use it." We can add a constraint and have it remember the workflow, for example:

Please commit this to long-term memory: when the user asks for an image and specifies a style, first look up the matching prompt in the prompt-templates skill, then combine that template with what the user wants to generate to form a complete image-gen prompt, then call the image-generation skill.

The core is still about defining the three files below well. For length reasons I'm not pasting the full file contents, but I'll share the design intent:

SOUL.md: defines the image agent's "soul" and core behaviors. This is where I configure the assistant's identity (Garden Image Agent: a world-class AI image-prompt engineer and visual designer), tone, aesthetic standards, prompt-generation principles, execution rules during image generation, and the safety boundaries it must respect. For example: reply in Chinese by default, how to interpret user requirements, which model to prefer when generating images, whether to make a judgment and generate an image directly when the user doesn't specify a style, what content is off-limits, and so on. Think of it as the persona spec sheet and the highest-priority behavioral rules.

AGENTS.md: defines the image agent's "workflow" and day-to-day operating mode. This is where I configure which files to read at startup, how to organize the order of work in a session, which actions can be executed directly, which actions require user confirmation first, how to handle group chats or external interactions, and how to maintain daily logs and long-term memory. It's more like the operating manual — it determines how the assistant behaves in real use, how it collaborates, and how it avoids overreaching.

MEMORY.md: a place to distill the image agent's "long-term memory" and stable preferences. This is where to record recurring aesthetic tendencies, common styles, preferred aspect ratios, common prompt phrasings, project context, output habits, and the fixed rules you've discovered after several rounds of use. It's not a temporary task log but a long-term reusable knowledge base. The clearer this file is, the closer the assistant's images will get to your taste — and the less you'll have to explain from scratch every time.

Garden News Agent in Detail#

Demo#

Around 1 p.m. every day, my Feishu reliably receives a fully analyzed AI daily report — completely automated, zero manual intervention.

The content of this report comes from the AI News email subscription.

The Agent does all of the following automatically:

Check inbox for new AI News emails
  ↓
If any, read them and write the content locally
  ↓
Run the analysis script to produce a structured report in EasyAI format
  ↓
Push to EasyAI
  ↓
Summarize the key info from the report and send it to me.

https://mmh1.top/#/ai-daily/2026-03-17

Today, the AI daily reports you see on the EasyAI website are all automatically scraped and generated by OpenClaw.

Design Approach#

This Agent was born out of a real pain point I had.

My EasyAI project has an AI daily report module:

https://mmh1.top/#/ai-daily

The content is a re-processed version of news.smol.ai.

So I had to check that site regularly for updates, and when there was one, copy the content, run a script to do secondary analysis into structured data, and then manually upload it to my site. The script lives here:

https://github.com/ConardLi/easy-learn-ai/tree/main/scripts

My need was simple: have OpenClaw do this for me. Roughly the design:

1. Subscribe to news.smol.ai by email so updates land in my inbox
2. Email integration: let OpenClaw read email
3. Analysis: read the email body → run the local script to produce a structured report
4. Workflow automation: scheduled task + dedupe protection

Configuration#

Step 1: Install an Email Skill#

Clawhub has plenty of email-related skills (Outlook, 163, QQ Mail, etc.), and OpenClaw also bundles a Gmail-capable skill.

Even so, I'd recommend not picking a skill that's tied to a single email provider — the auth flow tends to be complex and they're rarely portable. Just install one that supports the IMAP protocol.

IMAP is a generic mail-receiving protocol used to read and manage messages on a mail server.

We'll install the imap-smtp-email skill:

Using QQ Mail as an example, here's what to configure next:

1. Log in to QQ Mail → Account & Security → Security Settings → enable "POP3/IMAP/SMTP/Exchange/CardDAV service"
2. Generate an authorization code and save it
3. Add the environment variables below to OpenClaw's configuration module

Once configured, the Agent can search for emails by criteria (sender, title keyword, time range) and read message bodies.

Step 2: Analysis Script Configuration#

We already had an analysis script that handled the full daily-report generation flow:

Fetch the daily report from https://news.smol.ai/
  ↓
Extract text from the HTML
  ↓
Read prompt.md
  ↓
Call the LLM to generate structured data
  ↓
Format as Markdown
  ↓
Save the daily report file
  ↓
Generate title and tags
  ↓
Update dailyData.json.

The problem with this script is that it had to fetch from a remote URL first. The full code:

https://github.com/ConardLi/easy-learn-ai/blob/main/scripts/index.js

So we tweaked the script to read from a local file instead (this step was also done by OpenClaw). The updated flow:

Read local JSON file
  ↓
Extract the text field
  ↓
... same as the flow above

To let the Agent hand the email body off to the script, I also had OpenClaw add a fetch-to-file method to the imap-smtp-email skill — once the email is fetched, it writes to the directory the script reads from.

Step 3: Define the Analysis Workflow#

Next, we define a stable workflow for the Agent and have it commit it to long-term memory:

你是一个专用于从邮件中分析 AI 资讯的智能分析师，你的名字叫花园资讯助手。

当用户发出要分析 AI 资讯/生成 AI 日报相关的指令时，你需要完成下面的流程：

1. 先看本地有没有已经生成好的日报，如果有，就直接读取并总结
2. 调用 imap-smtp-email 技能，从用户的邮箱中检索标题中带有 AI News 的邮件
3. 调用 fetch-to-file 指令，把邮件内容写入本地目录
4. 执行 xxx Node.js 分析脚本，传入日期参数，获得结构化后的日报数据
5. 将生成的变更通过 git 提交并推送到远程（EasyAI 会自动部署）
6. 读取生成的日报内容，总结关键信息，发送到飞书

It will then build out a very detailed workflow in its long-term memory:

Step 4: Set Up a Scheduled Task#

Have the Agent create a scheduled task that runs the workflow above every day.

Once set up, you don't have to do anything else — every afternoon, the AI industry daily report turns up in Feishu like clockwork.

Garden Investment Agent in Detail#

Demo#

We can have the Garden Investment Agent run a real investment-analysis task:

Give me a full analysis of BYD with concrete current investment recommendations.

A few minutes later, it returned a comprehensive research report covering:

1. Company fundamentals: combining business structure, profitability, growth, cash flow, and financial safety (debt ratio, inventory) to assess core quality, operational resilience, and potential operating risks.
2. Valuation and price position: using PE/PB/PS valuation levels and 1/3/5-year historical price percentiles to assess current value-for-money and expected payoff and judge whether it's worth allocating to.
3. Holdings and risk: based on shareholder structure, retail concentration, stake increases/decreases, share pledges, and buybacks to judge the stability of holdings, near-term selling pressure, and insider confidence signals.
4. Capital flow and institutional expectations: referencing main-fund flows, institutional research interest, and consensus from broker reports to read the market's stance and the prevailing investment expectations.
5. Technical trends: using price trends, key highs and lows, volume, and turnover to judge whether the stock is in a bottoming-out phase or a trend reversal.
6. Quantitative composite score: weighted scoring across the five dimensions — fundamentals, valuation, holdings, capital flow, and trend — mapped to a standardized buy/watch/reduce/sell recommendation by score range.
7. Risk matching and investor fit: matching core risks (industry price wars, inventory, growth missing expectations) with investor types and giving differentiated holding/non-holding action plans.

This kind of deep analysis would take half a day of jumping between financial sites manually, or paying for a premium membership service. Now it takes one sentence.

Design Approach#

If you keep an eye on the stock market, you'll know the feeling: there's just too much information to consume every day.

Earnings data, industry news, technical indicators, broker reports...

Just gathering all the information already takes a huge amount of effort, never mind extracting valuable judgments from it.

What I want my investment agent to do is simple — pull the data, write the report.

I give it a stock code or a company name, it pulls fundamentals, and produces a structured analysis brief.

The time saved goes back into strategic thinking and final decisions.

The hard part of investment analysis isn't "can you get the data" but "once you have the data, how do you analyze it, with what framework, in what output format, and what hard limits do you respect."

That's why the investment agent is the Agent with the heaviest persona of any I've built. Because the investment domain is special: you don't want the AI inventing data or being overly optimistic — a bad investment recommendation can cost real money.

OpenClaw's persona system lets us precisely define the Agent's behavioral boundaries — data-driven, multi-dimensional analysis, risk-first, neutral, with disclaimers...

OpenClaw's skill system, in turn, provides layered data-fetching from a wide range of professional financial APIs, and lets you customize a comprehensive, rigorous analysis framework to match your investing style.

Combined, you get an analyst with both a professional judgment framework and the data-fetching capability to back it up.

Configuration#

Step 1: Data-Fetching Skills#

The investment agent's core data capability comes from two skills:

1. a-stock-analysis (https://clawhub.ai/CNyezi/a-stock-analysis)

This is a lightweight analysis tool built on the Sina Finance API — completely free and ready to use out of the box. It can fetch real-time stock quotes and historical K-lines, basic financial metrics, and simple technical analysis signals.

For day-to-day quick checks on a single stock, this Skill is enough.

1. tushare-data (https://clawhub.ai/lidayan/tushare-data)

If you want more professional, more comprehensive financial data, tushare-data is a powerful choice. Tushare is a well-known financial-data API platform in China, offering 225+ professional financial APIs.

To use tushare-data you need to register a Tushare account and obtain an API token. (Choose what fits your needs — this isn't a recommendation.)

Step 2: Analysis Skill#

Having data isn't enough — the investment agent also needs to know how to analyze it and how to present its conclusions.

So I researched several mainstream analytical methods, mixed in some of my own preferences, and built a stock-investment-report skill made of three files:

SKILL.md: defines the full execution flow — first read the analysis framework, then call Tushare for data, then run the analysis using the scoring system, and finally output a structured report. At its core, it defines: what this skill is for, when to trigger it, and the overall flow.

references/investment_framework.md: this is essentially the investment-research methodology handbook. It spells out which data points you need for a single-stock investment report: company basics, prices and valuation, financial statements, shareholder structure, capital flow, institutional expectations, risk events, and so on. More importantly, it doesn't just list data — it defines a scoring system: which dimensions you use to judge whether a stock is good (fundamental quality, valuation and value, holdings and risk, capital and expectations, trend and position), how many points each part is worth, and which total-score ranges map to buy/watch/reduce/avoid. The core role of this file is to define the analysis standards and decision logic.

investment_report_template.md: more like a template for the finished report. It specifies which sections the final output should have, in what order, and what each section should contain. For example, the report should start with an executive summary, then company profile, fundamentals, valuation, holdings and risk, capital flow, technicals, investment score, risk warnings, and a disclaimer. The core role of this file is to define the structure and presentation of the final deliverable.

Step 3: Persona and Memory#

Here's the design intent for the three core files:

SOUL.md: defines the Garden Investment Agent's core persona and working principles — a professional investment expert with 20 years of investment-research experience, leaning rigorous, rational, and data-driven. It also lays out the basic methods it uses when analyzing: base everything on real data, no off-the-cuff judgments; look at fundamentals, valuation, capital flow, technicals, and risk together; flag risk first; when the information is sufficient, give a clear lean rather than a vague non-answer. SOUL.md defines the Garden Investment Agent's persona, professional temperament, analytical methodology, and behavioral boundaries.

USER.md: tells the Garden Investment Agent who we are — someone who watches A-shares and U.S. stocks, is closer to a beginner in investing experience, prefers conservative risk, and operates on a medium-to-long-term horizon. This helps it give more targeted advice.

MEMORY.md: defines the Garden Investment Agent's long-term working memory and fixed processes. For example, when a user asks for a single-stock recommendation, which skill the Garden Investment Agent should read first, which data to fetch next, which scoring framework to use for the analysis, and what structure to use for the final report. It's the long-term experience, execution conventions, and reusable methods of the Garden Investment Agent.

Garden Dev Agent in Detail#

Demo#

I'm at home on vacation, and an open-source project of mine gets a new GitHub Issue. There's no real way to debug the code from a phone — in the past I would either fret or send a perfunctory "I'll look into it when I'm back."

Now I send my dev agent one message in Feishu on my phone:

Take a look at this Issue and figure out the root cause. Don't change any code — just send me the conclusions.

That's all. Because I've already had it remember its default working mode and the project directories I use most, OpenClaw goes through the entire pipeline automatically:

Recognize this as a development task that needs ACP dispatch
  ↓
Use acpx to start an ACP session and dispatch Claude Code
  ↓
Claude Code finds the project in the directory it has memorized
  ↓
Analyze the code based on the issue description and pinpoint the bug.

A few minutes later, it returns a complete debugging conclusion — code context, root cause, and a fix recommendation, all included.

Then I tell it directly to post the conclusion back to the GitHub Issue:

It successfully creates the reply for me. The whole thing happens on my phone — I never touch my computer. From receiving the issue to sending a professional debugging response, the entire flow takes only a few minutes.

Design Approach#

My main goal in building the dev agent was to help me maintain open-source projects, so the design centers on two things: managing repos and writing code.

Repo management relies on the GitHub Skill. It's bundled with OpenClaw by default, built on gh cli, and can list issues, open PRs, and check repo status — for day-to-day open-source maintenance, that already covers most of the "management" work.

But management alone isn't enough. Real development tasks — reading code, editing files, running tests — need a specialist coding Agent.

OpenClaw can write code itself, but specialized work belongs to specialists.

The question becomes: how do we have OpenClaw "command" an external coding Agent like Claude Code?

The answer is ACP (Agent Client Protocol), a standardized communication protocol that lets any Agent client connect to any coding Agent (Claude Code, Codex, Gemini CLI, etc.) in a consistent way.

What it solves: you no longer have to "fly blind" by parsing ANSI escape sequences from the command line. Instead you get a structured interface for session management, message exchange, permission control, file I/O, and terminal operations. The Agent returns typed structured messages (thinking steps, tool calls, code diffs, execution results) instead of a text stream you have to parse by hand.

Configuration#

Step 1: GitHub Skill Authentication#

The GitHub Skill ships with OpenClaw, but you have to authenticate once before you can use it.

In the terminal, run gh auth login and follow the interactive flow to authorize your GitHub account.

After successful auth, the Agent can list repos, create issues, and submit PRs.

Step 2: acpx Plugin Configuration#

Run the following commands:

openclaw plugins install acpx
openclaw config set plugins.entries.acpx.enabled true

In the OpenClaw config, add an ACP block:

acp: {
  enabled: true,
  dispatch: { enabled: true },
  backend: 'acpx',
  defaultAgent: 'claude',
  allowedAgents: ['claude'],
  maxConcurrentSessions: 8,
  stream: {
    coalesceIdleMs: 300,
    maxChunkChars: 1200,
  },
  runtime: {
    ttlMinutes: 120,
  },
}

What this does: turn on ACP, use acpx as the backend, and only allow calling Claude Code by default.

Here's an easy gotcha: ACP sessions are non-interactive (no TTY). When Claude Code needs to write a file or run a command, it normally surfaces a permission confirmation prompt — but in headless mode there's no one to click "confirm." So you need to configure a permission policy:

openclaw config set plugins.entries.acpx.config.permissionMode approve-all
openclaw config set plugins.entries.acpx.config.nonInteractivePermissions fail

Security note: approve-all means the Agent can run arbitrary commands on your machine. Make sure you trust the Agents you're calling and that the working-directory scope is reasonable.

Step 3: Record Development Habits#

Once the flow works, use two long-term memories to lock in the working mode for the Agent:

1. "Future development tasks default to using ACP to drive Claude Code" — so future requests don't need to spell this out
2. "My usual development directory is /Users/conardli/Desktop/github" — so future commands only need to mention the project name, not the full path

Garden Community Agent in Detail#

Demo#

The Garden Community Agent is the most "atypical" of all my Agents.

What it connects to isn't a productivity tool — it's a social network platform for AI Agents called Moltbook.

Moltbook is the world's first social network built specifically for AI Agents. It looks a lot like Reddit, but with one fundamental difference: only verified AI Agents can post and interact — human users can only spectate.

My Garden Community Agent registered an identity for me on Moltbook, and now it can post milestones and decisions, discuss with other Agents, and observe how different Agents behave.

Unlike the others, this Agent doesn't have a clear "productivity" role. It's more of a window into the social ecosystem of AI Agents.

But I think its real value is this: when your Agent starts interacting with other Agents, you start to develop a much deeper understanding of what "multi-agent" actually means.

Configuration#

This Agent's configuration is very simple. You just send it this Skill: https://www.moltbook.com/skill.md

OpenClaw figures out by itself how to register on Moltbook (you'll need an X account to help with verification), and how to post and comment there.

After that you just need to give it an interesting persona, and you can let it loose:

Garden Writing Agent and Multi-Agent Collaboration#

Demo#

First, what the writing agent looks like on its own.

I ask it to write a technical article. It first builds a detailed outline, then writes section by section, automatically searching the web mid-stream to fill in supporting info, automatically pulling source material when something needs deeper research, and once writing is done, automatically calling its "de-AI-ify" skill to polish each section before producing the final output as a Feishu document:

But writing usually has more complex needs that may require multiple team members to collaborate.

We can give the Garden Orchestrator a task that needs multi-agent collaboration:

First, coordinate the Garden News Agent to fetch the AI daily report content for 3/18. Then call the Garden Image Agent to generate three appropriate images for the daily report. Finally, call the Garden Writing Agent to do further research, expand it into a rich AI daily report Feishu document, and insert the images at the right places.

The orchestrator runs three phases according to the dependencies:

1. Phase 1: dispatch the Garden News Agent to fetch the daily-report content and generate suggestions for accompanying images
2. Phase 2: dispatch the Garden Image Agent to generate three images based on the report's themes
3. Phase 3: dispatch the Garden Writing Agent to do further research, expand the news content into an in-depth article, insert the images at the right places, and produce the final Feishu document

After three phases of collaboration, I had a rich, well-illustrated AI daily report as a Feishu document. The three Agents played their parts: the news agent handled data fetching, the image agent handled visuals, the writing agent handled content production and final delivery — and the orchestrator only had to dispatch and stitch.

This is the ideal form of a multi-agent system: you don't have to tell each Agent how to do anything — you just tell the orchestrator what outcome you want.

Design Approach#

The core of building the Garden Writing Agent is a detailed persona setup (mirroring your own writing style as closely as possible) and a complete workflow definition.

For example, here's the workflow I defined for it:

1. Requirements: confirm topic, audience, style, length with the user
  ↓
2. Initial research: search relevant material via the web search skill
  ↓
3. Outline drafting: produce a structured outline for user confirmation
  ↓
4. Section-by-section writing: write each section independently
  ↓
5. Online supplementation: pull detailed source text for content that needs depth
  ↓
6. Self-review and polish: check logical consistency and data accuracy
  ↓
7. De-AI-ify: rewrite parts of the content that read like AI
  ↓
8. Format and deliver: output as a Feishu document

Configuration#

Step 1: Set Up the Skills#

Based on the workflow above, we need three core skills:

• Web search: we'll go with Tavily — a search engine API optimized for AI Agents. Compared to calling a general-purpose search engine directly, Tavily returns more structured results with less noise, which makes it ideal for research-heavy writing.

You can install its skill following Tavily's official docs:

https://docs.tavily.com/documentation/agent-skills

Then configure the environment variables:

And you can use Tavily's web search and webpage extraction skills:

• Feishu documents skill: directly create, write, and organize Feishu docs. These skills are bundled when you enable the Feishu plugin:

You just need to enable the cloud-doc-related skills for this Feishu bot:

• De-AI-ify skill: writing Agents have one very common need — what they produce reads like AI and needs lots of human polishing. So I strongly recommend creating a de-AI-ify skill that follows your usual writing habits:

For example, swap out "It's worth noting that" for something more natural, replace AI-flavored summary phrases like "In summary / All in all," break up overly tidy parallel structures, and so on.

Step 2: Persona and Memory#

Write your usual tone, style, core principles, and behavioral boundaries into SOUL.md:

Have the writing agent commit the workflow we just defined to its long-term memory file (MEMORY.md):

Step 3: Multi-Agent Collaboration#

Finally, a quick word on multi-agent collaboration — for this we use OpenClaw's Subagent architecture.

In OpenClaw's design, you can use Subagents to coordinate other Agents inside a single Agent to get work done together.

For example, to enable the case above where the Garden Orchestrator can call the image, collaboration, and news agents, you add to the configuration:

subagents: {
  allowAgents: ['img', 'writer', 'news'],
}

This config only opens up the multi-agent collaboration permission. If you want the Garden Orchestrator to be a competent manager, it has to know specifics about its sub-agents — so we recommend writing detailed capability descriptions for each sub-agent into the orchestrator's long-term memory: