Auto Compact di Claude Code adalah fitur yang otomatis “memadatkan” (meringkas dan melipat) konten yang sangat panjang sebelum dikirim ke model, agar tetap muat dalam konteks dan fokus pada bagian yang paling relevan. - Apa yang di-compact: bagian kode yang tidak berubah di diff, boilerplate, file vendor/minified, potongan besar JSON/CSV, output build yang berulang, serta bagian panjang dari stack trace atau log. - Apa yang dipertahankan: nama file dan struktur folder, nomor baris, hunk/perubahan yang relevan, simbol/identifier yang dirujuk, serta cuplikan sekitar baris error agar konteks teknis tetap jelas. - Kapan aktif: saat Anda menempelkan atau melampirkan file/diff/log berukuran besar, atau ketika total konteks mendekati batas token. Fitur ini bekerja otomatis di latar belakang. - Cara mengontrol: di beberapa klien (mis. ekstensi editor atau aplikasi Claude), Anda dapat menonaktifkan Auto Compact di pengaturan, memperluas (expand) konten yang dipadatkan untuk melihat versi penuh, atau meminta secara eksplisit “include the full file” dalam prompt. Ketersediaan opsi dapat berbeda tergantung klien. - Manfaat: menjaga kualitas jawaban pada proyek besar, mengurangi risiko konten penting terpotong karena batas konteks, serta membantu efisiensi penggunaan token. Jika Anda memerlukan audit menyeluruh atau peninjauan baris-per-baris, tampilkan atau kirimkan konten penuh.

Claude Code adalah asisten pengodean agentic dari Anthropic yang dapat membaca codebase, mengedit file, menjalankan perintah, dan berintegrasi dengan alat di alur kerja terminal, IDE, aplikasi desktop, dan browser. Karena bekerja di dalam jendela konteks bersama, sesi yang panjang pada akhirnya akan terisi riwayat chat, output file, dan percakapan alat. Claude Code mengelolanya secara otomatis dengan melakukan kompaksi riwayat percakapan saat Anda mendekati batas; instruksi awal dapat hilang jika hanya ada di riwayat chat.

Hal itu makin penting pada 2026 karena Anthropic terus mendorong Claude Code ke arah pekerjaan yang lebih panjang dan lebih otonom. Pada 25 Maret 2026, Anthropic menerbitkan “Claude Code auto mode: a safer way to skip permissions,” menyebutkan pengguna menyetujui 93% prompt izin dan menggambarkan auto mode sebagai jalan tengah berbasis klasifier antara persetujuan manual dan melewati izin yang tidak aman. Pada 5 Februari 2026, Anthropic juga meluncurkan Claude Opus 4.6, menyoroti kemampuan pengodean lebih kuat, debugging lebih baik, dan sesi agentic yang lebih panjang. Pembaruan tersebut tidak sama dengan auto compact, tetapi jelas menunjukkan arah produk: lebih sedikit interupsi, sesi lebih panjang, dan kontinuitas yang lebih andal.

CometAPI saat ini menawarkan akses ke Claude API dengan harga lebih rendah daripada API resmi, misalnya Claude Sonnet 4.6, Claude Opus 4.6, dan Claude 5.

Apa arti sebenarnya Auto Compact di Claude Code

Auto Compact adalah mekanisme optimisasi konteks bawaan di Claude Code (CLI/aplikasi desktop dari Anthropic) dan ekosistem Claude API yang lebih luas. Fitur ini secara otomatis melakukan intervensi ketika percakapan Anda mendekati batas jendela konteks model—biasanya sekitar 200.000 token untuk model flagship seperti Claude Opus 4 atau Sonnet 4. Dokumentasi hooks menjelaskan dengan jelas: PreCompact terpanggil sebelum operasi kompaksi, dan matcher auto berarti “kompaksi otomatis ketika jendela konteks penuh.” Hook PostCompact yang cocok terpanggil setelah kompaksi selesai, dan menerima compact_summary yang dihasilkan.

Ini penting karena kompaksi tidak sama dengan “memory.” Auto memory adalah sistem pencatatan milik Claude sendiri, sedangkan kompaksi adalah mekanisme manajemen sesi yang memampatkan state percakapan yang sedang berlangsung. Dokumen memory menjelaskan bahwa CLAUDE.md bersifat persisten, auto memory ditulis oleh Claude, dan kompaksi adalah saat riwayat percakapan sesi diperkecil sehingga model bisa terus bekerja.

