Building Effective Agents với Claude — Hướng dẫn kiến trúc

AI Agents là gì — và tại sao chúng quan trọng

Một AI agent là hệ thống trong đó LLM không chỉ trả lời câu hỏi một lần mà điều phối một chuỗi hành động để hoàn thành mục tiêu phức tạp. Thay vì bạn phải break down task thủ công thành từng bước nhỏ, agent tự lên kế hoạch, thực thi từng bước, quan sát kết quả, và điều chỉnh kế hoạch nếu cần.

Năm 2025-2026 đánh dấu sự chuyển dịch từ "LLM as chatbot" sang "LLM as autonomous worker". Claude, với khả năng reasoning mạnh, tool use reliable, và context window 200K token, là một trong những model phù hợp nhất để build agents production-grade.

Agentic Loop — Vòng lặp cơ bản của mọi agent

Mọi AI agent đều hoạt động theo một vòng lặp cơ bản:

1. Observe: Thu thập thông tin về trạng thái hiện tại (từ tools, environment, user)
2. Plan: Quyết định bước tiếp theo cần làm
3. Act: Thực thi hành động (gọi tool, viết code, gọi API...)
4. Reflect: Đánh giá kết quả, cập nhật hiểu biết
5. Repeat: Lặp lại cho đến khi task hoàn thành hoặc cần human input

// Pseudo-code của agentic loop
async function agentLoop(task, tools, maxIterations = 20) {
  const messages = [{ role: 'user', content: task }];
  let iteration = 0;

  while (iteration < maxIterations) {
    const response = await claude.complete({
      system: AGENT_SYSTEM_PROMPT,
      messages,
      tools
    });

    // Kiểm tra nếu agent đã xong
    if (response.stop_reason === 'end_turn') {
      return response.content;
    }

    // Xử lý tool calls
    if (response.stop_reason === 'tool_use') {
      const toolResults = await executeTools(response.tool_calls);
      messages.push({ role: 'assistant', content: response.content });
      messages.push({ role: 'user', content: toolResults });
    }

    iteration++;
  }

  throw new Error('Max iterations reached');
}

Tool Use Fundamentals — Mắt, tai, và tay của agent

Tools là cách agent tương tác với thế giới bên ngoài context window. Mỗi tool là một function mà Claude có thể gọi khi cần.

Định nghĩa tool đúng cách

Chất lượng mô tả tool ảnh hưởng trực tiếp đến độ chính xác của agent. Claude đọc description để quyết định khi nào và cách nào gọi tool:

const tools = [
  {
    name: "search_web",
    description: "Tìm kiếm thông tin trên internet.
" +
      "Dùng khi cần thông tin cập nhật, sự kiện gần đây,
" +
      "hoặc facts không có trong training data.
" +
      "KHÔNG dùng cho thông tin đã biết chắc chắn.",
    input_schema: {
      type: "object",
      properties: {
        query: {
          type: "string",
          description: "Search query, nên ngắn gọn và cụ thể"
        },
        num_results: {
          type: "integer",
          description: "Số kết quả cần lấy (1-10, default: 5)",
          default: 5
        }
      },
      required: ["query"]
    }
  },
  {
    name: "execute_code",
    description: "Chạy Python code và trả về output.
" +
      "Dùng để tính toán, xử lý data, tạo charts.
" +
      "Code chạy trong sandbox an toàn, không có internet access.",
    input_schema: {
      type: "object",
      properties: {
        code: {
          type: "string",
          description: "Python code cần chạy"
        }
      },
      required: ["code"]
    }
  }
];

Tool design principles

• Single responsibility: Mỗi tool làm đúng một việc, làm tốt
• Clear boundaries: Mô tả rõ tool này dùng khi nào, không dùng khi nào
• Predictable outputs: Format output nhất quán để Claude xử lý dễ dàng
• Graceful errors: Tool luôn trả về structured error thay vì throw exception

Building Blocks — Ba thành phần cốt lõi

1. Planning — Lên kế hoạch trước khi hành động

Với task phức tạp, cho phép Claude "think out loud" trước khi bắt đầu thực thi:

SYSTEM: Khi nhận task phức tạp, hãy bắt đầu bằng:
1. Phân tích task: Task yêu cầu gì? Constraints là gì?
2. Lên kế hoạch: Các bước cụ thể cần thực hiện theo thứ tự
3. Identify risks: Điều gì có thể sai? Cần fallback gì?
Sau đó mới bắt đầu thực thi từng bước.

