Cara Persistent Memory Membuat AI Coding Agent Lebih Berguna

AI coding agent makin pintar untuk tugas pendek. Namun masalah yang lebih sulit adalah kontinuitas. Tanpa memory, setiap sesi terasa seperti hari pertama: agent harus mencari ulang perintah test, memahami ulang struktur package, mengulang kesalahan lama, dan bertanya hal yang sama.

Persistent memory menyelesaikan masalah itu dengan menyimpan pelajaran penting dari sesi sebelumnya sebagai konteks yang bisa dicari, ditinjau, dan diperbaiki. Tapi kuncinya bukan menyimpan semuanya. Memory yang baik itu selektif, transparan, dan mudah dikoreksi.

Ide dasarnya

Memory untuk AI agent sebaiknya diperlakukan seperti catatan engineering, bukan seperti salinan penuh chat history. Yang disimpan adalah pengetahuan yang masih berguna di sesi berikutnya.

Memory yang baik membantu agent untuk:

• mengingat pengetahuan spesifik proyek
• menemukan kasus lama yang mirip walau kata-katanya berbeda
• memisahkan catatan tepercaya dari hasil ekstraksi otomatis
• melupakan informasi yang sudah salah atau usang
• memberi developer permukaan audit yang jelas

Memory yang buruk menyimpan semuanya. Akibatnya cepat menjadi bising, mahal, dan berisiko.

Siklus kerja memory yang praktis

Tugas user / pekerjaan agent
        |
        v
Ringkasan percakapan
        |
        v
+---------------------------+
| Layer ekstraksi memory     |
| - fact                     |
| - episode                  |
| - procedure                |
| - preferensi user          |
+---------------------------+
        |
        v
+---------------------------+
| Gerbang kualitas & safety  |
| - tidak menyimpan secret   |
| - bukan progres sekali pakai|
| - confidence score         |
| - masuk review jika ragu   |
+---------------------------+
        |
        v
+---------------------------+
| Penyimpanan persistent     |
| - index markdown           |
| - record terstruktur       |
| - catatan episode          |
| - draft workflow           |
| - embedding sidecar        |
+---------------------------+
        |
        v
Diambil kembali di sesi berikutnya

Bagian terpenting di sini adalah gerbang kualitas. Memory tidak boleh langsung percaya semua kalimat yang dibuat model. Instruksi eksplisit dari user bisa lebih dipercaya. Fakta yang diekstrak otomatis sebaiknya diberi confidence lebih rendah dan masuk ke review queue.

Memory yang baik bukan hanya bisa mengingat. Ia juga bisa mengatakan, “catatan ini belum tentu benar, silakan tinjau dulu.”

Apa yang layak disimpan?

Gunakan satu pertanyaan sederhana: apakah informasi ini akan membantu pekerjaan di sesi lain, bukan hanya tugas hari ini?

Batas ini penting. Tanpa batas, memory terasa pintar di awal, lalu perlahan menjadi sumber kebingungan.

Retrieval sebaiknya berlapis

Keyword search tetap berguna, tapi tidak cukup. Developer sering memakai kata yang berbeda dari catatan lama. Catatan tentang “Layer provision” seharusnya tetap muncul ketika user bertanya tentang “dependency injection failure”.

Pipeline retrieval yang sehat bisa dibuat berlapis:

Query pencarian
   |
   +--> 1. Exact dan keyword rank
   |       cepat, deterministik, murah
   |
   +--> 2. Query expansion opsional
   |       model kecil menambahkan istilah terkait
   |
   +--> 3. Embedding similarity opsional
   |       mencari kemiripan makna, bukan hanya kata yang sama
   |
   +--> 4. Fallback markdown
           menangkap catatan topic lama yang ditulis manusia

Skor akhirnya bisa digabung dari beberapa sinyal:

final score = semantic match
            + keyword/topic match
            + confidence
            + reuse count
            - stale penalty

Formula kecil ini punya dampak besar. Memory yang sering dipakai dan terbukti membantu harus naik ranking. Catatan confidence rendah yang tidak pernah dipakai harus turun perlahan.

Kenapa embedding sidecar cukup masuk akal

