AI Agent Roadmap: Hướng dẫn về Cửa sổ Ngữ cảnh và Độ dài Tối đa trong LLM

“Model có 1 triệu token context” là câu marketing dễ gây hiểu sai nhất trong tài liệu AI hiện nay. Con số đó là trần kỹ thuật, không phải ngân sách bạn nên dùng. Agent chạy tốt thường dùng 5–15% cửa sổ; agent nhồi đầy thường chậm hơn, đắt hơn và trả lời tệ hơn agent cắt gọn — dù cùng model.

Bài này nói về ba con số mà tài liệu cũ gộp làm một: cửa sổ ngữ cảnh, trần input, và trần output. Cộng thêm hai thứ chỉ xuất hiện khi bạn làm thật: phụ phí long-context và chất lượng giảm dần theo độ dài.

Cập nhật 2026: con số thực tế

Model Context Input tối đa / output tối đa
GPT-6 Astra, Sol, Terra, Luna 1.050.000 922K / 128K
Claude Fable 5.1, Opus 5.5, Sonnet 5.5, Haiku 5.5 1M — / 128K (300K batch beta trên Opus/Sonnet 5.5)
Gemini 4 Argon 1.048.576 dùng chung dùng chung / 65.536 mặc định, tới 1M với long decode
Grok 4.7 500K — / —
Grok 4.3 1M — / —

Bảng này thay thế toàn bộ bảng “GPT-4 128K, Claude 2.1 200K, Gemini 1.5 Pro 1M” trong bản cũ. Những model đó không còn là tham chiếu để thiết kế agent. Nếu tài liệu nội bộ của bạn còn các con số đó, hãy sửa trước khi ai đó lập ngân sách theo chúng.

Ba con số, không phải một

Cửa sổ ngữ cảnh là tổng token model có thể xử lý trong một request: input cộng output. Trần input là số token tối đa bạn được gửi. Trần output là số token tối đa model được sinh. Ba số này không bằng nhau và không thể suy ra từ nhau.

Ví dụ rõ nhất là OpenAI: cửa sổ 1.050.000, input tối đa 922K, output tối đa 128K. Cộng lại vừa đúng 1,05 triệu — nghĩa là nếu bạn gửi 922K token input, model chỉ còn 128K để trả lời, và đó là trần cứng. Gửi 950K sẽ bị từ chối, không phải “tự cắt”. Với Gemini 4 Argon thì khác: 1.048.576 token là dùng chung cho cả vào và ra, output mặc định chỉ 65.536 nhưng có thể tới 1M khi bật long decode — nghĩa là bạn phải chủ động đặt output, không được mặc định.

Trong code, hãy tính ngân sách theo công thức:

ngan_sach_input = tran_input - output_reserve
output_reserve  = max_output + buffer_cho_tool_call

Đừng dùng context_window làm ngân sách input. Đây là lỗi khiến agent chạy đúng ở môi trường dev (prompt ngắn) và vỡ ở production (lịch sử dài, kết quả tool lớn). Xem thêm bài ảnh hưởng của tokenization để biết token nào ăn vào ngân sách đó trước.

Phụ phí long-context: bậc thang, không phải tuyến tính

Đây là phần bị bỏ qua nhiều nhất khi lập kế hoạch chi phí. Ba nhà áp ba quy tắc khác nhau:

  • OpenAI: trên 272K input token, toàn bộ request bị tính 2x giá input và cached input, 1,5x giá output. Không phải chỉ phần vượt — toàn bộ request.
  • xAI: từ 200K prompt token trở lên, giá gấp đôi trên toàn request (grok-4.7: $4/$12 thay vì $2/$6).
  • Anthropic và Google: giá phẳng ở 1M context, không có phụ phí theo độ dài.

Hệ quả toán học rất khó chịu: vượt ngưỡng một token làm chi phí nhảy bậc cho mọi token trong request. Với GPT-6.1 Sol, 280K input ở giá thường là $0,56; vượt ngưỡng còn $1,12 — gấp đôi cho thêm 8K token. Nếu agent của bạn có thể gói gọn xuống 260K bằng cách cắt lịch sử hoặc bỏ bớt tài liệu, khoản tiết kiệm lớn hơn nhiều so với việc tối ưu vài trăm token lặt vặt.

