สร้าง Multi-Agent Workflow ด้วย OpenClaw

ทำไมต้อง Multi-Agent?

Single Agent ทำงานได้หลายอย่าง แต่มีข้อจำกัดที่ชัดเจน: context window จำกัด (ยิ่งยาวยิ่งลืม), ไม่สามารถทำงานหลายอย่างพร้อมกันได้, ยิ่งงานซับซ้อนยิ่ง hallucinate — Multi-Agent แก้ปัญหาเหล่านี้โดย แบ่งงานให้ Agent เฉพาะทาง แต่ละตัวรับผิดชอบงานที่ถนัด แล้วประสานงานกัน

เปรียบเทียบ	Single Agent	Multi-Agent
Complexity	ทำงานง่ายๆ ได้ดี งานซับซ้อนเริ่มสับสน	แบ่งงานซับซ้อนเป็นงานย่อย แต่ละตัวโฟกัสเรื่องเดียว
Accuracy	ยิ่งงานเยอะยิ่ง hallucinate	Agent เฉพาะทาง + Reviewer ตรวจสอบ = แม่นยำกว่า
Scalability	ติด context window ไม่สามารถขยายได้	เพิ่ม Agent ได้ตามต้องการ ขยายง่าย
Specialization	ต้องเก่งทุกอย่าง (jack of all trades)	แต่ละตัวเชี่ยวชาญเรื่องเดียว (master of one)
Fault Tolerance	ถ้า Agent พัง = ทุกอย่างหยุด	Agent ตัวหนึ่งพัง ตัวอื่นทำงานต่อได้ + fallback

Agent Roles — ออกแบบทีม AI

แนวคิดหลักของ Multi-Agent คือ แทนที่จะให้ Agent ตัวเดียวทำทุกอย่าง ให้แบ่งงานให้ Agent หลายตัว แต่ละตัวเชี่ยวชาญเรื่องเดียว เหมือนทีมงานในองค์กรจริง — มีผู้จัดการ นักวิจัย นักวิเคราะห์ นักเขียน และ QA แต่ละคนรับผิดชอบงานที่ถนัด ผลลัพธ์ดีกว่าให้คนเดียวทำทุกอย่าง

Agent Role	หน้าที่	ตัวอย่างงาน
Coordinator Agent	รับคำสั่งจาก user กระจายงานให้ Agent อื่น รวมผลลัพธ์	รับคำสั่ง "วิเคราะห์คู่แข่ง" แล้วมอบหมายงานให้แต่ละทีม
Research Agent	ค้นหาข้อมูล ท่องเว็บ สรุปข่าว	ค้นหาข่าวคู่แข่ง 3 เดือนล่าสุด สรุปเป็น bullet points
Data Agent	ดึงข้อมูลจาก DB/API วิเคราะห์ตัวเลข	ดึงยอดขายจาก ERP เปรียบเทียบกับค่าเฉลี่ยอุตสาหกรรม
Writer Agent	เขียนรายงาน สร้างเอกสาร จัดรูปแบบ	รวมข้อมูลจาก Research + Data เขียนเป็นรายงาน PDF
Reviewer Agent	ตรวจสอบผลลัพธ์ QA ก่อนส่งกลับ user	ตรวจความถูกต้องของตัวเลข ภาษา ก่อนส่ง final report

การแบ่ง Agent เป็น role ที่ชัดเจนทำให้แต่ละตัว มี prompt ที่โฟกัส ไม่ต้องแบกรับ context มากเกินไป — เหมือนการออกแบบ Skill เฉพาะทาง แต่ยกระดับขึ้นเป็น Agent ทั้งตัว

Orchestration Patterns — รูปแบบการประสานงาน

การที่ Agent หลายตัวทำงานร่วมกันได้ต้องมี pattern การประสานงาน ที่ชัดเจน — OpenClaw รองรับ 4 รูปแบบหลัก:

Pattern	วิธีทำงาน	เหมาะกับ	ข้อดี
Sequential	A → B → C (ทำทีละขั้น)	งานที่ขั้นตอนถัดไปต้องใช้ผลลัพธ์จากขั้นก่อน	ง่าย debug ง่าย ผลลัพธ์ predictable
Parallel	A + B + C พร้อมกัน → รวมผล	งานที่แต่ละส่วนเป็นอิสระ ไม่ต้องรอกัน	เร็ว ประหยัดเวลา
Hierarchical	Boss Agent สั่งลูกน้อง ลูกน้องรายงานกลับ	งานซับซ้อนที่ต้องมีการตัดสินใจระหว่างทาง	ยืดหยุ่น ปรับแผนได้ตามสถานการณ์
Feedback Loop	ทำ → Review → แก้ → Review อีก	งานที่ต้องการคุณภาพสูง เช่น เขียนรายงาน	คุณภาพดี ผ่านการตรวจสอบหลายรอบ

# Sequential Pattern
User → [Research Agent] → [Data Agent] → [Writer Agent] → [Reviewer Agent] → User

# Parallel Pattern
              → [Research Agent] →
User → Fork                          Merge → [Writer Agent] → User
              → [Data Agent]     →

# Hierarchical Pattern
User → [Coordinator Agent] →→ [Research Agent] → report back
                               →→ [Data Agent]     → report back
                               →→ [Writer Agent]   → report back
                               → Combine → User

# Feedback Loop Pattern
User → [Writer Agent] ↔ [Reviewer Agent] (loop until approved) → User

สร้าง Multi-Agent Workflow — ตัวอย่างจริง

มาลองสร้าง Workflow จริงกัน — Use Case: "สร้างรายงานวิเคราะห์คู่แข่ง" ที่ Coordinator Agent กระจายงานให้ Agent 4 ตัวทำงานร่วมกัน

Workflow Overview

User: "วิเคราะห์คู่แข่ง 3 รายในตลาด ERP ประเทศไทย"
  |
  v
[Coordinator Agent] -- กระจายงาน -->
  |
  |--> [Research Agent]  ค้นข่าวคู่แข่ง 3 เดือนล่าสุด
  |--> [Data Agent]      ดึงข้อมูลส่วนแบ่งตลาด + pricing
  |
  v (รอผลจากทั้งสอง)
  |
  |--> [Writer Agent]    เขียนรายงานจากข้อมูลที่ได้
  |
  v
  |--> [Reviewer Agent]  ตรวจสอบ QA
  |
  v (ถ้าไม่ผ่าน กลับไป Writer แก้)
  |
  v
User: ได้รับรายงานฉบับสมบูรณ์

Workflow Config (YAML)

# workflows/competitor-analysis.yaml

name: competitor-analysis
description: "วิเคราะห์คู่แข่งแบบ Multi-Agent"

agents:
  coordinator:
    role: "Coordinator"
    model: "gpt-4"
    prompt: "คุณเป็นผู้จัดการโปรเจค รับคำสั่งจาก user แบ่งงานให้ทีม รวมผลลัพธ์"

  researcher:
    role: "Research"
    model: "gpt-4"
    prompt: "คุณเป็นนักวิจัยตลาด ค้นหาข้อมูลคู่แข่ง สรุปข่าว วิเคราะห์แนวโน้ม"
    skills: ["web-search", "news-summary"]

  data_analyst:
    role: "Data Analysis"
    model: "gpt-4"
    prompt: "คุณเป็นนักวิเคราะห์ข้อมูล ดึงตัวเลขจาก DB/API สร้างกราฟ เปรียบเทียบ"
    skills: ["db-query", "chart-generator"]

  writer:
    role: "Writer"
    model: "gpt-4"
    prompt: "คุณเป็นนักเขียนรายงาน รวมข้อมูลจากทีมวิจัยและวิเคราะห์ เขียนรายงานที่อ่านง่าย"

  reviewer:
    role: "Reviewer"
    model: "gpt-4"
    prompt: "คุณเป็น QA ตรวจสอบความถูกต้อง ภาษา ตัวเลข ก่อนส่งรายงานให้ user"

workflow:
  - step: "research"
    agent: ["researcher", "data_analyst"]
    mode: "parallel"

  - step: "write"
    agent: "writer"
    input_from: ["researcher", "data_analyst"]

  - step: "review"
    agent: "reviewer"
    input_from: "writer"
    retry_if_failed: true
    max_retries: 2

