Cara Mengurangi Biaya Token Agen dari CLI (Panduan 2026)

Agen pengkodean CLI merasa bebas hingga tagihan tiba. Anda mengarahkan Claude Code atau Codex ke sebuah repo, memintanya untuk merefaktor sebuah modul, dan sepuluh menit kemudian ia telah membaca empat puluh file, menjalankan suite pengujian tiga kali, dan menghabiskan jutaan token untuk konteks yang tidak pernah Anda perlukan. Kalikan itu dengan tim yang terdiri dari delapan insinyur yang menjalankan agen sepanjang hari, dan tagihan berhenti menjadi kesalahan pembulatan. Pengeluaran token pada agen pengkodean sebagian besar adalah pemborosan, dan sebagian besar pemborosan itu dapat diperbaiki dari baris perintah tanpa mengubah model atau menerima output yang lebih buruk.

TL;DR

Pangkas biaya token agen dengan memangkas konteks sebelum mencapai model: batasi set kerja, jaga agar file memori tetap pendek, dan kompres sesi panjang. Aktifkan penyinggahan prompt untuk prefiks stabil (sekitar diskon 90% untuk pembacaan berulang). Arahkan sub-tugas murah ke model kecil. Batasi output alat. Ukur biaya per eksekusi sehingga Anda tahu apa yang sebenarnya berubah.

Pendahuluan

Masalahnya muncul dalam dua cara. Anda bisa saja menemui hambatan di tengah tugas karena Anda melampaui batas mingguan atau sesi, atau tagihan API bulanan tiba dan seseorang bertanya mengapa “asisten AI” biayanya lebih mahal daripada kontraktor junior. Keduanya berasal dari akar penyebab yang sama: agen CLI secara default haus token. Mereka membaca seluruh file padahal hanya butuh sepuluh baris, memutar ulang seluruh percakapan di setiap giliran, membuang output perintah mentah kembali ke konteks, dan mengirim ulang prompt sistem serta peta repo yang sama ribuan kali sehari.

Tidak ada satupun hal tersebut yang melekat pada pekerjaan. Sebuah refaktor yang benar-benar perlu mempertimbangkan kode 2.000 token tidak membutuhkan konteks 180.000 token untuk melakukannya. Kesenjangan antara kedua angka tersebut adalah penghematan Anda, dan hampir semua itu dapat dipulihkan dengan flag, file konfigurasi, dan kebiasaan yang dapat Anda adopsi hari ini.

Panduan ini menjelaskan ke mana token sebenarnya pergi dalam eksekusi agen CLI, lalu memberikan taktik konkret untuk mengurangi setiap kategori: kebersihan konteks dan file memori, penyinggahan prompt, perutean model, pemangkasan output alat dan pengambilan, serta pengukuran biaya per eksekusi agar penghematan nyata dan bukan sekadar perkiraan. Contoh-contoh ini mengasumsikan Claude Code dan Codex, tetapi mekanismenya berlaku untuk agen mana pun yang berkomunikasi dengan API yang dikenakan biaya token.

Satu biaya terkait yang perlu disebutkan sejak awal: banyak pengeluaran token agen adalah untuk debugging. Agen yang memanggil API internal yang tidak stabil akan mencoba lagi, membaca isi kesalahan, membaca ulang dokumen, dan berulang, dengan setiap iterasi membayar biaya penuh dalam token.

Ke mana token sebenarnya pergi dalam eksekusi agen CLI

Sebelum Anda mengoptimalkan, Anda perlu model mental tentang tagihan. Satu “giliran” agen mengirimkan payload input ke model dan mendapatkan payload output kembali. Anda membayar keduanya, dan pada sebagian besar penyedia, biaya output tiga hingga enam kali lebih mahal per token daripada input. Untuk satu keluarga model frontier pada pertengahan 2026, input sekitar $3 per juta token dan output sekitar $15; model yang lebih murah dalam keluarga yang sama kira-kira $1 input dan $5 output. Anggap itu sebagai ilustrasi, bukan kutipan; periksa halaman harga langsung, karena penyedia merevisinya. Poin struktural ini berlaku terlepas dari angka pastinya: output mahal, dan volume inputlah yang membengkak.