Vì vậy quy tắc đầu tiên của context engineering là: biết ngưỡng của model bạn dùng và giữ request dưới ngưỡng đó nếu có thể. Với OpenAI là 272K, với xAI là 200K. Nếu bài toán buộc phải vượt, hãy chia thành nhiều request nhỏ (map-reduce, chunk + summarize) thay vì một request khổng lồ — thường rẻ hơn và cho kết quả dễ kiểm tra hơn.

Chất lượng giảm khi context dài

Không có gì trong kiến trúc Transformer bảo đảm model chú ý đều mọi token. Attention là trọng số trên toàn bộ chuỗi, và khi chuỗi dài, trọng số bị chia mỏng. Kinh nghiệm lặp lại ở nhiều nhóm: thông tin nằm ở giữa một khối rất dài dễ bị bỏ qua hơn thông tin ở đầu hoặc cuối; các chi tiết gần giống nhau (nhiều đoạn văn cùng chủ đề, nhiều bản ghi cùng schema) làm model trộn lẫn nguồn.

Đừng biến quan sát này thành một con số tuyệt đối — mức suy giảm phụ thuộc model, cách sắp xếp và loại task. Cách duy nhất đúng là đo trên eval của bạn: cùng một bộ câu hỏi, chạy với context 20K, 100K và 400K, so sánh độ chính xác và chi phí. Rất thường xuyên, bản 20K thắng cả về chất lượng lẫn tiền, vì nó không có nhiễu.

Ba dấu hiệu cho thấy context đang quá dài: model bỏ qua instruction đặt ở giữa; model trích dẫn nhầm đoạn tài liệu; agent lặp lại bước đã làm. Trước khi đổi model, hãy thử cắt context — phần lớn các triệu chứng này biến mất.

Compaction: giữ thông tin, bỏ token

Compaction là quá trình nén context mà vẫn giữ sự thật cần thiết. Có bốn kỹ thuật, dùng theo thứ tự từ rẻ đến đắt:

  • Bỏ phần không bao giờ cần lại. Kết quả tool đã dùng xong, log debug, lời chào, phần lặp lại của system prompt. Đây là khoản tiết kiệm miễn phí và hay bị bỏ qua nhất.
  • Tóm tắt lịch sử theo cửa sổ trượt. Giữ N lượt gần nhất nguyên văn, các lượt cũ thay bằng bản tóm tắt có cấu trúc (quyết định, dữ kiện, việc còn mở). Tóm tắt phải ổn định — nếu mỗi lần tóm tắt lại khác nhau, cache prefix sẽ vỡ.
  • Đưa bộ nhớ ra ngoài. Ghi state, kết quả trung gian và tài liệu vào file, DB hoặc bộ nhớ dài hạn, rồi retrieve khi cần. Context là bộ nhớ làm việc, không phải kho lưu trữ. Bài quản lý bộ nhớ agent đi sâu phần này.
  • Cô lập context theo nhánh. Subagent nhận một context riêng, trả về kết quả đã nén thay vì toàn bộ transcript. Đây là cách duy nhất giữ context chính gọn khi task có nhiều nhánh song song.

Một lưu ý về cache: compaction phải giữ phần đầu prompt byte-stable. Nếu bạn chèn bản tóm tắt mới vào trước system prompt, mọi token phía sau mất cache. Cấu trúc đúng là: system + tool schema cố định, rồi tới summary, rồi tới các lượt gần nhất, rồi câu hỏi hiện tại.

Trần output và chuyện bị cắt

Trần output thấp hơn nhiều người tưởng: 128K trên OpenAI và Claude, 65.536 mặc định trên Gemini 4 Argon. Với agent, đây không phải ràng buộc xa vời — một tool trả về danh sách 500 bản ghi, model sinh lại toàn bộ trong JSON, và bạn chạm trần mà không biết.

Output là hạng mục đắt nhất trong ba hạng mục, và reasoning token cũng được tính vào đây. Nghĩa là “cho model suy nghĩ nhiều hơn” vừa tốn tiền vừa ăn vào trần output: nếu max_output đặt quá thấp, reasoning có thể tiêu hết ngân sách trước khi có token trả lời nào.

Ba việc nên làm: đặt max_output theo schema thực tế, kiểm tra finish reason mỗi lần gọi, và thiết kế output ngắn — trả về ID hoặc diff thay vì cả object. Đừng dựa vào việc model “tự biết dừng”.

Vì sao nhiều context hơn không tốt hơn

