Multi-Agent Brand Studio

Sets up a multi-agent AI-powered social media team with brand-isolated workspaces, approval workflows, shared knowledge base, and Telegram integration on Ope...

Security Scan

The skill's purpose (multi-brand multi-agent social media studio with Telegram integration) matches the files and instructions, but there are important inconsistencies and potentially risky behaviors (config patching, cron jobs, writing bot tokens to config, running shell/Node scripts) you should review before installing.

Purpose & Capability

The code and SKILL.md implement the described features (scaffolding agents, brand files, approval workflow, Telegram integration, cron jobs). However the registry metadata lists no required binaries/env but the SKILL.md metadata and runtime steps require Node and bash. That mismatch (declared requirements vs actual instructions) is an incoherence to be aware of.

Instruction Scope

Runtime instructions explicitly tell the agent/operator to run scaffold.sh and node scripts that will create files and patch ~/.openclaw/openclaw.json, set up cron jobs, and write a Telegram bot token into config. Instructions also rely on reading incoming Telegram message context (to extract chat IDs). Those actions touch system configuration and secrets and go beyond simple prompt/roleplay behavior — review scripts and config changes carefully before running.

Install Mechanism

There is no package install spec (instruction-only), but the bundle includes shell and Node scripts that are meant to be executed locally. That is lower-risk than an arbitrary remote download, but running included scripts still writes to disk and modifies config. Optional QMD installation uses npm/bun (public registries) which is expected but introduces native addons (better-sqlite3) with rebuild steps in troubleshooting.

Credentials

The skill will require access to local OpenClaw config (~/.openclaw/openclaw.json), an LLM auth profile, and a Telegram bot token. The registry declared no required env vars/credentials, but the instructions require an auth profile and storing a bot token in openclaw.json — storing secrets in plaintext config and modifying system config without explicit declaration is disproportionate and should be validated by the user.

Persistence & Privilege

always:false (normal), but the skill's scripts and created cron job definitions persist automation (scheduled leader routines, task checks) and patch the agent gateway config. Combined with normal autonomous invocation, that increases the blast radius if misconfigured — inspect cron/job payloads and the patch-config.js behavior before enabling.

What to consider before installing

This skill largely does what it says, but it requires running included shell/Node scripts that will modify ~/.openclaw/openclaw.json, create directories and cron definitions, and store a Telegram bot token in config. Before installing: 1) Backup your ~/.openclaw/openclaw.json and other OpenClaw data. 2) Manually review scripts/patch-config.js, scripts/scaffold.sh, and scripts/telegram-topics.js to see exactly what they change (search for file writes, exec/spawn, network calls, and any hardcoded endpoints). 3) Confirm you accept storing the bot token in openclaw.json or change the workflow to use a secret store. 4) If you don’t want persistent automation immediately, don’t merge cron/job changes or run the config-patcher — scaffold files locally first. 5) If you plan to enable QMD, be prepared to run global npm/bun installs and rebuild native modules (better-sqlite3) as documented. 6) Consider testing in an isolated/dev OpenClaw instance rather than your production instance. If you want, I can list the exact code locations to inspect and flag suspicious patterns inside those scripts.

name: multi-agent-brand-studio description: Use when setting up Multi-Agent Brand Studio on OpenClaw for multi-brand social media operations, approval-gated publishing, brand-isolated workspaces, or multi-agent content workflows. metadata: { "openclaw": { "emoji": "📱", "requires": { "bins": ["node"] } } }

Overview

This skill sets up Multi-Agent Brand Studio, a complete AI-powered social media operations team on OpenClaw. It creates:

• 5 specialized agents in a star topology (Leader + 4 specialists) + on-demand Reviewer
• Persistent A2A sessions for context-preserving multi-agent workflows
• 3-layer memory system (MEMORY.md + daily notes + shared knowledge base)
• Shared knowledge base with brand profiles, operations guides, and domain knowledge
• Approval workflow ensuring nothing publishes without owner approval
• Brand isolation with per-brand channels, content guidelines, and asset directories
• Cron automation for daily memory consolidation and weekly KB review

Optional Dependencies