Berikut adalah apa yang mengisi payload input pada eksekusi tipikal:

• **Prompt sistem dan definisi alat.** Instruksi agen ditambah skema JSON setiap alat. Tetap per giliran, seringkali 5.000 hingga 15.000 token, dikirim ulang setiap giliran.
• **File memori dan proyek.** Hal-hal seperti CLAUDE.md, konvensi repo, dan instruksi persisten. Dimuat setiap giliran, relevan atau tidak.
• **Riwayat percakapan.** Setiap pesan pengguna sebelumnya, respons model, panggilan alat, dan hasil alat, diputar ulang sepenuhnya di setiap giliran. Ini bertumbuh tanpa batas dan biasanya merupakan item terbesar dalam sesi panjang.
• **Konten file yang diambil.** File yang dibaca agen. Sebuah Read tunggal pada file 1.200 baris kira-kira 12.000 hingga 18.000 token, dan agen suka membaca seluruh file.
• **Output alat.** Log test runner, gangguan npm install, git diff dari file lock yang dihasilkan, jejak tumpukan. Mentah dan verbose secara default.

Payload output adalah penalaran model, perubahan kode, dan penjelasan. Lebih kecil dari input pada sebagian besar eksekusi, tetapi diberi harga tertinggi per token, jadi perilaku "biarkan saya menjelaskan rencana saya dalam enam paragraf" yang bertele-tele itu mahal.

Fakta terpenting: riwayat percakapan diputar ulang di setiap giliran. Sesi 30 giliran tidak berarti biaya 30 kali satu giliran. Ini lebih dekat ke jumlah prefiks yang terus bertambah, sehingga giliran berikutnya masing-masing membawa beban penuh dari semua yang sebelumnya. Itulah mengapa sesi yang panjang dan bertele-tele adalah hal termahal yang dapat Anda lakukan, dan mengapa taktik di bawah ini secara tidak proporsional menargetkan konteks yang dikirim ulang.

Jika Anda ingin melihat lebih dalam bagaimana akuntansi sesi dan batas berfungsi dalam praktik, rincian dalam cara jendela token Claude Code diatur ulang adalah pelengkap yang berguna untuk bagian ini; ini menjelaskan mengapa sesi yang “terasa singkat” masih dapat menghabiskan anggaran.

Kebersihan Konteks dan File Memori

Token termurah adalah token yang tidak pernah Anda kirim. Kebersihan konteks adalah kebiasaan berdampak paling tinggi karena memperkecil payload input di setiap giliran untuk sisa sesi.

Batasi set kerja sebelum Anda memulai. Jangan membuka agen di root repo dan mengatakan “refactor logika penagihan.” Itu akan merayap. Sebaliknya, beri tahu persis file mana yang penting:

# Alih-alih prompt samar yang memicu eksplorasi luas:
claude "refactor the retry logic so it uses exponential backoff,
only in src/payments/retry.ts and its test file"

Menyebutkan file mencegah agen membaca dua puluh kandidat untuk menemukan dua yang penting. Jika Anda harus membiarkannya menjelajahi, arahkan ke direktori, bukan root.

Jaga agar file memori tetap pendek dan stabil. Sebuah CLAUDE.md (atau file memori proyek yang setara) dimuat ke dalam konteks di setiap giliran. Tim memperlakukannya seperti wiki dan membiarkannya tumbuh hingga 4.000 token teks orientasi. Misalnya, 50 giliran sehari di antara 8 insinyur, file memori yang membengkak dikirim ulang ratusan kali setiap hari tanpa manfaat marginal. Audit itu:

# Perkiraan kasar token pada file memori Anda (karakter / 4 adalah perkiraan yang layak):
wc -c CLAUDE.md | awk '{print "≈", int($1/4), "tokens per turn"}'