Alih-alih memaksa chat baru (dan kehilangan riwayat) atau membiarkan model “melupakan” detail penting, Auto Compact:

1. Menganalisis seluruh riwayat — mengidentifikasi elemen inti yang layak dipertahankan.
2. Menghasilkan ringkasan singkat — tentang keputusan, arsitektur kode, bug yang telah diselesaikan, status file, dan langkah berikutnya.
3. Mengganti pesan lama — dengan ringkasan ini (sebuah “blok kompaksi” dalam istilah API).
4. Melanjutkan tanpa hambatan — dengan konteks yang tetap terjaga.

Poin Data Utama (2026):

• Ambang pemicu: Default ~95% kapasitas (atau ~25% tersisa). Sebagian pengguna melaporkan buffer internal menyisakan 20–45k token (~22,5% konteks) untuk proses kompaksi itu sendiri.
• Peningkatan performa: Sejak Claude Code v2.0.64, kompaksi menjadi “instan” alih-alih memakan waktu beberapa menit.
• Contoh penghematan token (dari benchmark Claude Agent SDK): Alur kerja 5 tiket turun dari 204k menjadi 82k token input (pengurangan 58,6%) dengan dua kejadian kompaksi.

Auto Compact bukanlah hal yang sama dengan /clear (yang menghapus semuanya) atau pemotongan sederhana. Fitur ini secara cerdas mempertahankan hal-hal penting—diff kode terbaru, pilihan arsitektur, konvensi penamaan—seraya meringkas loop debugging yang telah tuntas dan percabangan eksploratif.

Mengapa menggunakan Auto Compact di Claude Code?

Sesi pengodean panjang adalah hal biasa. Satu implementasi fitur bisa mencakup 50+ giliran: perencanaan, debugging, refactor, pengujian. Tanpa kompaksi, penggunaan token tumbuh secara linear, kualitas respons menurun, dan biaya melonjak.

Bagi developer, hasilnya adalah berkurangnya kelelahan untuk “memulai ulang.” Alih-alih menyalin ringkasan secara manual ke sesi baru, Anda biarkan Claude mengompakkan sesi dan lanjutkan. Ini sangat berguna dalam perbaikan bug, refactor multi-file, perubahan berbasis pengujian, dan alur kerja yang berat pada review di mana percakapan bisa menjadi sangat panjang. Sesi Claude Code dimulai dengan jendela konteks yang segar, sehingga kompaksi adalah salah satu mekanisme kunci yang membuat pekerjaan jangka panjang menjadi praktis.

Manfaat Utama

• Panjang sesi tak terbatas: Lanjutkan tanpa batas tanpa harus mulai dari awal.
• Efisiensi biaya & performa: Mengurangi token input secara drastis. Laporan dunia nyata menunjukkan penghematan 50–60% pada alur kerja multiphase.
• Fokus dan stabilitas lebih baik: Mencegah “kelebihan konteks” yang membuat model berhalusinasi atau melupakan batasan sebelumnya.
• Melestarikan pengetahuan institusional: Keputusan penting tetap ada dalam konteks bahkan setelah ratusan pesan.
• Mulus untuk alur kerja agentic: Kritis saat menggunakan tools, server MCP, atau setup multi-agent di Claude Code.

Kapan sebaiknya Anda mengandalkan Auto Compact?

Gunakan Auto Compact ketika tugas bersifat jangka panjang secara alami: refactor multi-file, debugging yang bolak-balik antara log dan source, implementasi fitur dengan verifikasi berulang, atau riset yang memerlukan banyak panggilan alat. Dokumentasi Anthropic secara eksplisit menunjuk ke sesi panjang di mana jendela konteks dipenuhi percakapan yang tidak relevan, isi file, dan perintah, serta menyatakan auto compaction mempertahankan kode dan keputusan kunci sekaligus membebaskan ruang.

