Tất cả tập podcast
ai-agentsllmarchitecturesystem-design

Series 0 - Bài 3: Agentic Loop

Agentic Loop là vòng lặp Observe–Think–Act nằm ở trung tâm của mọi AI Agent. Bài này phân tích từng bước trong loop, điều kiện thoát, và các failure mode phổ biến nhất.

5 phút đọc
Tập này đang được chuẩn bị, quay lại sau nhé.

Điểm khác biệt cốt lõi giữa chatbot và agent không phải ở model mạnh hơn hay prompt dài hơn. Điểm khác biệt nằm ở một vòng lặp đơn giản — nhưng có implications rất sâu.

Vòng lặp đó gọi là Agentic Loop.

Agentic Loop là gì

Thay vì xử lý một request và trả về một response, agent chạy một vòng lặp:

  1. Observe — Nhận thông tin về trạng thái hiện tại (task, context, tool results)
  2. Think — LLM reasoning: cần làm gì tiếp theo để hoàn thành task
  3. Act — Thực thi quyết định: gọi tool hoặc kết thúc với response
  4. Lặp lại — Kết quả của Act trở thành input của Observe tiếp theo
              Task đầu vào
                   │
                   ▼
          ┌────────────────┐
          │    OBSERVE     │◀─────────────────────┐
          │                │                      │
          │ - Task gốc     │                      │
          │ - Tool results │                      │
          │ - History      │                      │
          └───────┬────────┘                      │
                  │                               │
                  ▼                               │
          ┌────────────────┐                      │
          │     THINK      │                      │
          │                │                      │
          │   LLM reason:  │                      │
          │   "Tôi cần     │                      │
          │    làm gì?"    │                      │
          └───────┬────────┘                      │
                  │                               │
         ┌────────▼────────┐                      │
         │   Quyết định    │                      │
         └────────┬────────┘                      │
                  │                               │
        ┌─────────▼──────────┐                    │
        │                    │                    │
   tool_use              text done                │
        │                    │                    │
        ▼                    ▼                    │
  ┌──────────┐        ┌──────────┐                │
  │  ACT     │        │  RETURN  │                │
  │ Execute  │        │ Response │                │
  │ tool     │        │ to user  │                │
  └──────┬───┘        └──────────┘                │
         │                                        │
         └────────────────────────────────────────┘
              tool_result vào Observe tiếp theo

Phân tích từng bước

Observe: Xây dựng bức tranh toàn cảnh

Bước Observe không phải chỉ nhận input. Nó là quá trình assembling context — gom tất cả thông tin liên quan vào một snapshot mà LLM có thể reason trên đó.

Context trong mỗi vòng Observe bao gồm:

  • Task gốc từ user
  • Toàn bộ conversation history
  • Kết quả của các tool calls trong các vòng trước
  • System context (thông tin về môi trường, permissions)

Mỗi vòng lặp, context window dày thêm. Đây là lý do token management quan trọng — một agent chạy 20 vòng có thể tốn gấp 10 lần token so với 5 vòng.

Think: LLM làm việc

Đây là bước LLM nhận toàn bộ context và quyết định:

  • Task đã hoàn thành chưa?
  • Nếu chưa, bước tiếp theo là gì?
  • Cần tool nào? Với input gì?

LLM không execute trong bước này. Nó chỉ reasoning và output quyết định dưới dạng:

  • tool_use block: yêu cầu gọi một tool cụ thể
  • Text response: khi task đã đủ để trả lời

Quality của bước Think phụ thuộc hoàn toàn vào chất lượng context từ bước Observe và system prompt định nghĩa behavior.

Act: Execution nằm ở phía application

Khi LLM output tool_use, application code thực thi tool và thu thập result. Đây là điểm quan trọng:

LLM output:
{
  "type": "tool_use",
  "name": "read_file",
  "input": { "path": "/src/main.ts" }
}

Application:
→ Validate input
→ Check permissions
→ Execute fs.readFile("/src/main.ts")
→ Return result to LLM

Application code là security layer duy nhất giữa LLM decision và side effect thực tế. Không có layer này, LLM có thể request bất kỳ hành động nào.

Điều kiện thoát loop

Một loop cần điều kiện dừng rõ ràng. Có hai loại:

Điều kiện dừng tự nhiên

LLM quyết định task đã hoàn thành và trả về text response thay vì tool_use. Đây là điểm lý tưởng.

Điều kiện dừng bắt buộc (Guardrails)

┌─────────────────────────────────────────┐
│          Safety Guardrails              │
│                                         │
│  Max iterations: 20                     │
│  → Prevent infinite loop                │
│                                         │
│  Max tokens: 100,000                    │
│  → Prevent runaway cost                 │
│                                         │
│  Timeout: 5 minutes                     │
│  → Prevent hanging                      │
│                                         │
│  Tool error threshold: 3 consecutive    │
│  → Prevent retry storm                  │
└─────────────────────────────────────────┘

Guardrails không phải optional. Không có chúng, một agent gặp lỗi có thể loop mãi mãi, tiêu token và tiền mà không có kết quả.

Failure modes phổ biến

1. Infinite Loop

Agent liên tục gọi cùng một tool với cùng input vì không có điều kiện thoát. Nguyên nhân thường là tool trả về kết quả mơ hồ và LLM không biết có nên tiếp tục không.

Vòng 1: search_web("latest news") → kết quả mơ hồ
Vòng 2: search_web("latest news") → vẫn mơ hồ
Vòng 3: search_web("latest news") → ...

Fix: Max iteration guardrail + tool results phải rõ ràng về trạng thái thành công hay thất bại.

2. Context Explosion

Mỗi vòng lặp thêm tool results vào context. Sau 15-20 vòng, context window có thể đầy, gây lỗi hoặc LLM bắt đầu ignore thông tin cũ.

Fix: Token budget management — cắt bớt history cũ, summarize tool results dài.

3. Hallucinated Tool Calls

LLM gọi một tool không tồn tại, hoặc truyền input không hợp lệ. Thường xảy ra khi tool definitions không đủ rõ.

Fix: Validate tool calls trước khi execute, trả error message rõ ràng về schema expected.

4. Goal Drift

Sau nhiều vòng lặp với tool results phức tạp, LLM có thể mất track của task gốc và bắt đầu optimize cho sub-goal không liên quan.

Fix: Reinject original task vào đầu mỗi Observe step. Không chỉ dựa vào conversation history.

Agentic Loop vs Request/Response

Request/Response (Chatbot):

User ──▶ LLM ──▶ User
1 round trip, predictable

Agentic Loop:

User ──▶ Loop ──▶ User
          │
    ┌─────┴──────┐
    │  N rounds  │
    │  LLM calls │
    │  Tool calls│
    └────────────┘
N round trips, variable, emergent behavior

Sự thay đổi này là fundamental. Với request/response, bạn biết trước cost và latency. Với agentic loop, cả hai là function của task complexity — và complexity không phải lúc nào cũng predictable.

Kết luận

  • Agentic Loop là vòng lặp Observe → Think → Act, lặp cho đến khi task hoàn thành.
  • LLM không execute actions — nó output quyết định, application code thực thi.
  • Mỗi vòng lặp, context dày thêm — đây là nguồn gốc của token cost và context management challenges.
  • Guardrails là bắt buộc: max iterations, timeout, token limit.
  • Failure modes chính: infinite loop, context explosion, hallucinated tool calls, goal drift.
  • Agentic loop tạo ra emergent behavior — agent có thể đạt được mục tiêu theo cách bạn không thiết kế trước.