Targetkan file yang ringkas: perintah build/test, konvensi keras, dan penunjuk ke tempat dokumen yang lebih dalam berada, bukan dokumen itu sendiri. Jika suatu bagian hanya relevan untuk satu tugas sebulan, itu tidak termasuk dalam file yang selalu dimuat. Pindahkan ke dokumen yang dibaca agen sesuai permintaan.

Kompres atau setel ulang sesi panjang. Ketika sebuah sesi telah menyelesaikan tugasnya dan Anda beralih ke tugas yang tidak terkait, jangan terus mengetik dalam konteks yang sama. Setiap giliran baru sekarang menyeret seluruh transkrip lama. Gunakan perintah kompresi atau hapus agen:

# Di Claude Code, ketika percakapan menjadi panjang:
/compact     # meringkas riwayat menjadi ringkasan singkat, menghapus transkrip mentah
# atau, untuk awal yang baru pada tugas baru:
/clear       # memulai dari awal; konteks lama tidak lagi dikirim ulang

/compact biasanya menggantikan puluhan ribu token riwayat mentah dengan ringkasan sepersepuluh ukurannya, dan prefiks yang lebih kecil itulah yang dibawa oleh setiap giliran berikutnya. Disiplinnya sederhana: satu tugas logis per sesi, kompres atau hapus di antara tugas. Pola alur kerja dalam alur kerja Claude Code sangat bergantung pada kebiasaan pembatasan ruang lingkup ini, dan layak untuk diadopsi secara keseluruhan.

Gunakan file ignore proyek. Jauhkan artefak yang dihasilkan, file lock, output build, dan dependensi pihak ketiga dari jangkauan agen. Jika agen tidak pernah melihat dist/ atau node_modules/, ia tidak akan pernah menghabiskan token untuk membaca atau membandingkannya. Sebagian besar agen menghormati file ignore; konfigurasikan sekali dan penghematannya permanen.

Penyinggahan prompt: berhenti membayar harga penuh untuk prefiks yang sama

Ini adalah tuas terbesar untuk eksekusi berulang, dan ini bersifat mekanis daripada perilaku. Penyinggahan prompt memungkinkan penyedia menyimpan prefiks permintaan Anda (alat, prompt sistem, konteks stabil) sehingga permintaan berikutnya yang berbagi prefiks tersebut membacanya kembali dengan diskon besar alih-alih memproses ulang.

Ekonomi, menurut dokumentasi penyinggahan prompt Anthropic: penulisan cache biayanya lebih mahal daripada token input normal (sekitar 1,25x input dasar untuk cache 5 menit default, sekitar 2x untuk cache 1 jam), tetapi pembacaan cache biayanya sekitar 0,1x input dasar; itu sekitar diskon 90% pada bagian yang di-cache. Karena premium penulisan kecil dan diskon pembacaan besar, penyinggahan menguntungkan setelah satu hit cache pada cache berumur pendek, dan setelah sekitar dua hit pada cache berumur panjang. Masa pakai cache default singkat (sekitar 5 menit, disegarkan setiap kali diakses), dengan opsi 1 jam tersedia. Ada ukuran cache minimum; model kecil dan model terbesar membutuhkan beberapa ribu token sebelum prefiks memenuhi syarat, jadi penyinggahan paling membantu di tempat yang paling penting: prefiks stabil yang besar.

Aturan struktural adalah menempatkan konten stabil terlebih dahulu dan konten volatil terakhir, lalu menyinggahkan batasnya. Urutannya adalah alat → sistem → pesan, dan mengubah apa pun akan membatalkan level tersebut dan semua yang setelahnya. Jadi, Anda ingin stempel waktu, pesan masuk pengguna, dan konten file yang baru diambil datang setelah titik henti cache Anda, bukan sebelumnya.

Jika Anda menggerakkan model langsung dari wrapper CLI Anda sendiri, Anda mengaturnya secara eksplisit:

# Cache prefiks stabil (sistem + definisi alat + konvensi repo).
# Giliran pengguna yang volatil datang setelahnya dan BUKAN bagian dari prefiks yang di-cache.
response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=2048,
    system=[
        {
            "type": "text",
            "text": SYSTEM_PROMPT + REPO_CONVENTIONS,   # stabil di seluruh eksekusi
            "cache_control": {"type": "ephemeral"},       # titik henti cache di sini
        }
    ],
    messages=[{"role": "user", "content": user_task}],     # berubah setiap eksekusi
)

# Periksa apa yang sebenarnya di-cache:
u = response.usage
print("cache write:", u.cache_creation_input_tokens)
print("cache read :", u.cache_read_input_tokens)   # token ini ditagih ~10%
print("fresh input:", u.input_tokens)

Agen refaktor harian yang menjalankan prompt sistem yang sama dan blok konvensi repo 8.000 token yang sama di 60 pemanggilan sehari adalah contoh kasusnya. Tanpa penyinggahan, Anda membayar harga input penuh untuk blok 8.000 token itu 60 kali. Dengan penyinggahan, Anda membayar premium penulisan sekali (atau sekali per kedaluwarsa cache) dan harga baca sekitar 10% di waktu lain. Untuk blok konvensi saja, itu mendekati pengurangan 90%, dan ini bertambah dengan setiap taktik lain di sini.

Dua catatan operasional. Pertama, jaga agar prefiks Anda stabil secara byte; satu karakter yang diubah sebelum titik henti akan merusak cache dan Anda membayar penulisan lagi. Sematkan prompt sistem dan konvensi Anda; jangan menyisipkan stempel waktu ke dalamnya. Kedua, cache berumur pendek secara default, jadi mem-batching eksekusi terkait secara berdekatan (daripada menyebarkannya sepanjang hari) membuat Anda terus menggunakan cache yang hangat. API OpenAI menerapkan diskon serupa untuk input yang di-cache secara otomatis pada model yang didukung; prinsipnya identik meskipun pengaturannya berbeda. Trik tingkat gratis dan perutean di menjalankan GPT-5.5 secara gratis melalui Codex adalah pelengkap yang berguna ketika penyinggahan saja tidak cukup.

Perutean model: model murah untuk pekerjaan murah

Tidak setiap tindakan agen membutuhkan model frontier. Mengganti nama variabel di tiga file, menulis pesan commit, meringkas diff, atau menghasilkan tes boilerplate tidak memerlukan model yang sama dengan yang merancang arsitektur. Namun, perilaku default sebagian besar agen CLI adalah menjalankan semuanya melalui satu model mahal untuk seluruh sesi.

Perutean berarti dengan sengaja mengirimkan sub-tugas berisiko rendah ke model yang lebih kecil dan lebih murah serta mencadangkan model yang mahal untuk penalaran yang sebenarnya. Selisih harga sangat besar: model kecil dalam keluarga tertentu bisa tiga hingga lima kali lebih murah per token daripada model unggulan, dan untuk tugas-tugas mekanis, perbedaan kualitas output dapat diabaikan.

Cara praktis untuk merutekan dari CLI:

# 1. Pilih model per pemanggilan berdasarkan tugas.
claude --model haiku   "write a conventional-commit message for the staged diff"
claude --model sonnet  "redesign the caching layer for the payments service"

# 2. Gunakan model murah untuk loop frekuensi tinggi, berisiko rendah
#    (pesan commit, entri changelog, penjelasan lint cepat)
#    dan model yang kuat hanya ketika Anda secara eksplisit memanggil tugas yang sulit.

Atur default ke model yang lebih murah dan tingkatkan secara sadar, daripada mengatur default ke model yang mahal dan tidak pernah menurunkan. Sebagian besar tim memiliki polaritas terbalik: mereka menjalankan model unggulan untuk semuanya “agar aman” dan membayar lima kali lipat untuk pesan commit.

