BroadRouter

Chi phí một lần chạy AI coding agent: số bước, context và cache

Đội ngũ BroadNet Inference · 7 phút đọc · Đăng ngày

Agent gửi lại toàn bộ context ở mỗi bước, nên đầu vào tăng theo bình phương số bước: 60 bước tốn đầu vào gấp khoảng 3,5 lần 30 bước. Cache quyết định phần lớn hóa đơn; nếu lịch sử chỉ nối thêm, hơn 90% đầu vào có thể tính theo giá cache. Hãy nhân chi phí mỗi lần chạy với số lần chạy mỗi tháng rồi so với một phiên giá cố định.

Coding agent không trả tiền theo tác vụ. Nó trả theo bước, và mỗi bước gửi lại toàn bộ hội thoại tới lúc đó. Vì vậy chi phí một lần chạy phụ thuộc vào số bước, và vào lượng context được cache, nhiều hơn hẳn so với giá mỗi token. Bài này dựng chi phí một lần chạy từ các thành phần đó, có số liệu cụ thể, và chỉ ra khi nào một phiên giá cố định thắng trả theo token.

Muốn biết token trong mỗi lần gọi đến từ đâu (schema tool, đọc file, lịch sử), hãy xem token của vòng lặp agent đi đâu. Bài này nói về phép tính của cả một lần chạy.

Context tăng thế nào trong một lần chạy agent?

Mỗi lần gọi gồm:

  • một context cơ sở gửi ở mọi lần gọi: system prompt, định nghĩa tool, file quy tắc, repo map;
  • mọi thứ các bước trước đã thêm vào: câu trả lời và tool call của model, nội dung file và output của lệnh;
  • chỉ dẫn mới hoặc kết quả tool mới.

Gọi context cơ sở là B và số token mỗi bước thêm vào là g. Bước 1 gửi B. Bước 2 gửi B + g. Bước n gửi B + (n − 1) × g. Cộng tất cả lại, một lần chạy n bước gửi đi:

Tổng đầu vào = n × B + g × n × (n − 1) ÷ 2

Số hạng thứ hai tăng theo bình phương số bước. Đó là lý do các lần chạy dài khiến người ta bất ngờ: bước cuối của một lần chạy 60 bước lớn hơn bước đầu rất nhiều, và mọi bước ở giữa lại trả tiền cho tất cả các bước trước một lần nữa.

Một lần chạy mẫu trông thế nào?

Lấy một agent có context cơ sở 15.000 token (system prompt, khoảng chục tool và một repo map). Mỗi bước thêm 3.000 token: một file hoặc test log cộng với câu trả lời của chính model. Mỗi bước viết 800 token đầu ra, kể cả suy luận.

Số bước Tổng đầu vào Đầu ra Lần gọi lớn nhất
10 285.000 8.000 42.000
30 1.755.000 24.000 102.000
60 6.210.000 48.000 192.000

Đi từ 30 lên 60 bước làm khối lượng công việc gấp đôi nhưng nhân đầu vào lên khoảng 3,5 lần. Đầu ra chỉ gấp đôi. Trong các lần chạy này, đầu vào gấp 36 đến 130 lần đầu ra, vì thế giá đầu vào, và giá đầu vào từ cache, quan trọng nhất với agent.

Lần gọi lớn nhất cũng phải vừa context window. 192.000 token vừa với DeepSeek V4.1 Flash và GLM 5.3 (mỗi model 1.048.576 token) và Qwen3.8 27B (262.144). Nó không vừa với Gemma 4 VL 26B (32.768): trong ví dụ này, lần gọi thứ bảy đã quá lớn.

Cache thay đổi hóa đơn bao nhiêu?

Nhà cung cấp tính prefix lặp lại của prompt theo giá đầu vào từ cache thấp hơn. Một agent chỉ nối thêm vào lịch sử sẽ gửi cùng một prefix mỗi lần cộng thêm một ít, nên trong trường hợp tốt nhất, chỉ những token được thêm từ lần gọi trước là mới:

Đầu vào mới (tốt nhất) = B + (n − 1) × g

