Optimasi Biaya Agen: Panduan Praktis Mengurangi Pengeluaran API

Agen Anda bekerja dengan baik. Ia menangani 200 permintaan per hari, dan pengguna puas. Lalu Anda mengecek tagihan API: $3.400 bulan ini. Anda menelusuri angka-angkanya dan menyadari bahwa agen tersebut rata-rata melakukan 12 panggilan API per permintaan, masing-masing dengan system prompt 4.000 token. Itu berarti 9,6 juta token input per hari hanya untuk system prompt. Dengan harga $3 per juta token, itu berarti $864/bulan hanya untuk konten yang berulang.

Biaya adalah alasan utama nomor satu mengapa penerapan agen di produksi dikurangi atau dihentikan sepenuhnya. Optimasi bukan tindakan prematur — ini soal kelangsungan hidup. Kabar baiknya: sebagian besar penerapan agen memiliki potensi pengurangan biaya 50–80% melalui perubahan-perubahan sederhana yang tidak memerlukan perombakan total sistem Anda.

Dalam panduan ini, Anda akan mempelajari tujuh strategi pengurangan biaya, diurutkan berdasarkan ROI (Return on Investment). Mulailah dari atas dan turun ke bawah hingga Anda mencapai target anggaran. Setiap bagian menyertakan angka konkret agar Anda dapat memperkirakan penghematan sebelum menulis satu baris kode pun.

1. Akuntansi Token: Ketahui Ke Mana Uang Anda Mengalir

Anda tidak bisa mengoptimalkan apa yang tidak Anda ukur. Sebelum mengubah apa pun, bangun gambaran lengkap tentang ke mana setiap dolar pergi dalam alur kerja agen Anda.

Rincian Token Input

Setiap panggilan API ke Claude menyertakan beberapa kategori token di sisi input:

• System prompt — Instruksi, persona, batasan. Seringkali 1.000–5.000 token dan diulang di setiap panggilan.
• Definisi alat — Skema JSON untuk setiap alat yang dapat digunakan agen. 10 alat dapat dengan mudah mengonsumsi 2.000–3.000 token.
• Riwayat percakapan — Semua pesan sebelumnya dalam percakapan. Bertumbuh di setiap langkah.
• Hasil alat — Output dari panggilan alat sebelumnya yang diinjeksikan kembali ke konteks. Bisa sangat besar (halaman web penuh, hasil database).

Rincian Token Output

Token output 3–5x lebih mahal daripada token input, menjadikannya target optimasi yang kritis:

• Penalaran agen — Rantai pemikiran internal (terutama dengan extended thinking).
• Pembuatan panggilan alat — JSON untuk pemanggilan alat.
• Respons akhir — Jawaban yang menghadap pengguna.

Perhitungan Biaya Per Tugas

Total biaya untuk satu tugas agen adalah:

Total Cost = Σ (input_tokens × input_price + output_tokens × output_price)
             for each API call in the task

Contoh Rincian Biaya

Berikut adalah rincian realistis untuk tugas agen penelitian 10 langkah menggunakan Claude Sonnet ($3/juta input, $15/juta output):

Perhatikan bagaimana biaya input mendominasi, dan bertumbuh di setiap langkah seiring akumulasi riwayat percakapan. Langkah 8–10 menyumbang 47% dari total biaya meskipun hanya 30% dari total langkah.

Kode Pelacakan Biaya

Implementasikan wrapper pelacakan sejak hari pertama:

import anthropic
import time
from dataclasses import dataclass, field
from typing import Optional

@dataclass
class CostRecord:
    step: int
    model: str
    input_tokens: int
    output_tokens: int
    cache_read_tokens: int = 0
    cache_creation_tokens: int = 0
    input_cost: float = 0.0
    output_cost: float = 0.0
    total_cost: float = 0.0
    duration_ms: float = 0.0

