Agent Loop — Nền tảng xây dựng AI Agent với Claude

Nếu bạn đã từng dùng Claude để hỏi-đáp hoặc sinh văn bản, bạn mới chỉ khai thác một phần nhỏ sức mạnh của nó. Sức mạnh thực sự nằm ở khả năng biến Claude thành một AI Agent — một hệ thống tự động suy nghĩ, hành động, quan sát kết quả và lặp lại cho đến khi hoàn thành nhiệm vụ. Trái tim của mọi AI Agent chính là Agent Loop.

Agent Loop là gì?

Agent Loop là một vòng lặp gồm 4 bước cơ bản:

1. Think (Suy nghĩ): Agent phân tích tình huống hiện tại, xem xét mục tiêu và quyết định bước tiếp theo cần làm
2. Act (Hành động): Agent gọi một công cụ (tool) để thực hiện hành động cụ thể — đọc file, tìm kiếm web, tính toán, gọi API
3. Observe (Quan sát): Agent nhận kết quả trả về từ công cụ, phân tích xem kết quả có đúng như mong đợi không
4. Repeat (Lặp lại): Nếu nhiệm vụ chưa hoàn thành, quay lại bước Think với thông tin mới

Vòng lặp này tiếp tục cho đến khi agent xác định rằng nhiệm vụ đã hoàn thành, hoặc gặp điều kiện dừng (hết số lần lặp, lỗi quá nhiều, v.v.).

Hãy hình dung như thế này: bạn giao cho một nhân viên mới một nhiệm vụ phức tạp. Họ sẽ không làm xong trong một bước duy nhất. Họ sẽ suy nghĩ về cách tiếp cận, thực hiện bước đầu tiên, xem kết quả, rồi điều chỉnh kế hoạch cho bước tiếp theo. Agent Loop hoạt động y hệt như vậy — chỉ khác là "bộ não" ở đây là Claude.

Tại sao Agent Loop quan trọng?

Có một cách đơn giản để hiểu kiến trúc agent: Claude là bộ não, tools là đôi tay.

Claude có khả năng suy luận (reasoning) cực mạnh — phân tích vấn đề, lập kế hoạch, ra quyết định. Nhưng bản thân Claude không thể tương tác trực tiếp với thế giới bên ngoài. Nó không thể đọc file trên máy tính của bạn, không thể truy cập internet, không thể chạy code. Đây là lúc tools phát huy vai trò.

Khi kết hợp Claude (reasoning engine) với tools (execution layer) trong một vòng lặp, bạn tạo ra một hệ thống có thể:

• Tự động hoá quy trình phức tạp: thay vì bạn phải chạy từng bước thủ công, agent tự lặp lại cho đến khi xong
• Xử lý các tình huống bất ngờ: nếu một bước thất bại, agent có thể tự điều chỉnh phương án
• Giải quyết bài toán mở: những nhiệm vụ mà bạn không biết trước cần bao nhiêu bước
• Tích lũy kiến thức qua từng bước: kết quả của bước trước trở thành input cho bước sau

So với việc gửi một prompt duy nhất và nhận một câu trả lời, agent loop cho phép Claude giải quyết những bài toán phức tạp hơn nhiều lần — giống như sự khác biệt giữa việc hỏi một câu hỏi và việc thuê một chuyên gia làm việc cho bạn trong nhiều giờ.

Agent Loop tối giản bằng Python

Dưới đây là một agent loop hoàn chỉnh chỉ trong khoảng 30 dòng code Python. Bạn có thể chạy ngay nếu đã cài thư viện anthropic:

import anthropic
import json

client = anthropic.Anthropic()
tools = [
    {
        "name": "calculator",
        "description": "Tính toán biểu thức toán học",
        "input_schema": {
            "type": "object",
            "properties": {
                "expression": {"type": "string", "description": "Biểu thức cần tính, ví dụ: 2 + 3 * 4"}
            },
            "required": ["expression"]
        }
    }
]

def run_tool(name, input_data):
    if name == "calculator":
        return str(eval(input_data["expression"]))
    return "Tool not found"

def agent_loop(task, max_iterations=10):
    messages = [{"role": "user", "content": task}]

    for i in range(max_iterations):
        response = client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=4096,
            tools=tools,
            messages=messages
        )

        # Nếu Claude trả về text thuần (không gọi tool) → hoàn thành
        if response.stop_reason == "end_turn":
            return response.content[0].text

        # Xử lý tool calls
        messages.append({"role": "assistant", "content": response.content})
        for block in response.content:
            if block.type == "tool_use":
                result = run_tool(block.name, block.input)
                messages.append({
                    "role": "user",
                    "content": [{"type": "tool_result", "tool_use_id": block.id, "content": result}]
                })

    return "Đã đạt giới hạn số lần lặp."

# Chạy agent
print(agent_loop("Tính tổng các số nguyên tố nhỏ hơn 20"))

Giải thích luồng hoạt động:

1. User đưa nhiệm vụ vào agent_loop()
2. Claude nhận nhiệm vụ, quyết định cần dùng calculator → gọi tool
3. Code nhận tool call, chạy calculator, trả kết quả về cho Claude
4. Claude xem kết quả, nếu cần tính thêm → gọi tool lần nữa; nếu đã đủ → trả lời text
5. Vòng lặp kết thúc khi Claude trả về end_turn hoặc đạt giới hạn lặp

Mở rộng: Thêm Tools cho Agent

Sức mạnh thực sự của agent nằm ở bộ tools bạn cung cấp. Dưới đây là cách thêm 3 tools phổ biến vào agent:

Tool 1: Đọc file

{
    "name": "read_file",
    "description": "Đọc nội dung một file trên máy tính",
    "input_schema": {
        "type": "object",
        "properties": {
            "path": {"type": "string", "description": "Đường dẫn đến file"}
        },
        "required": ["path"]
    }
}

def handle_read_file(input_data):
    try:
        with open(input_data["path"], "r", encoding="utf-8") as f:
            return f.read()
    except FileNotFoundError:
        return f"Error: File '{input_data['path']}' không tồn tại"
    except Exception as e:
        return f"Error: {str(e)}"

Tool 2: Tìm kiếm web

{
    "name": "web_search",
    "description": "Tìm kiếm thông tin trên internet",
    "input_schema": {
        "type": "object",
        "properties": {
            "query": {"type": "string", "description": "Từ khoá tìm kiếm"}
        },
        "required": ["query"]
    }
}

import requests

def handle_web_search(input_data):
    # Ví dụ dùng SerpAPI hoặc Tavily
    api_key = "YOUR_API_KEY"
    response = requests.get(
        "https://api.tavily.com/search",
        params={"query": input_data["query"], "api_key": api_key}
    )
    results = response.json().get("results", [])
    return json.dumps([{"title": r["title"], "snippet": r["content"]} for r in results[:3]])

Tool 3: Calculator nâng cao

import math

def handle_calculator(input_data):
    # Cho phép dùng các hàm math như sqrt, sin, cos, log
    allowed = {"math": math, "abs": abs, "round": round, "min": min, "max": max}
    try:
        result = eval(input_data["expression"], {"__builtins__": {}}, allowed)
        return str(result)
    except Exception as e:
        return f"Lỗi tính toán: {str(e)}"

Khi đã có nhiều tools, hàm run_tool() trở thành một dispatcher:

def run_tool(name, input_data):
    handlers = {
        "calculator": handle_calculator,
        "read_file": handle_read_file,
        "web_search": handle_web_search,
    }
    handler = handlers.get(name)
    if handler:
        return handler(input_data)
    return f"Unknown tool: {name}"

Điểm hay là bạn không cần nói cho Claude biết khi nào dùng tool nào. Claude tự quyết định dựa trên description của mỗi tool và ngữ cảnh nhiệm vụ. Đây chính là sức mạnh của reasoning engine.

Điều kiện dừng (Stop Conditions)

Một agent không có điều kiện dừng tốt sẽ lặp vô tận và tiêu tốn token (và tiền). Có 3 loại điều kiện dừng phổ biến:

1. Giới hạn số lần lặp (Max Iterations)

Đây là điều kiện dừng đơn giản nhất và bắt buộc phải có. Trong code ở trên, chúng ta đã dùng max_iterations=10. Tuỳ độ phức tạp của nhiệm vụ, bạn có thể tăng lên 20-50 cho các tác vụ research, hoặc giảm xuống 3-5 cho tác vụ đơn giản.

2. Nhiệm vụ hoàn thành (Task Complete)

Claude tự nhận biết khi nào nhiệm vụ đã hoàn thành và trả về stop_reason == "end_turn" thay vì gọi thêm tool. Đây là cách tự nhiên nhất — để Claude tự quyết định. Bạn cũng có thể thêm một tool đặc biệt gọi là task_complete để agent gọi khi xong:

{
    "name": "task_complete",
    "description": "Gọi khi nhiệm vụ đã hoàn thành. Trả về kết quả cuối cùng.",
    "input_schema": {
        "type": "object",
        "properties": {
            "result": {"type": "string", "description": "Kết quả cuối cùng của nhiệm vụ"}
        },
        "required": ["result"]
    }
}

3. Ngưỡng lỗi (Error Threshold)

Nếu agent liên tục gặp lỗi, việc tiếp tục lặp chỉ tốn tiền mà không tạo giá trị. Hãy đếm số lỗi liên tiếp và dừng khi vượt ngưỡng:

def agent_loop_with_error_handling(task, max_iterations=10, max_errors=3):
    messages = [{"role": "user", "content": task}]
    consecutive_errors = 0

    for i in range(max_iterations):
        response = client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=4096,
            tools=tools,
            messages=messages
        )

        if response.stop_reason == "end_turn":
            return response.content[0].text

        messages.append({"role": "assistant", "content": response.content})
        for block in response.content:
            if block.type == "tool_use":
                result = run_tool(block.name, block.input)
                if result.startswith("Error"):
                    consecutive_errors += 1
                    if consecutive_errors >= max_errors:
                        return f"Dừng sau {max_errors} lỗi liên tiếp. Lỗi cuối: {result}"
                else:
                    consecutive_errors = 0  # Reset nếu thành công
                messages.append({
                    "role": "user",
                    "content": [{"type": "tool_result", "tool_use_id": block.id, "content": result}]
                })

    return "Đã đạt giới hạn số lần lặp."

