Pagi tadi di thread, ada yang bertanya tentang bagaimana cara menggunakan GPT sebagai orkestrasi dengan LLM lokal. Pertanyaan tersebut adalah . Karena keterbatasan komentar, saya akan menjelaskan lebih detail dalam bentuk tulisan dan juga menyediakan kode yang bisa dijalankan.

Tujuan dari tulisan ini adalah dua hal:

1. Menunjukkan pola penghematan token dengan kombinasi GPT (atau Claude) berlangganan + LLM lokal pada tingkat kode

2. Memberikan panduan agar bisa dimodifikasi sesuai lingkungan masing-masing (Ollama / LM Studio / LLM lokal lainnya)

Mengapa Pola Ini? — Struktur Penghematan Token

Saat meminta LLM untuk mengerjakan tugas pengkodean, biasanya ada tiga tahapan:

1. Dekomposisi (Decompose) — Memecah permintaan pengguna yang ambigu menjadi instruksi spesifik

2. Generasi (Generate) — Membuat kode (atau konten) yang sebenarnya

3. Verifikasi (Verify) — Memeriksa apakah hasil sesuai dengan persyaratan, memutuskan apakah perlu diulang

Tahap 1 dan 3 membutuhkan . Meskipun inputnya pendek dan outputnya juga pendek, model harus pintar. Tahap 2 berbeda. Dibutuhkan . Inputnya pendek, tetapi outputnya panjang — titik di mana token meledak.

Jika ketiga tahapan dilakukan oleh model berbayar yang sama, tahap 2 akan menghabiskan sebagian besar biaya. Inti dari pola ini adalah:

Tahap 1 dan 3 dilakukan dengan model berbayar yang singkat, sedangkan tahap 2 dilakukan dengan LLM lokal yang panjang.

Keputusan diambil oleh model mahal, pekerjaan dilakukan oleh model murah. Dengan batasan langganan, Anda masih bisa menghemat biaya. (Ada juga yang berpendapat sebaliknya, berdasarkan pengalaman saya, jika kualitas keputusan dan desain bagus, bahkan model sederhana pun bisa melakukan pengkodean dengan baik. Jika ada yang ingin membantah, silakan)

Tiga Peran

Ada satu trik di sini. . Setelah Arsitek membuat kriteria verifikasi, Reviewer bisa melanjutkan sesi yang sama tanpa perlu memasukkan kembali kriteria tersebut ke dalam prompt. Sesi CLI itu sendiri berfungsi sebagai memori kerja. Ini adalah bentuk paling sederhana dari , dan bekerja tanpa database atau vektor store terpisah.

Alur Kerja

Permintaan pengguna
    ↓
[Arsitek] Codex CLI - Dekomposisi + Membuat kriteria verifikasi → Mendapatkan ID sesi
    ↓
[Developer] LLM lokal 27B - Melakukan tugas yang diberikan
    ↓
[Reviewer] Codex CLI - Melanjutkan sesi yang sama → Verifikasi → pass/retry/fail
    ↓
Jika pass, selesai. Jika retry, berikan instruksi tambahan ke Developer. Jika fail, kembalikan ke pengguna.

Retry maksimal 2 kali. Lebih dari itu berarti , jadi dikembalikan ke pengguna.

Kode Contoh

Saya telah mengunggah demo mini yang menerapkan pola ini ke . Hanya satu file Python + Textual TUI, dan alur kerjanya persis seperti yang dijelaskan di atas.

Berikut adalah inti kode (lihat repositori untuk versi lengkap):