Coordinator Logic (JavaScript)

// coordinator.js — รับคำสั่ง กระจายงาน รวมผลลัพธ์

const { AgentRunner, WorkflowEngine } = require('@openclaw/sdk');

async function runCompetitorAnalysis(userRequest) {
  const engine = new WorkflowEngine('workflows/competitor-analysis.yaml');

  // Step 1: Parallel — Research + Data Analysis
  console.log('[Coordinator] Dispatching to Research & Data agents...');
  const [researchResult, dataResult] = await Promise.all([
    engine.run('researcher', {
      task: `ค้นหาข่าวคู่แข่ง: ${userRequest}`,
      timeRange: '3 months'
    }),
    engine.run('data_analyst', {
      task: `ดึงข้อมูลตลาดและ pricing: ${userRequest}`,
      sources: ['market-db', 'pricing-api']
    })
  ]);

  // Step 2: Sequential — Writer รวมผลลัพธ์
  console.log('[Coordinator] Dispatching to Writer...');
  const report = await engine.run('writer', {
    task: 'เขียนรายงานวิเคราะห์คู่แข่ง',
    researchData: researchResult.output,
    analyticsData: dataResult.output,
    format: 'executive-summary'
  });

  // Step 3: Feedback Loop — Reviewer ตรวจสอบ
  let finalReport = report;
  for (let attempt = 0; attempt < 3; attempt++) {
    console.log(`[Coordinator] Review attempt ${attempt + 1}...`);
    const review = await engine.run('reviewer', {
      task: 'ตรวจสอบรายงาน',
      report: finalReport.output
    });

    if (review.output.approved) {
      console.log('[Coordinator] Report approved!');
      return review.output.finalReport;
    }

    // ส่งกลับให้ Writer แก้
    finalReport = await engine.run('writer', {
      task: 'แก้ไขรายงานตาม feedback',
      originalReport: finalReport.output,
      feedback: review.output.feedback
    });
  }

  return finalReport.output;
}

Message Passing — Agent คุยกันอย่างไร?

หัวใจของ Multi-Agent คือการ ส่งข้อมูลระหว่าง Agent — OpenClaw รองรับ 3 วิธีหลัก แต่ละวิธีเหมาะกับ use case ต่างกัน:

วิธี	หลักการ	เหมาะกับ	ข้อจำกัด
Direct	Agent ส่งข้อมูลให้ Agent ตรงๆ (agent-to-agent)	workflow ง่ายๆ 2-3 Agent	Agent ต้องรู้จักกัน ไม่ยืดหยุ่น
Shared Memory	Agent ทุกตัวอ่าน/เขียน shared context object	workflow ที่ Agent ต้องเห็นข้อมูลเดียวกัน	ต้องจัดการ race condition
Event Bus	pub/sub — Agent publish event, Agent อื่น subscribe	workflow ซับซ้อนที่ Agent เยอะ	ซับซ้อน debug ยากกว่า

Shared Context Object

// shared-context.js — ทุก Agent อ่าน/เขียนผ่าน object นี้

const sharedContext = {
  // ข้อมูลจาก User
  userRequest: "วิเคราะห์คู่แข่ง ERP ในไทย",
  createdAt: "2026-04-03T09:00:00Z",

  // Research Agent เขียนผลลัพธ์ลงที่นี่
  research: {
    status: "completed",
    competitors: [
      { name: "Competitor A", marketShare: "25%", strengths: ["ราคาถูก"] },
      { name: "Competitor B", marketShare: "18%", strengths: ["ฟีเจอร์เยอะ"] },
      { name: "Competitor C", marketShare: "12%", strengths: ["บริการดี"] }
    ],
    lastUpdated: "2026-04-03T09:05:00Z"
  },

  // Data Agent เขียนผลลัพธ์ลงที่นี่
  analytics: {
    status: "completed",
    marketSize: "15,000 ล้านบาท",
    growthRate: "12% YoY",
    lastUpdated: "2026-04-03T09:04:30Z"
  },

  // Writer Agent เขียนรายงานลงที่นี่
  report: { status: "pending", content: null },

  // Reviewer Agent เขียน feedback ลงที่นี่
  review: { status: "pending", approved: false, feedback: null }
};