Mọi thứ còn lại là cache hit. Tỷ lệ đầu vào được cache tăng lên khi lần chạy dài hơn:

Số bước Đầu vào mới, trường hợp tốt nhất Tỷ lệ được cache
10 42.000 85%
30 102.000 94%
60 192.000 97%

Agent thực tế hiếm khi đạt trường hợp tốt nhất, nên tính giá cho ba trường hợp sẽ có ích. Theo giá DeepSeek V4.1 Flash của BroadNet ($0.175 đầu vào, $0.0055 từ cache, $0.52 đầu ra mỗi 1M token, công bố ngày 2026-11-14), đây là chi phí mỗi lần chạy so với trường hợp tốt nhất của 30 bước:

Số bước Cache tốt nhất 80% được cache Không cache
10 0,33× 0,39× 1,37×
30 1× 2,07× 8,11×
60 2,33× 6,84× 28,2×

Có hai điều nổi bật. Không có cache, một lần chạy 60 bước tốn gấp 28 lần một lần chạy 30 bước được cache tốt. Và lần chạy càng dài, cache càng quan trọng. Trong trường hợp tốt nhất của 30 bước, đầu ra chiếm khoảng một phần ba chi phí, đầu vào mới dưới một nửa và đầu vào từ cache dưới một phần tư, nên sau cache, đầu ra là chỗ tiết kiệm tiếp theo.

Cache không phải thứ bạn bật lên là xong. Nó phụ thuộc vào việc nhà cung cấp giữ prefix và agent của bạn không thay đổi nó. Hướng dẫn của OpenAI mô tả việc khớp prefix chính xác với độ dài tối thiểu để được cache. API của chính DeepSeek lưu các đơn vị cache ở cuối đầu vào và đầu ra của mỗi request, nên một request tiếp theo kéo dài request trước có thể hit. Trang giá của BroadNet nói đầu vào từ cache không cần thiết lập gì, và tài liệu của BroadNet báo các lần hit trong usage.prompt_tokens_details.cached_tokens khi model cung cấp. Danh mục model của BroadNet xếp DeepSeek V4.1 Flash vào nhóm “models we never ran on our hardware” (bản dịch: các model chúng tôi chưa từng chạy trên phần cứng của mình), và Điều khoản (§7.3) đề cập model này “when partner-hosted” (bản dịch: khi do đối tác host), nên trên BroadNet nó được phục vụ qua một đối tác. Hãy đo tỷ lệ hit của bạn thay vì giả định theo số liệu của chính DeepSeek. Hãy viết prefix sao cho cache được: cấu trúc prompt để cache.

Ước tính lần chạy của bạn thế nào?

Script này đọc giá hiện hành từ pricing.json công khai của BroadNet, nên không bao giờ lỗi thời, và in ra tổng token cùng chi phí mỗi lần chạy cho từng trường hợp cache:

import json, urllib.request

PRICES = json.load(urllib.request.urlopen("https://inference.broadnet.ai/pricing.json"))
m = next(x for x in PRICES["models"] if x["id"] == "broadnet/deepseek-v4.1-flash")
p_in, p_cached, p_out = m["input_per_m"], m["cached_input_per_m"], m["output_per_m"]

def run_tokens(steps, base=15_000, growth=3_000, out_per_step=800, cache_rate=None):
    total_in = steps * base + growth * steps * (steps - 1) // 2
    if cache_rate is None:                      # best case: only new tokens miss
        new_in = base + (steps - 1) * growth
    else:
        new_in = round(total_in * (1 - cache_rate))
    return total_in, new_in, steps * out_per_step

def run_cost(total_in, new_in, out):
    return ((new_in * p_in) + (total_in - new_in) * p_cached + out * p_out) / 1e6

for steps in (10, 30, 60):
    for label, rate in (("best", None), ("80%", 0.8), ("none", 0.0)):
        t, n, o = run_tokens(steps, cache_rate=rate)
        print(f"{steps:>3} steps  cache {label:>4}  input {t:>9,}  new {n:>9,}  "
              f"output {o:>6,}  cost/run {run_cost(t, n, o):.4f} USD")