Kỹ thuật này — còn gọi là "plan-then-execute" — giúp giảm đáng kể số lượng iterations thất bại và cải thiện task success rate.

2. Execution — Thực thi chính xác và có kiểm soát

Trong quá trình thực thi, agent cần:

• Gọi tools theo đúng thứ tự logic (sequential khi có dependency, parallel khi độc lập)
• Validate output của mỗi tool trước khi dùng trong bước tiếp theo
• Nhận diện khi nào kết quả không như mong đợi và điều chỉnh kế hoạch

3. Reflection — Tự đánh giá và học từ lỗi

Sau mỗi action hoặc sau khi hoàn thành task, agent nên tự đánh giá:

// Reflection prompt sau khi hoàn thành subtask
"Vừa xong bước [X]. Kết quả có đúng như mong đợi không?
Nếu không, điều gì cần điều chỉnh trong kế hoạch tiếp theo?"

Multi-Agent Architectures

Khi task quá phức tạp cho một agent, multi-agent architecture cho phép phân tán công việc.

Pattern 1: Orchestrator + Workers

Đây là pattern phổ biến nhất. Một orchestrator agent nhận task gốc, phân tích, và giao phần việc cho các specialist workers:

// Orchestrator nhận task phức tạp
const orchestratorTask = "Phân tích thị trường smartphone Việt Nam Q1 2026:
" +
  "1. Search web để lấy sales data
" +
  "2. Phân tích market share
" +
  "3. Identify key trends
" +
  "4. Viết executive summary";

// Orchestrator quyết định giao cho workers:
// - ResearchAgent: thu thập data
// - AnalysisAgent: phân tích số liệu
// - WritingAgent: viết báo cáo

Pattern 2: Pipeline (Sequential)

Output của agent A là input của agent B — phù hợp khi workflow có thứ tự tuyến tính rõ ràng:

RawData → [CleaningAgent] → CleanData
       → [AnalysisAgent] → Insights
       → [ReportAgent]   → FinalReport

Pattern 3: Debate / Critique

Hai agents với perspective khác nhau cùng làm việc trên một task — một "Proposer" tạo solution, một "Critic" tìm lỗi và cải thiện. Hiệu quả đặc biệt cho code review và strategic decisions:

const proposerSystem = "Bạn là software architect.
" +
  "Đề xuất architecture solution cho task được giao.
" +
  "Ưu tiên simplicity và maintainability.";

const criticSystem = "Bạn là senior engineer với 10 năm kinh nghiệm.
" +
  "Review solution được đề xuất. Chỉ ra:
" +
  "- Potential failure points
" +
  "- Scalability concerns
" +
  "- Security issues
" +
  "- Better alternatives nếu có.";

// Round 1: Proposer creates design
// Round 2: Critic reviews
// Round 3: Proposer revises
// Round 4: Final critique + sign-off

Error Handling và Retry Strategies

Agents trong production sẽ gặp lỗi — đây là thực tế không thể tránh. Hệ thống agent tốt cần có error handling đa lớp:

Tool-level error handling

async function executeToolSafely(toolName, input) {
  try {
    const result = await tools[toolName](input);
    return { success: true, data: result };
  } catch (error) {
    return {
      success: false,
      error: error.message,
      suggestion: getSuggestionForError(error)
    };
  }
}

Agent-level retry với backoff

const retryConfig = {
  maxRetries: 3,
  backoffMs: [1000, 3000, 9000], // exponential backoff
  retryableErrors: ['rate_limit', 'timeout', 'tool_unavailable']
};

Fallback strategies

• Nếu tool A fails, thử tool B với cùng mục đích
• Nếu không thể hoàn thành subtask, đánh dấu và tiếp tục các subtask khác
• Khi vượt quá retry limit, escalate lên human-in-the-loop

Human-in-the-Loop — Khi nào cần con người

Không phải mọi quyết định đều nên delegate hoàn toàn cho agent. Thiết kế tốt cần xác định rõ các "checkpoint" yêu cầu human approval:

const HUMAN_APPROVAL_REQUIRED = [
  'delete_production_data',
  'send_bulk_email',
  'charge_customer',
  'deploy_to_production',
  'contact_external_partner'
];

async function executeAction(action) {
  if (HUMAN_APPROVAL_REQUIRED.includes(action.type)) {
    const approved = await requestHumanApproval(action);
    if (!approved) return { status: 'rejected' };
  }
  return await performAction(action);
}

Nguyên tắc: Bất kỳ hành động nào không thể undo hoặc có tác động lớn đến tài chính/uy tín đều nên có human checkpoint.