Untuk memory lokal developer, Anda tidak selalu butuh vector database penuh. Sidecar sederhana sering sudah cukup:

records.jsonl
  fact_123  "Tests must run from packages/app"
  proc_456  "Debug API tests by starting Redis first"

embeddings.jsonl
  fact_123  model=openai/text-embedding-3-small  vector=[...]
  proc_456  model=openai/text-embedding-3-small  vector=[...]

Record tetap mudah diaudit manusia. Vector tetap opsional. Kalau embedding model tidak tersedia, sistem bisa fallback ke keyword search. Kalau embedding model berubah, vector lama bisa diabaikan atau dibangun ulang secara lazy.

Pendekatan ini ringan karena:

• tidak butuh server database tambahan
• tidak berat di migration schema
• tidak memaksa semua pengguna memakai embeddings
• mudah dibersihkan saat maintenance
• setiap vector jelas menunjuk ke record asalnya

Trust state membuat memory lebih aman

Tidak semua memory punya tingkat kepercayaan yang sama.

User berkata       +----------------+
"ingat ini"    --> | Trusted memory  |
                   | confidence 1    |
                   +----------------+

Ekstraksi otomatis +----------------+
dari summary   --> | Candidate fact  |
                   | perlu review    |
                   +----------------+

Sering dipakai     +----------------+
di search      --> | Ranking naik    |
                   | use_count +1    |
                   +----------------+

Ditolak / salah    +----------------+
               --> | Forget/delete   |
                   +----------------+

Dengan model seperti ini, memory bisa dikoreksi. Developer bisa melihat daftar memory, mencari, menyetujui, menolak, atau menghapus catatan yang salah. Permukaan audit ini sama pentingnya dengan retrieval.

Memory juga perlu maintenance

Penyimpanan persistent apa pun butuh perawatan. Untuk agent memory, maintenance bisa dibuat sederhana:

maintenance pass
   |
   +--> hapus record duplikat
   +--> prune record lama, confidence rendah, dan tidak pernah dipakai
   +--> hapus topic file kosong
   +--> batasi ukuran records.jsonl
   +--> hapus embedding vector yang orphan

Tujuannya bukan membuat memory sebesar mungkin. Tujuannya membuat memory tetap tajam.

Rancangan storage yang mudah diaudit

Struktur file yang sederhana biasanya lebih tahan lama:

memory/
  MEMORY.md                 ringkasan yang dibaca saat startup
  records.jsonl             record terstruktur untuk ranking dan audit
  review.jsonl              item otomatis yang perlu ditinjau
  embeddings.jsonl          vector opsional untuk semantic search
  episodes/                 ringkasan sesi yang berkualitas
  skills/.draft/            workflow reusable yang belum dipromosikan
  testing.md                catatan topic buatan manusia
  build.md                  catatan topic buatan manusia

Markdown membuat manusia nyaman membaca dan memperbaiki. JSONL membuat mesin mudah melakukan ranking, touch count, pruning, dan audit.

Mental model yang berguna

Anggap memory sebagai knowledge base kecil yang hidup:

• markdown untuk manusia
• record terstruktur untuk mesin
• review queue untuk trust
• embeddings untuk recall
• maintenance untuk hygiene

Ketika bagian-bagian ini bekerja bersama, AI coding agent tidak lagi terasa seperti asisten stateless. Ia mulai terasa seperti rekan kerja yang mengenal proyek: tidak sempurna, tidak ajaib, tapi berguna.

Manfaat nyatanya sederhana: lebih sedikit kesalahan berulang, debugging lebih cepat, handoff antar sesi lebih mulus, dan jejak memory yang bisa diperiksa developer.

Kalau tim Anda sedang membangun workflow AI internal, mulai dari yang kecil. Buat file project memory, tambahkan record log terstruktur, sediakan command untuk search dan forget, lalu baru tambahkan semantic retrieval. Justru bagian yang tampak membosankan itulah yang membuat bagian pintar menjadi aman.

Butuh bantuan merancang workflow AI yang praktis untuk tim engineering? Lihat layanan software engineering kami atau hubungi Bee Mata.