Event Bus Pattern

// event-bus.js — pub/sub สำหรับ Agent สื่อสารกัน

const { EventBus } = require('@openclaw/sdk');
const bus = new EventBus();

// Research Agent — publish เมื่อค้นหาเสร็จ
bus.on('task:research', async (task) => {
  const result = await researchAgent.run(task);
  bus.emit('research:completed', result);
});

// Data Agent — publish เมื่อวิเคราะห์เสร็จ
bus.on('task:analyze', async (task) => {
  const result = await dataAgent.run(task);
  bus.emit('analysis:completed', result);
});

// Writer Agent — subscribe รอผลจาก Research + Data
let pendingResults = {};
bus.on('research:completed', (data) => {
  pendingResults.research = data;
  checkAndWrite();
});
bus.on('analysis:completed', (data) => {
  pendingResults.analysis = data;
  checkAndWrite();
});

function checkAndWrite() {
  if (pendingResults.research && pendingResults.analysis) {
    bus.emit('task:write', {
      research: pendingResults.research,
      analysis: pendingResults.analysis
    });
  }
}

// เริ่ม Workflow — emit tasks แบบ parallel
bus.emit('task:research', { query: "คู่แข่ง ERP ไทย" });
bus.emit('task:analyze', { query: "ส่วนแบ่งตลาด ERP" });

Error Handling & Fallback

Multi-Agent มีโอกาสผิดพลาดมากกว่า Single Agent เพราะมี moving parts เยอะกว่า — ต้อง บริหารความเสี่ยง และวาง แผนฉุกเฉิน ให้ดี:

สถานการณ์	สาเหตุ	วิธีจัดการ
Agent ไม่ตอบ (Timeout)	LLM ช้า, network error, Agent crash	ตั้ง timeout + retry 2-3 ครั้ง + fallback agent
Agent ตอบผิด (Validation Failed)	Hallucination, wrong format, missing fields	Schema validation + ส่ง feedback ให้ Agent แก้ไข
API Error	External API down, authentication expired	Retry with exponential backoff + cache ข้อมูลเก่า
LLM Rate Limit	ส่ง request เยอะเกินไปพร้อมกัน	Queue system + stagger requests + fallback model

// error-handling.js — Retry Logic + Fallback Agent

async function runWithRetry(agent, task, options = {}) {
  const maxRetries = options.maxRetries || 3;
  const timeout = options.timeout || 30000; // 30 seconds
  const fallbackAgent = options.fallbackAgent || null;

  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      console.log(`[Retry] Attempt ${attempt}/${maxRetries} for ${agent.name}`);

      const result = await Promise.race([
        agent.run(task),
        new Promise((_, reject) =>
          setTimeout(() => reject(new Error('Timeout')), timeout)
        )
      ]);

      // Validate output
      if (!result || !result.output) {
        throw new Error('Invalid output: missing required fields');
      }

      return result;
    } catch (error) {
      console.error(`[Retry] ${agent.name} failed: ${error.message}`);

      if (attempt === maxRetries && fallbackAgent) {
        console.log(`[Retry] Switching to fallback: ${fallbackAgent.name}`);
        return fallbackAgent.run(task);
      }

      // Exponential backoff
      await new Promise(r => setTimeout(r, 1000 * Math.pow(2, attempt)));
    }
  }

  throw new Error(`All retries failed for ${agent.name}`);
}

OpenClaw Deep Dive Series — อ่านต่อ

"Multi-Agent Workflow เปลี่ยน AI จากผู้ช่วยคนเดียว เป็นทีมงานอัจฉริยะที่ประสานงานกันอัตโนมัติ — ทำงานที่ซับซ้อนได้แม่นยำกว่า เร็วกว่า และเชื่อถือได้มากกว่า"

- ทีมงาน Saeree ERP

แหล่งอ้างอิง

• OpenClaw Multi-Agent Documentation (Official)
• CrewAI — Multi-Agent Framework Reference
• AutoGen — Microsoft Multi-Agent Framework
• LangGraph Documentation — Agent Orchestration