async def run_workflow(user_input, cfg, state, emit):
    # 1. Architect: Dekomposisi
    arch = await asyncio.to_thread(
        call_codex,
        ARCHITECT_PROMPT.format(user_input=user_input),
        cfg,
        session_id=state.session_id,  # Jika None adalah sesi baru
    )
    state.session_id = arch.thread_id  # Simpan ID sesi → Reviewer menggunakan kembali
    plan = parse_json_blob(arch.text)
    instructions = plan["developer_instructions"]

    # 2. Developer: Generasi (LLM lokal, biaya token 0)
    dev_output = await asyncio.to_thread(
        call_ollama,
        DEVELOPER_PROMPT.format(developer_instructions=instructions),
        cfg,
    )

    # 3. Reviewer: Validasi (resume sesi Architect → kriteria sudah ada di konteks)
    rev = await asyncio.to_thread(
        call_codex,
        REVIEWER_PROMPT.format(developer_output=dev_output),
        cfg,
        session_id=state.session_id,  # Sesi yang sama!
    )
    verdict = parse_json_blob(rev.text)
    # Menangani pass / retry / fail sesuai verdict

call_codex() adalah pemanggilan subprocess codex exec --json, call_ollama() adalah pembungkus klien Python ollama satu baris. Keduanya tidak melebihi 30 baris.

Pengaturan Lingkungan - Ini mungkin lebih penting

Kodenya sendiri sederhana, tetapi memilih model dan backend yang sesuai dengan lingkungan Anda adalah pekerjaan sebenarnya. Saya akan mengorganisirnya berdasarkan opsi.

1. Pilih Backend LLM Lokal

Ollama - Rekomendasi default. Instalasi dan unduhan model selesai dalam satu baris.

# Setelah instalasi
ollama pull qwen3.6:32b      # atau gemma4:27b, command-r:35b, dll
ollama serve                  # Kadang berjalan otomatis di latar belakang

LM Studio — Untuk mereka yang lebih suka GUI, ingin melihat opsi kuantisasi model secara detail. Mendukung API kompatibel OpenAI.

Jalankan LM Studio → Unduh model → Tab "Local Server" → Start Server
Alamat default: http://localhost:1234

Ollama Cloud — Direkomendasikan untuk mereka yang tidak memiliki GPU lokal atau GPU yang lemah. Anda dapat menjalankan model besar 27B atau lebih tanpa beban pada mesin Anda sendiri. Tier gratis memiliki tingkat "penggunaan ringan", tetapi cukup untuk menjalankan demo seperti ini sesekali. Pro adalah $20/bulan (atau $200/tahun) dengan 50x penggunaan dibandingkan gratis + hingga 3 model bersamaan. Tagihan berdasarkan waktu GPU, bukan unit token, jadi permintaan pendek atau berbagi cache menggunakan jauh lebih sedikit. Bahkan dikombinasikan dengan ChatGPT Plus, sekitar $40/bulan adalah mungkin untuk menggabungkan GPT + kombinasi 27B dengan dua langganan tetap.

# Saat menggunakan Ollama Cloud (ubah host saja)
[developer]
host = "https://ollama.com"  # atau endpoint cloud Anda sendiri
# Perlu mengatur OLLAMA_API_KEY melalui variabel lingkungan

2. Pilihan Model — Berdasarkan VRAM (Per Mei 2026)

Dua hal yang saya rekomendasikan untuk beban kerja pengkodean saat ini adalah Gemma 4 (Google, diluncurkan April) dan Qwen 3.6 (Alibaba, diluncurkan April). Keduanya diluncurkan pada April, dan ada lompatan yang berarti di wilayah 27B-31B.

Qwen 3.6-27B adalah yang paling ramah pengkodean. Dengan SWE-bench Verified 77.2%, Terminal-Bench 2.0 59.3%, berada di level yang sama dengan Claude 4.5 Opus. Lisensinya bebas karena Apache 2.0. Dengan kuantisasi 4-bit, berjalan di 18GB.

Gemma 4 31B memiliki tolok ukur inferensi yang lebih kuat. GPQA Diamond 84.3%, MMLU Pro 85.2%. Pengkodean sedikit tertinggal, tetapi lebih cocok untuk tugas penalaran dan tinjauan.

Anda dapat menulis nama model yang diambil dari hasil ollama list ke dalam config.toml.