Hãy thay các giá trị mặc định bằng số liệu của bạn. Đừng đoán; hãy đọc chúng từ một lần chạy thật:

  1. Ghi prompt_tokens, prompt_tokens_details.cached_tokens và completion_tokens cho mọi lần gọi, như trong bài về ngân sách token của agent.
  2. B là prompt_tokens của lần gọi đầu tiên. g là mức tăng trung bình của prompt_tokens từ lần gọi này sang lần gọi kế tiếp.
  3. Đầu ra mỗi bước là trung bình completion_tokens. Nó bao gồm token suy luận, được tính như đầu ra.
  4. Tỷ lệ cache thật của bạn là tổng cached_tokens chia cho tổng prompt_tokens.

Công cụ ước tính chi phí chạy agent miễn phí thực hiện cùng phép tính trong trình duyệt, để bạn thử số bước, mức tăng và tỷ lệ cache khác mà không cần code.

Điều gì khiến một lần chạy tốn hơn ước tính?

  • Retry. Một tool call thất bại hoặc một lần retry 429 là thêm một lần gọi mang đầy đủ context. Hãy tính chúng là bước.
  • Thay đổi prefix. Timestamp trong system prompt, tool liệt kê theo thứ tự khác, hay file quy tắc bị sửa giữa chừng đều biến đầu vào từ cache trở lại thành đầu vào mới, kể từ điểm thay đổi.
  • Nén lịch sử. Tóm tắt lịch sử làm context nhỏ lại, giảm đầu vào về sau, nhưng lịch sử mới chưa từng được cache, nên lần gọi kế tiếp trả trọn giá đầu vào. Hãy nén hiếm khi và theo những bước lớn; quản lý context cho agent chạy lâu nói khi nào nên làm.
  • Output tool lớn. Một test log 20.000 dòng thêm vào ở bước 5 sẽ đi theo mọi bước sau. Theo công thức, nó cộng thêm 20.000 × (số bước còn lại) token đầu vào.
  • Mức suy luận. Mức cao có thể nhân đầu ra mỗi bước lên nhiều lần. Đặt reasoning_effort là low cho các lần sửa thường ngày.
  • Đi lạc. Một agent mất 60 bước cho tác vụ 30 bước sẽ trả theo bình phương, không phải gấp đôi. Giới hạn số bước chính là giới hạn chi phí. Mười cách giảm chi phí coding agent trình bày các đòn bẩy.

Khi nào phiên giá cố định thắng trả theo token?

Đổi chi phí mỗi lần chạy thành con số hằng tháng: chi phí hằng tháng = chi phí mỗi lần chạy × số lần chạy mỗi tháng. Rồi so với gói giá cố định. Trên BroadNet, các gói cung cấp DeepSeek V4.1 Flash không đếm token: Full Moon $60 mỗi tháng, Orbit $15 mỗi tuần và Meteor $1 mỗi giờ, đều tính theo phiên.

Số lần chạy mỗi tháng để hòa vốn = giá gói ÷ chi phí mỗi lần chạy.

Có hai điều khiến phép so sánh này không đơn giản như vẻ ngoài:

  1. Tỷ lệ cache quyết định phía trả theo token. Với tỷ lệ cache cao, trả theo token trên Flash rẻ, và bạn cần rất nhiều lần chạy mới vượt $60. Với tỷ lệ kém, bạn vượt nhanh. Bài về giá cố định trình bày điểm hòa vốn theo khối lượng hằng tháng: khoảng 917 triệu token đầu vào và 46 triệu token đầu ra với 80% được cache (phép tính hòa vốn).
  2. Thời gian đặt trần cho phía giá cố định. Một phiên chạy một request tại một thời điểm. Nếu một lần gọi mất trung bình 20 giây (prefill, khoảng 800 token đầu ra ở tốc độ khoảng 100 token mỗi giây, cộng thời gian chạy tool), một lần chạy 30 bước mất khoảng 10 phút. Khi đó một phiên chứa được tối đa khoảng sáu lần chạy mỗi giờ. Nhiều agent song song hơn cần nhiều phiên hơn.

