Workflow Patterns — 5 mẫu điều phối trước khi cần Agent
Prompt chaining, routing, parallelization, orchestrator-workers, evaluator-optimizer: năm khối xây dựng giải quyết phần lớn bài toán 'agentic' mà không cần trao toàn quyền cho model.
Phần lớn hệ thống "agent" chạy tốt trong production thực chất là workflow: luồng do code điều khiển, LLM làm từng bước hẹp. Chúng rẻ hơn, nhanh hơn, dễ test và dễ giải thích hơn agent tự do. Năm pattern trong module này là bộ từ vựng chung của ngành — bạn sẽ gặp lại chúng dưới tên khác trong mọi framework. Nắm chắc chúng giúp bạn (a) không dùng agent cho bài toán chỉ cần workflow, và (b) ghép chúng bên trong một hệ agent khi cần.
🎯 Mục tiêu học tập
- Nhận diện và cài đặt được 5 workflow pattern cơ bản bằng code thuần
- Chọn đúng pattern theo đặc điểm bài toán: cố định hay rẽ nhánh, tuần tự hay song song, có tiêu chí đánh giá rõ hay không
- Dùng structured output để nối các bước một cách đáng tin cậy
- Biết điểm giới hạn của workflow — dấu hiệu cho thấy đã đến lúc cần agent loop
Tổng quan 5 pattern
| Pattern | Hình dạng luồng | Dùng khi | Ví dụ |
|---|---|---|---|
| Prompt chaining | A → B → C, có cổng kiểm tra giữa các bước | Tác vụ tách được thành các bước cố định | Dàn ý → kiểm tra dàn ý → viết bài |
| Routing | Phân loại → một trong N nhánh chuyên biệt | Đầu vào thuộc vài loại khác hẳn nhau | Ticket: hoàn tiền / kỹ thuật / hỏi chung |
| Parallelization | Tách ra N lời gọi chạy cùng lúc → gộp | Các phần độc lập, hoặc cần nhiều góc nhìn | Review code theo 4 khía cạnh; bỏ phiếu kiểm duyệt |
| Orchestrator-workers | LLM điều phối tự chia việc → worker → tổng hợp | Không biết trước cần chia thành mấy phần | Sửa một tính năng chạm vào số file chưa biết trước |
| Evaluator-optimizer | Sinh → chấm → sửa, lặp đến khi đạt | Có tiêu chí rõ và phản hồi giúp cải thiện thật | Dịch văn học; viết code đến khi test pass |
Ba pattern đầu là workflow thuần (code quyết định luồng). Hai pattern sau bắt đầu trao quyền cho model (model quyết định chia việc gì, hoặc khi nào đạt) — chúng là cầu nối sang agent.
Prompt chaining và cổng kiểm tra
Đổi một lời gọi khó lấy nhiều lời gọi dễ. Giá trị thật nằm ở cổng (gate) giữa các bước: một kiểm tra bằng code (hoặc LLM) quyết định đi tiếp, làm lại, hay dừng.
from pydantic import BaseModel
class Outline(BaseModel):
title: str
sections: list[str]
def write_article(topic: str) -> str:
outline = client.messages.parse(
model="claude-opus-5-5", max_tokens=16000,
messages=[{"role": "user", "content": f"Lập dàn ý bài viết kỹ thuật về: {topic}"}],
output_format=Outline,
).parsed_output
# Cổng: kiểm tra bằng code, rẻ và chắc chắn
if not (4 <= len(outline.sections) <= 8):
raise ValueError("Dàn ý không đạt, cần sinh lại")
draft = client.messages.create(
model="claude-opus-5-5", max_tokens=16000,
messages=[{"role": "user", "content": f"Viết bài theo dàn ý sau:\n{outline.model_dump_json()}"}],
)
return draft.content[0].text
Structured output (schema Pydantic/JSON) là keo nối các bước: bước sau nhận dữ liệu có kiểu thay vì phải phân tích văn bản tự do. Ưu tiên cổng bằng code (đếm, regex, validate schema, chạy test) trước khi nghĩ đến cổng bằng LLM.
Routing
Một bước phân loại rẻ quyết định nhánh xử lý; mỗi nhánh có prompt, tool, thậm chí model riêng. Lợi ích: mỗi nhánh được tối ưu độc lập mà không làm hỏng nhánh khác, và việc dễ được đưa cho model rẻ.
from typing import Literal
class Route(BaseModel):
category: Literal["refund", "technical", "general"]
reason: str
def handle_ticket(ticket: str) -> str:
route = client.messages.parse(
model="claude-haiku-4-5", max_tokens=512, # phân loại: model nhỏ là đủ
system="Phân loại ticket hỗ trợ vào đúng một nhóm.",
messages=[{"role": "user", "content": ticket}],
output_format=Route,
).parsed_output
handlers = {"refund": handle_refund, "technical": run_support_agent, "general": answer_faq}
return handlers[route.category](ticket)
Chú ý nhánh technical gọi một agent: routing là cách phổ biến để chỉ trả chi phí
agent cho phần đầu vào thật sự cần nó. Luôn có nhánh mặc định cho trường hợp phân loại không chắc, và
theo dõi phân bố các nhánh trong production — phân bố lệch đột ngột là tín hiệu có vấn đề.
Parallelization: chia phần và bỏ phiếu
Hai biến thể:
- Chia phần (sectioning): các phần việc độc lập chạy đồng thời — review bảo mật, hiệu năng, độ dễ đọc bằng ba lời gọi riêng, mỗi lời gọi tập trung một khía cạnh nên kỹ hơn một lời gọi "review tất cả".
- Bỏ phiếu (voting): cùng một câu hỏi chạy nhiều lần (hoặc với các prompt khác nhau) rồi lấy đa số/ngưỡng — dùng cho quyết định cần độ tin cậy cao như kiểm duyệt nội dung.
import asyncio
from anthropic import AsyncAnthropic
aclient = AsyncAnthropic()
ASPECTS = {
"security": "Chỉ tìm lỗ hổng bảo mật: injection, lộ secret, thiếu kiểm tra quyền.",
"performance": "Chỉ tìm vấn đề hiệu năng: N+1 query, vòng lặp thừa, thiếu index.",
"correctness": "Chỉ tìm lỗi logic và trường hợp biên chưa xử lý.",
}
async def review_one(aspect: str, instruction: str, diff: str) -> str:
r = await aclient.messages.create(
model="claude-opus-5-5", max_tokens=16000,
system=instruction,
messages=[{"role": "user", "content": diff}],
)
return f"## {aspect}\n{r.content[0].text}"
async def review(diff: str) -> str:
parts = await asyncio.gather(*(review_one(a, i, diff) for a, i in ASPECTS.items()))
return "\n\n".join(parts)
Song song hoá giảm độ trễ nhưng không giảm tổng token. Nhớ đặt giới hạn đồng thời (semaphore) để không vượt rate limit.
Orchestrator-workers
Khác parallelization ở chỗ số lượng và nội dung phần việc không biết trước — một LLM điều phối đọc yêu cầu rồi tự quyết định chia thành những việc con nào, giao cho worker, và tổng hợp.
class Subtask(BaseModel):
title: str
instructions: str # đủ ngữ cảnh để worker làm độc lập
class Plan(BaseModel):
subtasks: list[Subtask]
def orchestrate(request: str) -> str:
plan = client.messages.parse(
model="claude-opus-5-5", max_tokens=16000,
system="Chia yêu cầu thành các việc con độc lập. Mỗi việc con phải tự đủ ngữ cảnh.",
messages=[{"role": "user", "content": request}],
output_format=Plan,
).parsed_output
results = [run_worker(t.instructions) for t in plan.subtasks[:8]] # giới hạn cứng số worker
return synthesize(request, results)
Đây là dạng "một lượt" của hệ multi-agent (Module 10): điều phối viên lập kế hoạch một lần. Khi bạn cho điều phối viên xem kết quả rồi quyết định giao thêm việc, nó trở thành agent thật sự.
Evaluator-optimizer
class Verdict(BaseModel):
passed: bool
feedback: str
def generate_until_good(task: str, criteria: str, max_rounds: int = 3) -> str:
draft, feedback = "", ""
for _ in range(max_rounds):
draft = generate(task, previous=draft, feedback=feedback)
verdict = client.messages.parse(
model="claude-opus-5-5", max_tokens=16000,
system=f"Bạn là người thẩm định khắt khe. Tiêu chí:\n{criteria}",
messages=[{"role": "user", "content": draft}],
output_format=Verdict,
).parsed_output
if verdict.passed:
break
feedback = verdict.feedback
return draft
Pattern này chỉ đáng dùng khi thoả cả hai: có tiêu chí đánh giá rõ ràng, và phản hồi thực sự giúp bản sau tốt hơn. Vài lưu ý thực tế:
- Người chấm tốt nhất là thứ không phải LLM: test suite, compiler, linter, validator. Chỉ dùng LLM chấm cho tiêu chí không tự động hoá được.
- Người chấm cần context khác người viết (prompt riêng, lý tưởng là không thấy quá trình suy nghĩ của người viết) — nếu không nó dễ đồng tình với chính lập luận đã sinh ra lỗi.
- Luôn có số vòng tối đa, và ghi lại số vòng thực tế: nếu gần như luôn đạt ở vòng 1, bạn đang trả tiền gấp đôi vô ích.
Khi nào workflow không còn đủ
Dấu hiệu nên chuyển một phần (không nhất thiết toàn bộ) sang agent loop:
- Số nhánh
if/elsetrong code điều phối tăng không ngừng để xử lý ngoại lệ. - Bước tiếp theo phụ thuộc vào nội dung kết quả bước trước theo cách không liệt kê trước được.
- Số bước cần thiết dao động mạnh giữa các đầu vào (có ca 2 bước, có ca 40 bước).
- Cần khả năng phục hồi: thử cách A, thất bại, hiểu vì sao, thử cách B.
Kiến trúc lai rất phổ biến và thường là tốt nhất: workflow ở ngoài, agent ở trong — code lo routing, kiểm tra quyền, cổng duyệt và ghi nhận kết quả; agent chỉ được thả tự do trong một bước có phạm vi và bộ tool giới hạn.
🏋️ Bài tập thực hành
Bài toán: nhận một pull request (diff + mô tả) và sinh bản review. Cài đặt ba phiên bản: (A) một lời gọi LLM duy nhất; (B) workflow: routing theo loại thay đổi (docs/refactor/feature) → parallelization theo 3 khía cạnh → tổng hợp → evaluator kiểm tra "mỗi nhận xét có trỏ đúng dòng và có đề xuất sửa không"; (C) agent loop ở Module 2 với tool đọc file trong repo để hiểu ngữ cảnh ngoài diff. Chạy cả ba trên 10 PR thật của một repo mã nguồn mở, so sánh: chất lượng (bạn tự chấm mù), chi phí, độ trễ. Viết nửa trang kết luận: phiên bản nào bạn sẽ đưa vào production và vì sao.
📚 Tài nguyên học tập
-
Anthropic — Building Effective AgentsNguồn gốc của 5 pattern, kèm sơ đồ và tình huống áp dụngBài viết
-
Anthropic Cookbook — Agent patternsNotebook cài đặt tham khảo cho từng patternCode
-
Claude Docs — Structured outputsÉp output theo schema để nối các bước workflowDocs
✅ Tự đánh giá hoàn thành
- Cài đặt được cả 5 pattern bằng code thuần, không framework
- Nói được pattern nào do code điều khiển luồng, pattern nào đã trao một phần quyền cho model
- Dùng structured output và cổng kiểm tra bằng code giữa các bước
- Đã so sánh bằng số liệu giữa 1 lời gọi, workflow, và agent trên cùng một bài toán