Sumbu perutean kedua adalah sub-agen. Jika kerangka kerja agen Anda mendukung pendelegasian sub-tugas sempit ke agen anak, berikan agen anak itu model yang murah dan konteks yang kecil. Agen anak melakukan pekerjaan kasar (mencari, meringkas, membuat draf) dengan biaya murah dan melaporkan hasil singkat kembali ke induk yang mahal, alih-alih induk yang mahal melakukan pekerjaan kasar itu sendiri dengan harga penuh dan konteks lengkap. Pola loop otonom dalam perintah tujuan di Codex dan Claude Code menunjukkan cara menyusun delegasi tersebut sehingga model mahal hanya melihat hasil yang disaring.

Catatan tentang batas, bukan hanya dolar. Jika Anda menggunakan paket dengan batas penggunaan daripada bayar sesuai pemakaian murni, perutean juga memperpanjang seberapa jauh alokasi Anda dapat digunakan. Menghabiskan anggaran model premium Anda untuk pesan commit adalah cara tim menemui hambatan pada hari Kamis. Peningkatan batas mingguan Claude Code baru-baru ini membantu, tetapi perutean tetaplah yang membuat alokasi bertahan lama.

Memangkas Output dan Pengambilan Alat

Output alat adalah pembunuh anggaran yang senyap karena tidak terlihat sampai Anda mencarinya. Setiap perintah yang dijalankan agen mengembalikan teks, dan teks itu langsung masuk kembali ke konteks, di mana ia kemudian diputar ulang di setiap giliran berikutnya. Satu npm install dapat mengembalikan ribuan baris. Eksekusi tes dengan logging verbose dapat mengembalikan puluhan ribu token. Sebuah git diff yang menyertakan file lock yang dibuat ulang bisa sangat besar. Agen jarang membutuhkan semuanya; ia hanya membutuhkan status lulus/gagal dan kegagalan yang relevan.

Taktik yang memangkas ini dengan bersih:

Buat perintah hening di sumbernya. Agen membayar untuk apa pun yang dicetak perintah. Konfigurasikan alat agar ringkas:

# Berisik (agen membayar untuk setiap baris):
npm test

# Hening (hanya kegagalan dan ringkasan yang kembali):
npm test --silent -- --reporter=dot

# Berisik:
npm install

# Hening:
npm install --silent --no-audit --no-fund

Saring sebelum agen melihatnya. Ketika Anda mengontrol perintah yang dijalankan agen, saring gangguan sehingga hanya sinyal yang kembali:

# Hanya baris yang relevan yang kembali ke konteks:
pytest -q 2>&1 | tail -n 30

# Statistik diff alih-alih diff penuh 4.000 baris:
git diff --stat

# Grep untuk kegagalan alih-alih membuang seluruh log:
npm test 2>&1 | grep -E "(FAIL|✗|Error)" | head -n 20

Prioritaskan pembacaan yang ditargetkan daripada pembacaan seluruh file. Membaca file 1.500 baris untuk mengubah satu fungsi adalah pemborosan murni. Dorong agen untuk melakukan grep pada simbol dan membaca jendela di sekitarnya, bukan seluruh file. Banyak agen melakukan ini ketika prompt mendorong mereka (“temukan dan baca hanya fungsi yang menangani percobaan ulang, bukan seluruh file”). Pada file besar, itu adalah perbedaan antara ~18.000 token dan ~800.

Batasi cakupan pengambilan. Jika agen Anda melakukan pencarian basis kode atau RAG atas dokumen, batasi berapa banyak chunk yang diambilnya dan seberapa besar ukurannya. Sepuluh cuplikan 200 token yang menjawab pertanyaan lebih baik daripada lima puluh cuplikan 800 token yang menguburnya; Anda membayar setiap token yang diambil terlepas dari apakah model menggunakannya atau tidak.

Perubahan-perubahan ini sebagian besar adalah konfigurasi satu kali (pelapor tes, flag instalasi, file ignore) dan memberikan keuntungan pada setiap eksekusi selamanya, yang menjadikannya salah satu pengembalian terbaik atas upaya dalam seluruh daftar ini.

Mengukur dan Mengaitkan Biaya per Eksekusi