# Pricing per million tokens (as of early 2026)
MODEL_PRICING = {
    "claude-haiku": {"input": 0.25, "output": 1.25, "cache_read": 0.025, "cache_write": 0.30},
    "claude-sonnet": {"input": 3.00, "output": 15.00, "cache_read": 0.30, "cache_write": 3.75},
    "claude-opus": {"input": 15.00, "output": 75.00, "cache_read": 1.50, "cache_write": 18.75},
}

@dataclass
class TaskCostTracker:
    task_id: str
    budget_limit: Optional[float] = None
    records: list = field(default_factory=list)
    total_cost: float = 0.0

    def record_call(self, step: int, model: str, usage) -> CostRecord:
        pricing = MODEL_PRICING.get(model, MODEL_PRICING["claude-sonnet"])

        input_cost = (usage.input_tokens / 1_000_000) * pricing["input"]
        output_cost = (usage.output_tokens / 1_000_000) * pricing["output"]
        cache_read_cost = (getattr(usage, 'cache_read_input_tokens', 0) / 1_000_000) * pricing["cache_read"]
        cache_write_cost = (getattr(usage, 'cache_creation_input_tokens', 0) / 1_000_000) * pricing["cache_write"]

        total = input_cost + output_cost + cache_read_cost + cache_write_cost

        record = CostRecord(
            step=step,
            model=model,
            input_tokens=usage.input_tokens,
            output_tokens=usage.output_tokens,
            cache_read_tokens=getattr(usage, 'cache_read_input_tokens', 0),
            cache_creation_tokens=getattr(usage, 'cache_creation_input_tokens', 0),
            input_cost=input_cost + cache_read_cost + cache_write_cost,
            output_cost=output_cost,
            total_cost=total,
        )

        self.records.append(record)
        self.total_cost += total

        print(f"  Step {step} [{model}]: {usage.input_tokens} in / {usage.output_tokens} out = ${total:.4f} (cumulative: ${self.total_cost:.4f})")

        if self.budget_limit and self.total_cost > self.budget_limit:
            raise BudgetExceededError(
                f"Task {self.task_id} exceeded budget: ${self.total_cost:.4f} > ${self.budget_limit:.4f}"
            )

        return record

    def summary(self) -> dict:
        return {
            "task_id": self.task_id,
            "total_steps": len(self.records),
            "total_input_tokens": sum(r.input_tokens for r in self.records),
            "total_output_tokens": sum(r.output_tokens for r in self.records),
            "total_cost": self.total_cost,
            "cost_by_model": self._cost_by_model(),
        }

    def _cost_by_model(self) -> dict:
        by_model = {}
        for r in self.records:
            if r.model not in by_model:
                by_model[r.model] = {"calls": 0, "cost": 0.0}
            by_model[r.model]["calls"] += 1
            by_model[r.model]["cost"] += r.total_cost
        return by_model


class BudgetExceededError(Exception):
    pass

Mulai pelacakan hari ini, bahkan sebelum melakukan optimasi. Anda memerlukan angka dasar untuk mengukur peningkatan.

2. Pemilihan Model Berdasarkan Tugas

Ini adalah tuas biaya terbesar yang tersedia bagi Anda. Tidak setiap langkah agen memerlukan model paling canggih Anda.

Tingkatan Model dan Harga

Menggunakan keluarga Claude sebagai referensi:

Haiku 12x lebih murah dari Sonnet untuk input dan 12x lebih murah untuk output. Sonnet 5x lebih murah dari Opus di semua aspek.

Rekomendasi Per Peran

Cocokkan setiap peran agen dengan model termurah yang memenuhi pers

Artikel Terkait

• Strategi Caching untuk AI Agent: Memangkas Biaya Tanpa Mengorbankan Kualitas
• Model Penalaran dalam Alur Kerja Agen: Kapan Extended Thinking Sepadan
• Pola Multi-Agen: Orkestrator, Pekerja, dan Pipeline
• Debugging dan Observabilitas dalam Sistem Agen Otonom