Vai trò của Claude trong Agent Loop

Claude đóng 3 vai trò quan trọng trong mỗi vòng lặp:

• Quyết định dùng tool nào: Dựa trên mô tả tools và ngữ cảnh hiện tại, Claude chọn tool phù hợp nhất. Nếu không cần tool nào, Claude trả lời trực tiếp.
• Diễn giải kết quả: Khi tool trả về dữ liệu thô (JSON, text, số liệu), Claude hiểu và tóm tắt kết quả theo cách có ý nghĩa.
• Lập kế hoạch bước tiếp: Claude không chỉ phản ứng — nó lập kế hoạch. Nó biết mình cần làm gì tiếp theo dựa trên kết quả vừa nhận được và mục tiêu tổng thể.

Chính vì Claude xử lý phần "suy nghĩ" nên bạn — người lập trình — không cần viết logic điều kiện phức tạp. Bạn chỉ cần cung cấp tools và mô tả rõ ràng, Claude sẽ tự biết cách phối hợp.

So sánh: Agent Loop vs Prompt Chaining vs Workflow

Ba cách tiếp cận phổ biến khi xây dựng ứng dụng AI, mỗi cách phù hợp với bài toán khác nhau:

Quy tắc chọn: Luôn bắt đầu với cách đơn giản nhất. Nếu simple prompt đủ tốt, không cần agent. Nếu bạn biết chính xác các bước cần thực hiện, dùng prompt chaining. Chỉ dùng agent loop khi số bước không xác định trước hoặc cần khả năng tự điều chỉnh.

Khi nào nên dùng Agent — và khi nào KHÔNG nên

Nên dùng Agent khi:

• Nhiệm vụ có nhiều bước, không biết trước số bước: ví dụ research một chủ đề, debug code, phân tích dữ liệu phức tạp
• Cần tương tác với nhiều nguồn dữ liệu: đọc file, query database, gọi API bên ngoài
• Cần khả năng tự sửa lỗi: agent có thể thử cách khác nếu cách đầu không hoạt động
• Bài toán mở: "Tìm hiểu đối thủ cạnh tranh" thay vì "Tóm tắt đoạn văn này"

KHÔNG nên dùng Agent khi:

• Chi phí là ưu tiên hàng đầu: Mỗi vòng lặp là một API call. Agent chạy 15 vòng tốn gấp 15 lần simple prompt. Với tác vụ đơn giản, đây là lãng phí.
• Cần tốc độ phản hồi nhanh: Agent loop có độ trễ tích luỹ. Mỗi vòng mất 2-5 giây → 10 vòng = 20-50 giây. Không phù hợp cho chatbot real-time.
• Yêu cầu tính nhất quán cao: Vì Claude tự quyết định, hai lần chạy cùng một input có thể cho kết quả khác nhau (số bước khác, tool khác). Nếu cần deterministic, dùng prompt chaining.
• Nhiệm vụ đã có quy trình rõ ràng: Nếu bạn biết chính xác "bước 1 làm A, bước 2 làm B, bước 3 làm C" thì hardcode pipeline sẽ nhanh hơn, rẻ hơn và đáng tin cậy hơn.

Một nguyên tắc thực tế: bắt đầu không dùng agent. Chỉ khi bạn thấy mình đang viết quá nhiều logic điều kiện ("nếu kết quả là X thì làm Y, nếu là Z thì làm W..."), đó là lúc nên chuyển sang agent loop và để Claude xử lý logic đó.

Bước tiếp theo

Bạn đã hiểu nền tảng của Agent Loop — vòng lặp Think → Act → Observe → Repeat. Đây là building block cơ bản nhất mà mọi AI agent đều xây dựng trên đó. Từ đây, bạn có thể khám phá thêm:

• Multi-agent systems: Nhiều agent phối hợp với nhau, mỗi agent chuyên một lĩnh vực (coding agent, research agent, review agent)
• Evaluation & testing: Cách đánh giá chất lượng agent một cách có hệ thống — không chỉ "chạy thử xem ổn không"
• Production deployment: Xử lý rate limiting, caching, logging, monitoring khi đưa agent lên production
• Extended thinking: Bật chế độ thinking của Claude để agent suy luận sâu hơn trước mỗi quyết định

Hãy bắt đầu bằng cách copy đoạn code agent loop tối giản ở trên, chạy thử, rồi dần thêm tools theo nhu cầu. Mỗi tool mới bạn thêm vào là một khả năng mới cho agent. Tham khảo thêm các bài hướng dẫn nâng cao tại Thư viện Nền tảng Claude.