[developer]
model = "qwen3.6:27b"            # atau gemma4:31b, gemma4:26b-a4b
host = "http://localhost:11434"  # Default Ollama
temperature = 0.3
num_ctx = 8192

Model 7B/8B cukup untuk pembelajaran, tetapi kemampuannya mengikuti instruksi Architect kurang akurat sehingga loop retry sering terjadi. Untuk benar-benar menyelesaikan pekerjaan, Anda perlu menggunakan model 27B ke atas.

3. Cara Mengganti dengan LM Studio

Demo ini menggunakan default Ollama, jika Anda menggunakan LM Studio, cukup ganti fungsi call_ollama() di app.py dengan klien yang kompatibel dengan OpenAI.

Proses transformasi ini sendiri adalah contoh penggunaan pertama yang bagus untuk demo ini. Jika Anda meminta Codex atau Claude untuk mengubah "fungsi ini menjadi versi LM Studio, URL dasarnya adalah "http://localhost:1234/v1", mereka akan menyelesaikannya dalam 5 menit. Permintaan pertama Anda untuk workflow yang Anda buat adalah memodifikasi workflow itu sendiri.

Kira-kira seperti ini:

from openai import OpenAI

def call_local_llm(prompt, cfg):
    client = OpenAI(
        base_url="http://localhost:1234/v1",
        api_key="lm-studio",  # LM Studio menerima string apa pun
    )
    resp = client.chat.completions.create(
        model=cfg.developer_model,
        messages=[{"role": "user", "content": prompt}],
        temperature=cfg.developer_temperature,
    )
    return resp.choices[0].message.content

Begitulah cara kerjanya. Tambahkan openai ke requirements.txt dan hapus ollama.

4. Memilih Model Architect/Reviewer

Demo ini dibuat berdasarkan Codex CLI. Pengguna ChatGPT Plus/Codex dapat menggunakannya tanpa API key tambahan.

Opsi lain:

Semua "fitur prompt non-dialog + resume sesi", jadi Anda hanya perlu mengubah bagian call_codex() sesuai dengan alat yang digunakan. Seperti transformasi LM Studio, ini juga bisa dilakukan dengan cepat dengan meminta LLM.

Tentu saja ada batasan

Demo ini masih sederhana dan memiliki beberapa kekurangan.

• Tanpa Streaming — menerima semuanya melalui subprocess. Jika proses memakan waktu 30 detik, layar akan tetap tidak berubah selama 30 detik.

• Single Developer — Tidak ada diskusi model ganda atau eksekusi paralel.

• Tanpa Panggilan Alat — Developer tidak dapat mengeksekusi kode mereka sendiri untuk verifikasi.

• Ulangi 2 Kali Saja — Lebih dari itu membutuhkan intervensi pengguna.

• Tidak Ada Status Permanen Selain Sesi — Konvensi proyek, keputusan masa lalu tidak masuk ke konteks.

Jika Anda sering menemui batasan ini dalam pekerjaan Anda, maka itu adalah tanda untuk beralih ke alat lengkap. Kerangka kerja seperti LangGraph dan CrewAI atau tunaFlow yang saya buat, mengimplementasikan pola yang sama dalam versi lengkap. Namun, itu adalah cerita lain, dan untuk saat ini, Anda dapat melihat "bagaimana cara kerjanya" dari demo ini.

Untuk Pemula — Ringkasan Satu Kalimat

1. Langganan ChatGPT Plus / Claude Pro / Gemini + Instal CLI yang sesuai

2. Instal Ollama dan dapatkan model 27B ke atas (atau LM Studio)

3. git clone → pip install -r requirements.txt → cp config.example.toml config.toml → Sesuaikan nama model dengan lingkungan Anda

4. python app.py --check untuk memverifikasi lingkungan

5. python app.py jalankan

Jika Anda penasaran tentang , penjelasan lebih detail tersedia di docs/how-it-works.md.

Silakan tinggalkan komentar jika ada pertanyaan atau kendala. Anda juga dapat melaporkannya sebagai isu di GitHub. Semoga akhir pekan menyenangkan 😁