Với những đợt ngắn, Meteor hoạt động theo cùng cách ở quy mô nhỏ hơn: nếu sáu lần chạy vừa trong một giờ, mỗi lần tốn $1 ÷ 6. Hãy so con số đó với chi phí theo token cho một lần chạy mà script tính ra. Để thử khối lượng của bạn, dùng công cụ so sánh giá cố định và trả theo token.

Kiểu dùng của bạn Thường rẻ hơn
Vài lần chạy ngắn mỗi ngày Trả theo token
Lần chạy dài với cache kém Phiên giá cố định
Agent chạy gần hết ngày làm việc Phiên giá cố định
Nhiều agent song song, cả ngày Mỗi agent một phiên giá cố định
Cần native tool calling trên BroadNet Trả theo token với GLM 5.3 hoặc Qwen3.8 27B

BroadNet Inference phù hợp ở đâu

BroadNet báo token từ cache và token suy luận trong khối usage, nên bạn có thể đo mọi con số ở trên từ chính các lần chạy của mình. DeepSeek V4.1 Flash có giá đầu vào từ cache thấp và context 1.048.576 token, và các gói không giới hạn bỏ việc đếm token của nó; xem cách phiên hoạt động.

Hãy kiểm tra một giới hạn trước. Tài liệu của BroadNet chỉ ghi tool calling cho GLM 5.3 và Qwen3.8 27B, và cả hai đều không có trong gói giá cố định. Những agent sửa file qua văn bản, như Aider, không cần native tool call. Nếu agent của bạn cần, hãy thử DeepSeek V4.1 Flash với agent đó trước khi mua gói, hoặc dự trù ngân sách cho GLM hay Qwen theo token. Và nếu agent của bạn chỉ thỉnh thoảng mới chạy, trả theo token thường sẽ rẻ hơn mọi gói giá cố định.

Câu hỏi thường gặp

Một lần chạy AI coding agent tốn bao nhiêu?

Hãy đếm token, rồi tính giá. Trong ví dụ của bài này, một lần chạy 30 bước với context cơ sở 15.000 token và thêm 3.000 token mỗi bước gửi đi 1.755.000 token đầu vào và 24.000 token đầu ra. Chi phí phụ thuộc chủ yếu vào phần đầu vào được tính theo giá cache.

Vì sao lần chạy agent dài hơn lại tốn nhiều hơn một cách không cân xứng?

Mỗi bước gửi lại mọi thứ trước nó. Đầu vào mỗi bước tăng theo đường thẳng, nên tổng của cả lần chạy tăng theo bình phương số bước. Trong ví dụ tính toán, tăng một lần chạy từ 30 lên 60 bước nhân đầu vào lên khoảng 3,5 lần.

Nên kỳ vọng tỷ lệ cache hit bao nhiêu từ một coding agent?

Tùy agent và nhà cung cấp. Với lịch sử chỉ nối thêm nghiêm ngặt, chỉ những token mới nhất bị miss, cho kết quả 85% đến 97% trong các ví dụ của chúng tôi. Lịch sử bị sửa, timestamp trong system prompt và những khoảng dừng dài làm tỷ lệ này giảm. Hãy đo bằng prompt_tokens_details.cached_tokens.

Khi nào phiên giá cố định rẻ hơn trả theo token cho agent?

Khi chi phí mỗi lần chạy × số lần chạy mỗi tháng lớn hơn giá gói. Trên BroadNet, Full Moon có giá $60 mỗi phiên mỗi tháng cho DeepSeek V4.1 Flash. Dùng nhẹ hoặc thỉnh thoảng thường rẻ hơn khi trả theo token.

Token suy luận có làm thay đổi ước tính không?

Có. Chúng được tính như đầu ra, và đầu ra đắt hơn đầu vào trên mỗi token. Hãy đưa lượng suy luận bạn đo được vào đầu ra mỗi bước. Trên BroadNet, completion_tokens_details.reasoning_tokens báo con số này khi model cung cấp.

Đọc dạng MarkdownHỏi ChatGPTHỏi ClaudeHỏi Perplexity