• Image generation tool for Creator agent: The Creator agent requires an image generation tool installed in its workspace-creator/skills/ directory to produce images. Recommended: nano-banana-pro (Gemini-based, free tier). Without it, Creator produces text visual briefs only and cannot generate images.

Prerequisites

Before installing, ensure:

1. OpenClaw v2026.2.26+ is installed and openclaw onboard has been completed
2. At least one auth profile exists (e.g., Anthropic API key)
3. The ~/.openclaw/ directory exists

Quick Start

1. Install the skill (if not already in workspace/skills/)
2. Trigger setup: "Set up Multi-Agent Brand Studio"
3. Follow the interactive onboarding (6 steps, ~10 minutes)
4. Start creating content!

Onboarding Flow

When first triggered, this skill runs an interactive setup process.

Step 1: Prerequisites Check

Verify the environment is ready:

• OpenClaw installed and openclaw onboard completed
• ~/.openclaw/ directory exists
• At least one auth profile configured

If any prerequisite is missing, guide the user to resolve it before continuing.

Step 2: Team Setup

All 5 agents are installed automatically. Do not ask the user to choose a team size.

The full team:

Agent	Role
Leader	Orchestration, routing, quality gates
Creator	Content + visual (copywriting, image gen, platform formatting)
Worker	Execution for Leader (files, CLI, config, maintenance)
Researcher	Market research, competitor analysis
Engineer	Technical integrations, automation

On-demand:

Agent	Role
Reviewer	Independent quality review (spawned when needed)

Model — All agents inherit the model configured during openclaw onboard (at agents.defaults.model). No per-agent model setup is needed.

Advanced note: If you later want to run a leaner team, re-run scaffold.sh --agents leader,creator,engineer to scaffold a subset.

Step 3: Run Scaffold

Execute the setup scripts to create all directories and files first:

# 1. Create directories, copy templates, set up symlinks
bash scripts/scaffold.sh \
  --skill-dir "$(pwd)"

# 2. Merge agent configuration into openclaw.json
node scripts/patch-config.js \
  --config ~/.openclaw/openclaw.json

The scaffold creates:

• Agent workspace directories with SOUL.md, AGENTS.md, MEMORY.md
• Shared knowledge base with all template files
• Symlinks from each workspace to shared/
• Sub-skills (instance-setup, brand-manager) in Leader's skills/
• Cron job definitions

The config patcher merges into openclaw.json:

• Agent definitions with model assignments and tool restrictions
• A2A session configuration
• QMD memory paths (only if QMD is installed — otherwise skipped with a suggestion)
• Internal hooks

Step 4: Telegram Setup

This step uses a guided flow — do not ask the user for raw chat IDs or thread IDs.

Phase A: Confirm Bot Token

1. Check openclaw.json for channels.telegram.botToken
2. If present → skip to Phase B
3. If missing → guide the user:
   • "Open Telegram, search for @BotFather"
   • "Send /newbot and follow the prompts to create a bot"
   • "Copy the bot token and paste it here"
   • Write the token into openclaw.json at channels.telegram.botToken

Phase B: Choose Channel Mode

Present the options in this order (Group+Topics first):

1. Group+Topics (recommended) — Best for most setups

   • Brands are topic threads inside a Telegram supergroup
   • Works for both solo operators and multi-person teams
   • Requires a supergroup with Topics enabled

2. DM+Topics — Private alternative, no group needed

   • Each brand gets its own topic thread inside the bot's DM
   • Requires enabling Thread Mode on the bot (guided below)

3. DM-simple — Minimal, no brand isolation

   • Single DM conversation with the bot
   • Context-based brand routing (no topics)

4. Group-simple — Group without brand isolation

   • Single group conversation
   • Context-based brand routing (no topics)

Phase C: Mode-Specific Setup

If DM+Topics:

1. Guide the user to enable Thread Mode on their bot:
   • "Open Telegram, find @BotFather"
   • "Tap the Open button (bottom-left) to open the BotFather MiniApp"
   • "Select your bot in the MiniApp"
   • "Go to Bot Settings"
   • "Find Thread Mode and enable it"
   • "Come back and tell me when it's done"