Kurang cocok ketika tugas pendek, terisolasi, atau memerlukan instruksi yang tepat dan dipertahankan secara permanen. Instruksi dari awal percakapan mungkin akan hilang setelah kompaksi, itulah sebabnya aturan proyek sebaiknya ditempatkan di CLAUDE.md, bukan di prompt sekali pakai yang dapat terkompresi dan hilang kemudian.

Kapan digunakan (atau diaktifkan):

• Selalu aktif secara default bagi sebagian besar pengguna — ideal untuk pengodean harian, refactor besar, atau proyek eksploratif.
• Tugas jangka panjang — memproses antrean, pipeline data, atau codebase multi-file.
• Lingkungan tim/enterprise — di mana kontinuitas konteks lintas sesi penting.
• Proyek berisiko tinggi — kehilangan satu keputusan arsitektur bisa membuang waktu berjam-jam.

Kapan mempertimbangkan untuk menonaktifkan (via /config):

• Anda ingin setiap token konteks untuk kontrol ultra-presisi.
• Anda lebih suka manajemen sepenuhnya manual (power user yang menyimpan/memulihkan rencana via file).

Berita terbaru (2025–2026): Pada Maret 2025, Anthropic meningkatkan logika pelestarian Auto Compact, membuat ringkasan lebih cerdas dalam mempertahankan “informasi penting sambil mengurangi penggunaan token.” Menjelang akhir 2025, pemicu disempurnakan (kadang lebih awal pada 64–75% penggunaan untuk menghindari kompaksi gagal). Awal 2026 terjadi bug sementara di antarmuka web/desktop (ditandai telah diperbaiki pertengahan Januari meski ada laporan sisa), sementara CLI tetap stabil. Versi 2.0.64 (Feb 2026) membuat kompaksi menjadi instan—peningkatan besar untuk pengalaman developer.

Cara menggunakan Auto Compact di Claude Code: Panduan langkah demi langkah

Claude Code dirancang agar setiap sesi dimulai dengan jendela konteks yang segar. Ini bermanfaat karena setiap tugas baru dimulai dengan bersih, dan juga memudahkan Anda melihat ketika suatu sesi mulai “berisik.” Disarankan menggunakan /clear antara tugas yang tidak terkait agar konteks lama tidak terus memakan ruang.

Langkah 1: Periksa Status Konteks Saat Ini

Gunakan /context untuk memvisualisasikan beban konteks saat ini. Daftar perintah bawaan Claude Code menyatakan /context menampilkan grid berwarna dan menyoroti pembengkakan memori, saran optimisasi, dan peringatan kapasitas. Ini adalah cara tercepat untuk mengetahui kapan auto kompaksi kemungkinan akan diaktifkan.

Di sesi Claude Code Anda, ketik:

/context

Ini menampilkan “Context left until auto-compact: XX%” — bar kemajuan waktu nyata Anda.

Langkah 2: Konfigurasikan Auto-Compact (Opsional)

Ketika jendela konteks penuh, Claude Code akan mengompakkan percakapan secara otomatis. Referensi hooks memberi label peristiwa ini sebagai auto, dan peristiwa ini terpanggil ketika jendela konteks penuh. Dalam praktiknya, Anda tidak “mengaktifkan” auto compact, melainkan membiarkan Claude Code melakukannya saat diperlukan.

/config

Arahkan ke “Auto-compact enabled” dan ubah true/false. Default-nya enabled. Anda juga bisa menyesuaikan pengaturan terkait seperti penggunaan server MCP untuk membebaskan token secara proaktif.

Langkah 3: Biarkan Auto-Compact Berjalan Otomatis

Ketika mencapai ~95%:

• Claude menampilkan “Compacting our conversation so we can keep chatting…” (atau sejenisnya).
• Proses berjalan di latar belakang dan sesi dilanjutkan.
• Anda akan melihat ringkasan baru di bagian atas konteks.

Pro tip: Jangan menunggu hingga 0%. Lakukan kompaksi manual lebih awal untuk hasil yang lebih baik (lihat praktik terbaik di bawah).

Langkah 4: Gunakan hooks jika Anda ingin mengotomatiskan proses sekitar kompaksi

Claude Code mengekspos PreCompact dan PostCompact. Referensi hook menunjukkan bahwa PreCompact dapat mendeteksi apakah kompaksi manual atau otomatis, dan PostCompact menerima compact_summary yang dihasilkan. Ini membuat hooks cocok untuk logging, jejak audit, catatan pascakompaksi, atau otomatisasi eksternal.