MCP — Model Context Protocol Integration

Model Context Protocol (MCP) là chuẩn mở do Anthropic phát triển, cho phép Claude kết nối với external data sources và tools theo cách chuẩn hóa. Thay vì viết custom integration cho mỗi tool, bạn dùng MCP server có sẵn:

// Ví dụ: Kết nối Claude với database qua MCP
// mcp-config.json
{
  "mcpServers": {
    "postgresql": {
      "command": "npx",
      "args": ["@modelcontextprotocol/server-postgres"],
      "env": {
        "POSTGRES_CONNECTION_STRING": "postgresql://..."
      }
    },
    "filesystem": {
      "command": "npx",
      "args": ["@modelcontextprotocol/server-filesystem"],
      "env": {
        "ALLOWED_DIRECTORIES": "/data/reports"
      }
    }
  }
}

MCP ecosystem đang phát triển nhanh — có sẵn MCP servers cho Google Drive, Slack, GitHub, Jira, database phổ biến, và nhiều hơn nữa. Điều này có nghĩa là bạn có thể build agent kết nối với tools của công ty mà không cần viết integration từ đầu.

Production Considerations

Chi phí và tối ưu

Agents tiêu tốn nhiều tokens hơn single-turn completions vì mỗi iteration phải gửi lại toàn bộ conversation history. Một số kỹ thuật tối ưu chi phí:

• Model tiering: Dùng Haiku cho planning đơn giản, Sonnet cho execution, Opus chỉ khi cần reasoning phức tạp
• Prompt caching: Cache system prompt và document context để tránh tính phí lại
• Early stopping: Detect khi task đã xong thay vì chạy đủ maxIterations

Latency

Mỗi iteration của agent loop = ít nhất 1-5 giây latency. Cho tasks cần 10-20 iterations, total time có thể là 1-2 phút. Strategies:

• Parallel tool execution khi tools không có dependency
• Streaming intermediate results về UI để user thấy progress
• Set expectations rõ ràng với user về expected completion time

Safety và guardrails

Agents có thể thực hiện hành động có tác động thực — quan trọng hơn nhiều so với chatbot thông thường:

• Implement resource limits (max API calls, max file size, max execution time)
• Sandbox environment cho code execution
• Audit log mọi action của agent
• Rate limiting để prevent runaway loops

Claude Agent SDK — Overview

Anthropic cung cấp Claude Agent SDK để đơn giản hóa việc build agents. SDK xử lý:

• Agentic loop management tự động
• Tool execution và result injection
• Error handling và retry logic
• Conversation history management

import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic();

// Định nghĩa tools
const tools = [/* ... */];

// Chạy agent với SDK
const result = await client.messages.create({
  model: "claude-opus-4",
  max_tokens: 8192,
  tools: tools,
  messages: [
    { role: "user", content: "Phân tích dữ liệu bán hàng tháng này và tạo báo cáo" }
  ]
});

// Developer cần tự implement agentic loop để handle tool_use responses

Real Examples — Agents hoạt động trong thực tế

Example 1: Code Review Agent

Agent nhận GitHub PR link, tự động fetch code changes, phân tích theo checklist (security, performance, code style), và tạo review comments chi tiết. Tools cần: fetch_github_pr, analyze_code, post_github_comment.

Example 2: Research Agent

Agent nhận topic, tự search web tìm sources, đọc và summarize mỗi source, cross-reference các claims, và tạo research report với citations. Tools cần: search_web, fetch_url, extract_content, write_report.

Example 3: Customer Support Agent

Agent kết nối với CRM và order management system, tự động xử lý 80% tickets thông thường (tracking, returns, FAQs), và chỉ escalate tickets phức tạp lên human agent. Tools cần: lookup_order, get_customer_profile, create_return_request, escalate_to_human.

Xây dựng effective agents không phải chỉ là kỹ thuật — đó là sự hiểu biết sâu sắc về khi nào nên trust AI và khi nào cần human judgment. Agents hoạt động tốt nhất khi được thiết kế với triết lý: tự động hóa những gì có thể tự động hóa an toàn, và gracefully hand off những gì vượt quá phạm vi đó.

---

Bài viết liên quan

• Context Engineering — Nghệ thuật quản lý context cho Claude
• Claude Code vs GitHub Copilot vs Cursor — Đâu là IDE AI tốt nhất?
• Claude API — Hướng dẫn từ A đến Z cho developer
• Extended Thinking + Tool Use — Suy luận sâu kết hợp công cụ
• Claude cho Data: Validation và data quality