2. Once confirmed, use the bot token to get the user's chat ID:
   • "Send any message to your bot in Telegram"
   • Agent reads the incoming message context to extract the user's chat ID from {{From}}
   • Agent writes the chat ID into the channel config
3. Create the Operations topic automatically:

   node scripts/telegram-topics.js \
     --config ~/.openclaw/openclaw.json \
     --chat <USER_CHAT_ID> \
     --name "Operations"
   

4. Write the resulting thread ID into shared/operations/channel-map.md
5. Update cron/jobs.json — replace {{OPERATIONS_CHANNEL}} with the actual Operations channel address (format: chatId:threadId, e.g., 123456789:7)

If Group+Topics:

1. Check if the user already has a supergroup:
   • If not: guide them to create one (Create Group → toggle "Topics" on)
2. Guide the user to add the bot to the group:
   • "Add your bot to the supergroup"
   • "Make the bot an admin with the Manage Topics permission"
   • "Send a message in the group"
3. Agent reads the incoming message context to extract:
   • Group chat ID from {{To}}
   • Agent writes the chat ID into the channel config
4. Create the Operations topic automatically:

   node scripts/telegram-topics.js \
     --config ~/.openclaw/openclaw.json \
     --chat <GROUP_CHAT_ID> \
     --name "Operations"
   

5. Write the resulting thread ID into shared/operations/channel-map.md
6. Update cron/jobs.json — replace {{OPERATIONS_CHANNEL}} with the actual Operations channel address (format: chatId:threadId, e.g., -100XXXXXXXXXX:7)

If DM-simple:

1. "Send any message to your bot in Telegram"
2. Agent reads the chat ID from the incoming message context
3. Write chat ID into channel config — done

If Group-simple:

1. Guide: "Add the bot to your group and send a message"
2. Agent reads the group chat ID from the incoming message context
3. Write chat ID into channel config — done

Step 5: Instance Setup + First Brand

After scaffolding and Telegram configuration, run the sub-skills:

1. Instance Setup (instance-setup skill)

   • Owner name and timezone
   • Communication language (owner-facing)
   • Default content language
   • Bot identity (name, emoji, personality)
   • Updates: shared/INSTANCE.md, workspace/IDENTITY.md

2. First Brand (brand-manager add)

   • Brand ID, display name, domain
   • Target market and content language
   • Topic creation (for Topics modes):
     • Agent calls scripts/telegram-topics.js to create a topic named after the brand
     • The script returns the thread ID
     • Agent writes the thread ID into shared/operations/channel-map.md and the brand config
   • For simple modes: no topic needed, skip thread ID
   • Creates: brand profile, content guidelines, domain knowledge file, asset directories

Step 6: Verification + Gateway Restart

1. Restart gateway:

   openclaw gateway restart
   

2. Run diagnostics:

   openclaw doctor
   

   This validates: agent config, DM allowlist inheritance, session health, model availability, and workspace integrity.

3. Additional checks:

   • Leader responds to messages
   • sessions_send to at least one agent succeeds

Optional: Enable QMD semantic memory

If patch-config.js reported "qmd binary not found" during Step 3, agents will use file-based memory (which works fine). To enable enhanced semantic search:

• Say "Set up QMD" to run the qmd-setup sub-skill, which guides you through installation and configuration.

Suggested first tasks after setup:

1. Fill in your brand profile: shared/brands/{brand_id}/profile.md
2. Test content creation: "Write a Facebook post for {brand}"
3. Add more brands: "Add a new brand"
4. Set up posting schedule: fill in shared/operations/posting-schedule.md

Post-Installation

Async Dispatch Model (v2.0.0+)

Leader uses fully async dispatch (sessions_send with timeoutSeconds: 0) for all agent communication. This means:

• Leader is never blocked waiting for an agent — always available to the owner.
• Agents callback to Leader via sessions_send when done (event-driven, not polling). Leader processes callbacks per the "Agent Callback Protocol" flow in AGENTS.md.
• Each task is tracked in a separate file: tasks/T-{YYYYMMDD}-{HHMM}.md. Completed tasks are archived to tasks/archive/.
• Stale task detection is handled by a cron job (stale-task-check, every 10 minutes) that scans tasks/ for steps stuck in [⏳] state. Runs as Leader.
• HEARTBEAT.md ships empty by default — periodic checks are handled by cron jobs instead of heartbeat polls.

Secrets Management (Optional)

For centralized API key management instead of scattered env vars:

openclaw secrets audit      # Check for plaintext secrets in config
openclaw secrets configure  # Set up secret entries
openclaw secrets apply      # Activate secrets
openclaw secrets reload     # Hot-reload without gateway restart

Adding More Brands

Use the brand-manager sub-skill:

• "Add a new brand" — interactive brand creation (auto-creates topic for Topics modes)
• "List brands" — show all active brands
• "Archive {brand}" — deactivate a brand

Customizing Agents

Each agent's behavior is defined in two files:

• SOUL.md — Persona, philosophy, boundaries, safety rules
• AGENTS.md — Operating procedures, data handling, brand scope, tools

Modify these files to tune agent behavior for your specific needs.

Memory System

The 3-layer memory system works automatically:

• MEMORY.md — Long-term curated memory (auto-updated by cron)
• memory/YYYY-MM-DD.md — Daily activity logs
• shared/ — Permanent knowledge base (grows over time)

Optional enhancement: Install QMD for semantic search across the knowledge base. Use the qmd-setup sub-skill or install manually (bun install -g @tobilu/qmd).

See references/memory-system.md for detailed documentation.

Communication Signals

Agents use standardized signals to communicate status. See references/signals-protocol.md for the complete signal dictionary.

Reference Documentation

Document	Purpose	When to Read
references/architecture.md	Star topology, session model, parallelism	Understanding system design
references/agent-roles.md	Detailed agent capabilities and restrictions	Customizing team composition
references/signals-protocol.md	Complete signal dictionary	Debugging agent communication
references/memory-system.md	3-layer memory + knowledge capture	Understanding memory behavior
references/approval-workflow.md	Approval pipeline + owner shortcuts	Content publishing workflow
references/troubleshooting.md	Known issues (IPv6, etc.) + solutions	When something breaks

Directory Structure

After installation, the following structure is created:

~/.openclaw/
├── openclaw.json                    # Updated with agent configs
├── workspace/                       # Leader
│   ├── SOUL.md, AGENTS.md, HEARTBEAT.md, IDENTITY.md
│   ├── memory/, skills/, assets/
│   └── shared/                      # Real directory (shared KB lives here)
│       ├── INSTANCE.md              # Instance configuration
│       ├── brand-registry.md        # Brand registry
│       ├── system-guide.md, brand-guide.md, compliance-guide.md
│       ├── team-roster.md
│       ├── brands/{id}/profile.md   # Per-brand profiles
│       ├── domain/{id}-industry.md  # Industry knowledge
│       ├── operations/              # Ops guides
│       └── errors/solutions.md      # Error KB
├── workspace-creator/               # Creator
│   ├── SOUL.md, AGENTS.md, MEMORY.md
│   ├── memory/, skills/
│   └── shared -> ../workspace/shared/
├── workspace-worker/                # Worker
│   └── (same structure)
├── workspace-researcher/            # Researcher
│   └── (same structure)
├── workspace-engineer/              # Engineer
│   └── (same structure)
├── workspace-reviewer/              # Reviewer (minimal, read-only)
│   ├── SOUL.md, AGENTS.md
│   └── shared -> ../workspace/shared/
└── cron/jobs.json                   # Scheduled tasks

Scripts

Script	Purpose	When to Run
scripts/scaffold.sh	Create directories, copy templates, set up symlinks	During initial setup
scripts/patch-config.js	Merge agent config into openclaw.json	During initial setup
scripts/telegram-topics.js	Create forum topics in Telegram DM or supergroup	During setup and when adding brands

Sub-Skills

Skill	Purpose
instance-setup	Configure owner info, language, bot identity
brand-manager	Add, edit, archive brands
qmd-setup	Install and configure QMD semantic search memory (optional)