Pola hook sederhana seperti ini:

{  "hooks": {    "PostCompact": [      {        "matcher": "auto",        "hooks": [          {            "type": "command",            "command": "./scripts/save-compact-summary.sh"          }        ]      }    ]  }}

Dan skrip shell yang cocok dapat membaca input JSON dari stdin, karena command hooks Claude Code menerima JSON dengan cara itu:

#!/usr/bin/env bashset -euo pipefailjq -r '.compact_summary // empty' \  | sed 's/^/[compact] /' \  >> .claude/compact-log.txt

Dokumen mengonfirmasi bahwa command hooks menerima JSON via stdin, dan bahwa PostCompact menyertakan compact_summary, sehingga pola ini selaras dengan model hook saat ini.

Langkah 5: Kompaksi Manual dengan Presisi (Direkomendasikan)

Gunakan /compact ketika Anda ingin asisten meringkas thread saat itu juga. Anda dapat menyertakan instruksi yang membentuk ringkasan yang ingin dipertahankan. Halaman perintah bawaan Anthropic mencantumkan /compact [instructions] sebagai “Compact conversation with optional focus instructions,”

/compact keep the auth flow decisions, the current test plan, and the open TODOs

Pola tersebut berguna tepat sebelum handoff, sebelum berpindah branch, atau sebelum Anda meminta Claude memulai fase kerja baru.

Contoh dari penggunaan nyata:

• Setelah debugging: /compact keep the solution we found, remove debugging steps
• Tonggak proyek: /compact focus on the new feature requirements

Kompaksi di Level API (Lanjutan – Python SDK & Messages API)

Untuk agen atau skrip kustom, gunakan alat kompaksi resmi.

Contoh Claude Agent Python SDK (otomatis untuk alur kerja yang menggunakan tools):

from anthropic import Anthropic

client = Anthropic()

runner = client.beta.messages.tool_runner(
    model="claude-opus-4-6",
    max_tokens=4096,
    tools=your_tools,
    messages=messages,
    compaction_control={
        "enabled": True,
        "context_token_threshold": 100000,  # or lower for aggressive compaction
        "model": "claude-haiku-4-5",        # cheaper summarizer
        "summary_prompt": """Create a focused summary preserving:
1. COMPLETED TASKS and key outcomes
2. CURRENT STATE and open items
3. NEXT STEPS
Wrap in <summary></summary> tags."""
    }
)

Deteksi peristiwa kompaksi:

if curr_msg_count < prev_msg_count:
    print(f"Compaction occurred! Messages reduced from {prev_msg_count} to {curr_msg_count}")
```<grok-card data-id="f4afb5" data-type="citation_card" data-plain-type="render_inline_citation" ></grok-card>

**Full Messages API (beta, 2026)** – requires header:
```bash
curl https://api.anthropic.com/v1/messages \
  --header "anthropic-beta: compact-2026-01-12" \
  --data '{
    "model": "claude-opus-4-6",
    "messages": [...],
    "context_management": {
      "edits": [{
        "type": "compact_20260112",
        "trigger": {"type": "input_tokens", "value": 150000},
        "pause_after_compaction": true
      }]
    }
  }'

API mengembalikan blok kompaksi yang harus Anda teruskan pada panggilan berikutnya. Instruksi kustom dan jeda memberi Anda kontrol penuh atas penganggaran (misalnya, menegakkan batas total 3M token lintas sesi).

Jika Anda menggunakan Claude API dari CometAPI, ubah header message menjadi "https://api.cometapi.com/v1/messages\\".

Auto-Compact vs Manual Compact vs Clear: Tabel Perbandingan

Praktik Terbaik untuk Auto Compact di Claude Code (Pro Tips dari Developer)

Lakukan kompaksi secara proaktif

Aturan ketiga adalah menggunakan kompaksi sebagai “reset”, bukan sebagai penyangga. Jika thread penuh jalan buntu, minta Claude mengompakkan dengan instruksi jelas tentang hal-hal yang penting: tujuan saat ini, pendekatan yang dipilih, tes yang gagal, dan pertanyaan yang belum terjawab. Dalam praktiknya, ini membuat ringkasan jauh lebih berguna daripada membiarkan sistem mengompak tanpa arahan dan berharap hasilnya baik.