Anda tidak dapat mengelola apa yang tidak Anda ukur, dan “tagihan menurun” bukanlah pengukuran. Untuk mengetahui apakah suatu taktik berhasil, Anda memerlukan biaya yang dikaitkan dengan suatu eksekusi, idealnya ke suatu tugas.

Mulailah dengan data yang sudah diberikan API kepada Anda. Setiap respons menyertakan objek penggunaan. Tangkap itu:

u = response.usage
# Perkiraan biaya dalam dolar; ganti dengan tarif langsung untuk model Anda.
INPUT_RATE  = 3.00 / 1_000_000     # input dasar $/token (ilustratif)
OUTPUT_RATE = 15.00 / 1_000_000    # output $/token (ilustratif)
CACHE_READ  = 0.30 / 1_000_000     # ~10% dari input dasar
CACHE_WRITE = 3.75 / 1_000_000     # ~1,25x input dasar (cache 5 menit)

cost = (
    u.input_tokens          * INPUT_RATE  +
    u.output_tokens         * OUTPUT_RATE +
    u.cache_read_input_tokens  * CACHE_READ +
    u.cache_creation_input_tokens * CACHE_WRITE
)
print(f"run cost ≈ ${cost:.4f}  "
      f"(in={u.input_tokens} out={u.output_tokens} "
      f"cr={u.cache_read_input_tokens})")

Jika Anda menggunakan CLI agen daripada wrapper Anda sendiri, tiga pendekatan berikut berfungsi:

# 1. Sebagian besar CLI agen mengekspos perintah penggunaan/biaya untuk sesi tersebut.
#    Periksa setelah tugas representatif dan catat angkanya.
claude /cost

# 2. Konsol penyedia melaporkan pengeluaran per kunci API. Keluarkan kunci API khusus
#    per agen atau per proyek agar pengeluaran dapat diatribusikan
#    daripada digabungkan menjadi satu total yang tidak dapat dilacak.

# 3. Tandai eksekusi. Bungkus pemanggilan agen dalam skrip yang mencatat
#    stempel waktu, label tugas, dan jumlah token yang dilaporkan ke CSV.
#    Satu minggu dari CSV itu memberi tahu Anda tugas mana yang mahal.

Perkirakan sebelum Anda menjalankan sesuatu yang besar. Tempel prompt dan file yang ingin Anda sertakan ke dalam tokenizer (tokenizer publik OpenAI adalah cara cepat untuk memeriksa ukuran) dan lihat jumlahnya. Jika “sertakan seluruh modul” adalah 90.000 token dan versi yang ditargetkan adalah 6.000, Anda baru saja melihat keputusannya sebelum membayarnya.

Lacak satu angka per tugas representatif seiring waktu: biaya per “eksekusi refaktor harian,” biaya per “eksekusi tinjauan PR.” Ketika Anda mengaktifkan penyinggahan atau mengalihkan sub-tugas ke model murah, angka itu seharusnya bergerak. Jika tidak, taktik tersebut tidak melakukan apa yang Anda pikirkan, dan Anda mempelajarinya dengan harga satu eksekusi alih-alih tagihan sebulan.

Perbandingan Taktik

Rentang penghematan bersifat ilustratif dan bertumpuk secara multiplikatif; keuntungan pada satu taktik bergantung pada pemborosan dasar Anda.

Kesimpulan

Biaya token agen sebagian besar ditimbulkan sendiri, dan baris perintah adalah tempat Anda memperbaikinya. Pemborosan terletak pada konteks yang Anda kirim ulang, output yang tidak Anda baca, dan model yang terlalu mahal untuk tugas yang sedang dikerjakan. Atasi hal-hal tersebut dan tagihan akan turun tanpa menyentuh kualitas pekerjaan.

Lakukan item-item dengan upaya rendah terlebih dahulu; pembatasan ruang lingkup, output yang hening, dan file memori yang ramping tidak memerlukan biaya apa pun dan memberikan keuntungan pada setiap eksekusi mulai sekarang. Tambahkan penyinggahan dan perutean di atasnya dan perbedaannya adalah jenis yang dapat Anda masukkan ke dalam anggaran.