Bốn lý do, theo thứ tự tác động:

  • Pha loãng attention. Thêm 300K token nhiễu không làm model thông minh hơn; nó làm giảm trọng số tương đối của thông tin đúng.
  • Chi phí bậc thang. Vượt 272K (OpenAI) hoặc 200K (xAI) là gấp đôi toàn request, cộng thêm prefill chậm hơn.
  • Phá cache. Context dài thường xuyên thay đổi, nên prefix không ổn định, và bạn trả giá input đầy đủ ở mọi bước.
  • Khó debug và khó eval. Khi câu trả lời sai, bạn phải tìm trong 400K token xem thông tin nào gây nhiễu. Với 20K token, việc đó mất vài phút.

Chọn chiến lược theo loại task

Task Context điển hình Chiến lược
Chat hỗ trợ, FAQ 5–20K System + N lượt gần nhất; tóm tắt phần cũ
Hỏi đáp tài liệu 10–50K Retrieve + rerank, k nhỏ, chunk có ngữ cảnh
Agent codebase 50–200K Đọc theo nhu cầu qua tool, không nhét cả repo
Phân tích log / báo cáo dài 200K+ Map-reduce theo chunk; tránh vượt ngưỡng phụ phí
Task nhiều nhánh — Subagent context riêng, trả về kết quả đã nén

Đoạn code dưới là bộ chia ngân sách tối thiểu, đủ để bạn thấy mình đang vượt ở đâu trước khi gọi API. Nó không phụ thuộc SDK nào.

# File: context_budget.py
MAX_INPUT = 922_000        # GPT-6: input tối đa
OUTPUT_CAP = 128_000       # trần output
LONG_CTX_THRESHOLD = 272_000  # ngưỡng phụ phí OpenAI

def plan(system_tokens: int, tool_schema_tokens: int,
         history_tokens: int, doc_tokens: int,
         max_output: int = 16_000) -> dict:
    fixed = system_tokens + tool_schema_tokens
    reserve = max_output + 2_000          # buffer cho tool call JSON
    available = MAX_INPUT - fixed - reserve
    if available <= 0:
        raise ValueError("system + tools + max_output đã vượt trần input")

    history = min(history_tokens, available // 2)
    docs = min(doc_tokens, available - history)
    total_input = fixed + history + docs
    return {
        "total_input": total_input,
        "history": history,
        "docs": docs,
        "dropped_docs": doc_tokens - docs,
        "over_long_ctx_threshold": total_input > LONG_CTX_THRESHOLD,
    }

print(plan(6_000, 9_000, history_tokens=120_000, doc_tokens=900_000))

Hai tín hiệu trong output đáng chú ý: dropped_docs khác 0 nghĩa là bạn đang âm thầm bỏ tài liệu — hãy log nó, vì agent sẽ trả lời như thể đã đọc; và over_long_ctx_threshold bật lên nghĩa là chi phí sắp gấp đôi, nên cân nhắc map-reduce thay vì gửi một request lớn.

Lỗi phổ biến

  • Dùng context window làm ngân sách input. Quên output reserve là nguyên nhân số một của lỗi 400 ở production.
  • Nhồi cả tài liệu “để model tự tìm”. Retrieve có rerank rẻ hơn và chính xác hơn ở hầu hết task.
  • Không biết ngưỡng phụ phí của model đang dùng. Với OpenAI 272K, với xAI 200K — vượt một token là gấp đôi cả request.
  • Đánh giá chất lượng bằng cảm giác. Cần eval ở hai mức context khác nhau thì mới biết context dài có lợi hay không.
  • Chèn summary vào đầu prompt. Làm vậy phá cache của toàn bộ phần phía sau.

Checklist

  • Ghi rõ ba con số của model đang dùng: context, trần input, trần output.
  • Tính ngân sách = trần input − max_output − buffer tool call.
  • Log số tài liệu bị bỏ và số lần request vượt ngưỡng phụ phí.
  • Chạy eval ở hai mức context (ví dụ 20K và 200K) trước khi tăng context.
  • Giữ prefix ổn định; đặt mọi nội dung thay đổi ở cuối.
  • Với tài liệu rất dài, dùng map-reduce thay vì một request khổng lồ.

Hướng 2027: context sẽ được quản lý như tài nguyên có ngân sách — framework báo token theo từng vùng (system, tool, memory, retrieval), và các model lớn sẽ có cơ chế nén nội bộ thay vì bắt ứng dụng tự cắt. Nhưng quy tắc vẫn giữ nguyên: thứ bạn không đưa vào context thì model không biết, và thứ bạn đưa vào cũng có giá.

Bài liên quan