Buat instruksi yang bersifat tetap tetap singkat.

Anthropic menyatakan file di atas 200 baris dapat menurunkan kepatuhan, jadi kebijakan yang terlalu panjang biasanya lebih buruk dibanding aturan yang ringkas dan dalam cakupan jelas. Gunakan .claude/rules/ untuk perilaku spesifik tipe file atau path, dan gunakan impor @path saat Anda memerlukan detail pendukung yang lebih kaya tanpa membebani file instruksi utama.
Bebaskan token terlebih dahulu — Nonaktifkan server MCP yang tidak terpakai dengan /mcp atau @server-name disable sebelum melakukan kompaksi.

Gabungkan dengan CLAUDE.md

Perlakukan CLAUDE.md sebagai sumber kebenaran untuk apa pun yang ingin Anda pertahankan sepanjang sesi panjang. CLAUDE.md dibaca ulang setelah /compact, yang menjadikannya tempat yang tepat untuk perintah build, konvensi pengodean, dan aturan persisten yang tidak ingin Anda hilangkan. Auto memory juga berguna, tetapi ini adalah sistem berbeda dengan tujuan berbeda.

Tips lainnya

Pantau via /context — Usahakan penggunaan di bawah 70–80% jika memungkinkan.

Untuk pengguna API — Tetapkan ambang lebih rendah (misalnya 50k–100k) dan gunakan model peringkas yang lebih murah seperti Haiku.

Nonaktifkan hanya bila perlu — Kebanyakan developer kini merekomendasikan menjaga Auto-Compact tetap aktif setelah perbaikan 2025.

Uji kompaksi — Uji di sesi non-kritis terlebih dahulu untuk melihat bagaimana alur kerja spesifik Anda diringkas.

Dampak dunia nyata: Developer melaporkan sesi produktif 2–3x lebih lama dan lebih sedikit momen “Claude lupa apa yang kita lakukan.”

Masalah Umum & Pemecahan Masalah (Edisi 2026)

• Auto-compact tidak terpicu: Periksa web/desktop vs CLI; beberapa bug Jan 2026 telah diperbaiki tetapi pastikan versi.
• Konteks hilang setelah kompaksi: Gunakan /compact manual dengan instruksi eksplisit di kesempatan berikutnya.
• Loop tak berujung atau penggunaan 102%: Jarang; mulai ulang sesi atau gunakan /clear sebagai jalan terakhir.
• Kompaksi lambat: Masalah pra-v2.0.64—perbarui Claude Code.
• Kesalahan blok kompaksi API: Selalu lampirkan blok kompaksi lengkap pada panggilan lanjutan.

Kesimpulan

Auto compact adalah salah satu mekanik tersembunyi terpenting di Claude Code karena menjaga sesi pengodean panjang tetap dapat digunakan tanpa memaksa Anda memulai ulang setiap kali jendela konteks penuh. Aturannya sederhana: biarkan auto compact menangani overflow, gunakan /compact ketika Anda ingin kontrol, simpan panduan yang tahan lama di CLAUDE.md, dan gunakan /clear atau /rewind ketika struktur sesi berubah. Kombinasi ini memberi Anda keseimbangan terbaik antara kontinuitas, kontrol, dan kecepatan dalam alur kerja Claude Code yang panjang.

Auto Compact di Claude Code merepresentasikan lompatan dalam pengembangan berbantuan AI yang praktis. Dengan mengelola jendela konteks 200k token secara cerdas, fitur ini menghilangkan titik gesekan terbesar dalam pengodean bentuk panjang: kehabisan memori. Dengan performa instan (2026), opsi konfigurasi kaya, dan ekstensi API yang kuat, kini Auto Compact menjadi fitur matang dan teruji medan yang digunakan ribuan developer setiap hari.

Langkah aksi hari ini:

1. Buka Claude Code dan jalankan /config — pastikan Auto-Compact aktif.
2. Coba /compact manual dengan instruksi pada proyek Anda saat ini.
3. Jelajahi Python SDK atau Messages API untuk agen otomatis di CometAPI.