Open-Interpreter: Panduan Agen Koding AI Sumber Terbuka

Jika Anda pernah menjalankan model open-weight di dalam agen koding yang dibangun untuk model lain, Anda tahu itu bukan ide terbaik.

Model biasanya salah membaca skema alat dan menjalankan perintah yang sama yang gagal berulang kali hingga Anda menghentikannya. Setelah Anda kembali ke model yang menjadi dasar pembuatan agen tersebut, tugas yang sama berjalan tanpa masalah. Biasanya masalahnya bukan di modelnya, melainkan pada harness agen di sekelilingnya, karena prompt dan format alatnya disetel untuk pihak lain.

Open Interpreter menyelesaikan ini dengan meniru harness tempat setiap model disetel, seperti Claude Code atau Kimi Code. Ini adalah agen koding AI sumber terbuka yang berjalan dari terminal Anda, dan versi saat ini adalah proyek Rust yang dibangun di atas Codex milik OpenAI, bukan asisten komputer berbasis Python yang mungkin Anda ingat.

Dalam artikel ini, saya akan memandu Anda melalui instalasi, penyiapan model dan harness, alur kerja koding langsung, dan bagaimana Open Interpreter dibandingkan dengan Claude Code, OpenCode, dan Codex.

Baru mengenal agen AI? Daftar di kursus Pengantar Agen AI dan pelajari dasarnya dalam satu sore.

Apa Itu Open Interpreter?

Open Interpreter memberi model AI akses ke proyek Anda dan alat yang biasa digunakan pengembang untuk mengerjakannya.

Anda hanya perlu mendeskripsikan tugas dalam bahasa Inggris biasa, dan agen akan bekerja pada kode Anda. Ia dapat bekerja dengan:

• Berkas: Membaca kode Anda dan mengeditnya
• Perintah: Menjalankan perintah shell, skrip, dan langkah build
• Repositori: Bekerja dengan Git, sehingga dapat memeriksa riwayat proyek dan menampilkan diff dari perubahannya
• Alat pengembangan: Menggunakan test runner dan linter untuk memeriksa hasil kerjanya sendiri
• Tugas multi-langkah: Merangkai tindakan-tindakan ini, dari investigasi awal hingga perbaikan yang sudah diuji

Proyek ini bersumber terbuka di bawah lisensi Apache 2.0. Ia juga tidak terbatas pada satu penyedia model. Anda dapat menghubungkannya ke model hosted, model open-weight, atau model yang berjalan secara lokal di mesin Anda sendiri.

Repositori utama memiliki lebih dari 68.000 bintang GitHub per September 2026.

Cara Kerja Open Interpreter

Open Interpreter bekerja dalam sebuah loop:

1. Tugas: Anda menjelaskan yang Anda inginkan, misalnya "perbaiki tes yang gagal"
2. Inspeksi: Model membaca struktur proyek dan berkas terkait
3. Perencanaan: Menentukan alat atau tindakan yang dibutuhkan tugas
4. Edit: Membaca atau mengubah berkas
5. Perintah: Menjalankan perintah shell, seperti test suite
6. Evaluasi: Memeriksa output untuk melihat apakah perubahan berhasil
7. Iterasi: Mengulangi langkah 2-6 hingga tugas selesai atau membutuhkan masukan Anda

Beberapa langkah ini perlu persetujuan Anda terlebih dahulu, tergantung pada pengaturan izin. Saya akan membahasnya di bagian keamanan.

Berikut gambaran yang lebih visual:

Cara kerja Open Interpreter

Hal yang perlu diingat di sini adalah Anda tidak berbicara langsung dengan model. Open Interpreter mengirimkan tugas Anda ke model, diformat dengan prompt dan definisi alat dari harness yang aktif. Model meminta pemanggilan alat, dan Open Interpreter menjalankannya terhadap basis kode Anda. Hasilnya kemudian kembali ke model untuk langkah berikutnya.

Karena model dan harness adalah lapisan terpisah, Anda dapat mengganti salah satunya tanpa melakukan apa pun pada sisa penyiapan.

Cara Menginstal Open Interpreter

Open Interpreter terinstal sebagai binary mandiri, jadi Anda tidak memerlukan Python atau pip.

Jika ada posting blog lama yang menyuruh Anda menjalankan pip install open-interpreter, itu menjelaskan versi Python legacy. Perintah itu tidak akan memberi Anda agen koding berbasis Rust yang saya bahas di artikel ini.

Anda juga akan memerlukan Git di mesin Anda. Open Interpreter bisa berjalan tanpa itu, tetapi Git memberinya sesi yang paham repositori dan diff.

macOS dan Linux

Jalankan skrip instalasi dari terminal Anda:

curl -fsSL https://www.openinterpreter.com/install | sh

Skrip mengunduh rilis yang tepat untuk platform Anda dan menempatkan perintah interpreter di ~/.local/bin.

Windows

Buka PowerShell dan jalankan:

irm https://www.openinterpreter.com/install.ps1 | iex

WSL juga didukung jika Anda lebih menyukai penyiapan gaya Linux. Dalam hal itu, jalankan perintah macOS dan Linux di dalam terminal WSL Anda.

Verifikasi instalasi

Mulai ulang terminal Anda agar mengambil PATH baru, lalu periksa versinya:

interpreter --version

Jika Anda melihat nomor versi, pemasangan berhasil.

Pemeriksaan versi Open Interpreter

Luncurkan sesi interaktif

Mulai sesi dari direktori mana pun:

interpreter

Anda juga dapat mengetik i, yang merupakan alias singkat untuk perintah yang sama.

Open Interpreter membuka UI terminal tempat Anda mendeskripsikan tugas dalam bahasa Inggris biasa. Saat pertama kali memulainya, ia meminta Anda menghubungkan penyedia model. Saya akan menggunakan model lokal melalui Ollama di bagian berikutnya, jadi Anda dapat melewati langkah ini dulu.

Sesi interaktif Open Interpreter

Untuk keluar dari sesi, ketik /exit.

Cara Menggunakan Open Interpreter

Cara tercepat untuk memahami agen koding adalah memberinya tugas dan melihat apa yang dilakukannya.

Saya akan menggunakan proyek pelacak kebiasaan kecil untuk seluruh bagian ini. Proyek ini memiliki satu fungsi, satu berkas uji, dan satu bug.

Buat proyek demo

Proyek ini menghitung rangkaian terpanjang hari berturut-turut untuk suatu kebiasaan. Misalnya, menghitung berapa hari berturut-turut Anda berolahraga.

Mulai dengan folder proyek dan lingkungan virtual:

mkdir habit-tracker && cd habit-tracker
python3 -m venv .venv
source .venv/bin/activate
pip install pytest

Buat habits.py dengan kode berikut:

def longest_streak(dates):
    """Return the longest run of consecutive days.

    Each date is a 'YYYY-MM-DD' string, for example "2026-03-14".
    Duplicate dates count once.
    """
    days = sorted(set(dates))
    if not days:
        return 0

    longest = current = 1
    for previous, today in zip(days, days[1:]):
        if int(today[8:10]) - int(previous[8:10]) == 1:
            current += 1
            longest = max(longest, current)
        else:
            current = 1
    return longest

Lalu buat test_habits.py:

from habits import longest_streak


def test_streak_within_one_month():
    dates = ["2026-03-01", "2026-03-02", "2026-03-03", "2026-03-10"]
    assert longest_streak(dates) == 3


def test_duplicate_dates_count_once():
    dates = ["2026-03-01", "2026-03-01", "2026-03-02"]
    assert longest_streak(dates) == 2


def test_streak_across_month_boundary():
    dates = ["2026-01-30", "2026-01-31", "2026-02-01"]
    assert longest_streak(dates) == 3

Fungsinya memiliki bug. Saya tidak akan menunjukkannya, karena menemukan bug adalah tugas agen.

Tambahkan berkas .gitignore agar lingkungan virtual dan berkas cache tidak masuk ke repositori:

.venv/
__pycache__/
.pytest_cache/

Sekarang commit proyeknya:

git init
git add .
git commit -m "Initial commit"

Commit ini memberi Anda titik awal yang bersih. Nanti, Anda akan menggunakannya untuk melihat tepatnya apa yang diubah agen.

Jalankan tes untuk mengonfirmasi bug:

python -m pytest

Hasil tes pelacak kebiasaan

Dua tes lolos, dan satu gagal. Itulah masalah yang perlu diselesaikan Open Interpreter.

Mulai Open Interpreter dengan model lokal

Anda akan memerlukan Ollama terpasang dan berjalan. Anda juga membutuhkan model yang mendukung pemanggilan alat, jadi tarik modelnya:

ollama pull qwen3-coder:30b

Lalu mulai Open Interpreter dari folder proyek. Gunakan terminal yang sama, agar agen bisa menggunakan pemasangan pytest dari lingkungan virtual Anda:

interpreter --oss --local-provider ollama -m qwen3-coder:30b

Berikut fungsi masing-masing flag:

• --oss: Menggunakan penyedia sumber terbuka lokal

• --local-provider ollama: Memilih Ollama alih-alih LM Studio

• -m qwen3-coder:30b: Menetapkan model untuk run ini

Jalankan /status untuk mengonfirmasi penyedia aktif, model, mode sandbox, dan kebijakan persetujuan.

Sesi Open Interpreter dengan model Ollama lokal

Minta menyelidiki bug

Anda belum ingin agen mengedit apa pun. Minta diagnosis terlebih dahulu:

The tests in this project are failing. Find the cause and explain how you'd fix it. Don't edit any files yet.

Biasanya agen akan membaca berkas dan menjalankan tes sebelum menjawab. Perintah dijalankan di dalam sandbox, dan jika agen membutuhkan akses lebih dari yang diizinkan sandbox, ia akan meminta persetujuan Anda terlebih dahulu.

Output Open Interpreter

Tinjau usulan perbaikan

Baca penjelasannya sebelum Anda menyetujui apa pun.

Diagnosis yang benar menyatakan fungsi hanya membandingkan hari dalam bulan, sehingga rangkaian terputus saat melintasi bulan baru. Perbaikan yang baik membandingkan tanggal penuh, misalnya dengan date.fromisoformat() dari modul datetime Python.

Jika diagnosisnya salah, luruskan dalam sesi yang sama sebelum agen mengedit kode apa pun.

Usulan perbaikan Open Interpreter

Biarkan mengedit berkas dan menjalankan tes

Setelah Anda puas dengan rencananya, terapkan perbaikan:

Apply the fix to habits.py, then run the tests.

Agen mengedit berkas dan menjalankan ulang pytest. Anda ingin melihat ketiga tes lolos.

Semua tes lolos setelah perbaikan

Periksa diff

Tes yang lolos tidak selalu berarti bug di kode Anda teratasi. Mungkin tes diperbarui untuk mengakali bug. Anda tetap perlu meninjau kode.

Jalankan /diff di dalam sesi untuk melihat perubahan working-tree. Anda juga bisa menjalankan git diff setelah keluar.

Diff perubahan yang dibuat oleh Open Interpreter

Diff persisnya bergantung pada model, jadi milik Anda mungkin tidak sama persis baris demi baris. Jika Anda menyukai perubahannya, commit, dan jika tidak, pulihkan berkas aslinya:

git restore habits.py

Dan itulah idenya. Anda mendeskripsikan masalah, agen menyelidiki dan memperbaikinya, dan Anda meninjau setiap perubahan sebelum menjadi bagian dari kode Anda.

Model di Open Interpreter

Open Interpreter mengharuskan Anda membawa model sendiri.

Setiap permintaan melalui tiga lapisan ini:

Lapisan permintaan

Berikut yang dapat Anda hubungkan:

• Model hosted: Model komersial dari penyedia seperti OpenAI dan Anthropic, dengan masuk atau kunci API
• Model open-weight melalui API: Model seperti Kimi K3 dan DeepSeek, baik dari penyedianya sendiri atau melalui gateway seperti OpenRouter
• Model lokal: Model yang berjalan di perangkat keras Anda sendiri melalui Ollama atau LM Studio, yang merupakan penyedia bawaan yang tidak memerlukan kunci API

Daftar penyedia dibuat dari katalog model publik, dan hanya mempertahankan model yang mendukung pemanggilan alat. Jika ada model yang Anda harapkan tidak ada, biasanya itu penyebabnya.

Ingat untuk mewaspadai ollama-cloud. Ini adalah penyedia hosted terpisah, sehingga permintaan Anda meninggalkan mesin Anda. Hanya penyedia bawaan ollama yang menjalankan model secara lokal.

Beralih model

Anda dapat mengubah model pada tiga tingkat:

• Di dalam sesi: Jalankan /model untuk memilih penyedia, model, dan upaya penalaran

• Untuk satu kali run: Teruskan flag -m, seperti di bagian sebelumnya

• Sebagai default: Atur di berkas konfigurasi Anda

Anda dapat menjalankan /status kapan saja untuk melihat penyedia dan model mana yang aktif.

Konfigurasi penyedia

Open Interpreter membaca pengaturannya dari ~/.openinterpreter/config.toml. Untuk menjadikan penyiapan Ollama dari bagian sebelumnya sebagai default Anda, tambahkan dua baris ini:

model_provider = "ollama"
model = "qwen3-coder:30b"

Setelah itu, interpreter mulai dengan model ini, dan Anda tidak memerlukan flag apa pun.

Penyedia hosted membaca kunci API mereka dari variabel lingkungan. Misalnya, DeepSeek mengharapkan DEEPSEEK_API_KEY:

export DEEPSEEK_API_KEY="your-api-key"

Anda juga dapat menambahkan endpoint kompatibel OpenAI sebagai penyedia kustom:

model_provider = "my-provider"
model = "my-model"

[model_providers.my-provider]
name = "My Provider"
base_url = "https://api.example.com/v1"
env_key = "MY_PROVIDER_API_KEY"
wire_api = "chat"

Pengaturan wire_api memberi tahu Open Interpreter format permintaan apa yang diharapkan endpoint. Gunakan chat untuk Chat Completions yang kompatibel dengan OpenAI, responses untuk OpenAI Responses API, dan messages untuk endpoint bergaya Anthropic.

Proyek tepercaya juga dapat memiliki .openinterpreter/config.toml sendiri, yang menimpa konfigurasi pengguna Anda. Flag baris perintah menimpa keduanya. Jika Anda tidak yakin nilai mana yang berlaku, jalankan /debug-config untuk melihat pengaturan efektif dan asalnya.

Mengapa model dan harness sama-sama penting

Model menentukan seberapa baik agen memahami kode Anda. Harness menentukan bagaimana model melihat tugas dan alat.

Anda membutuhkan keduanya. Model yang baik di dalam harness yang tidak cocok akan mengirim pemanggilan alat yang salah format dan salah membaca hasil. Dan harness yang baik tidak bisa menutupi model yang tidak memahami kode.

Itulah mengapa Open Interpreter memilih harness saat Anda memilih model. Misalnya:

• Model Claude mendapatkan harness claude-code

• Model Kimi mendapatkan kimi-code

• Model Qwen mendapatkan qwen-code

• Model DeepSeek mendapatkan claude-code-bare

Untuk keluarga model lain, Anda dapat memilih harness sendiri dengan /harness.

Hal yang perlu diingat di sini adalah hasil yang lemah tidak selalu berarti modelnya lemah. Sebelum Anda mengganti model, coba model yang sama dengan harness berbeda, yang akan saya bahas rinci di bagian berikutnya.

Harness Agen Open Interpreter

Emulasi harness adalah alasan utama versi Open Interpreter saat ini ada.

Harness agen adalah segala hal di sekitar model yang mengubahnya menjadi agen. Ini mencakup:

• Instruksi: System prompt yang memberi tahu model bagaimana berperilaku dan kapan menggunakan alat, dan lain-lain
• Alat: Tindakan yang dapat dilakukan model, seperti membaca berkas atau menjalankan perintah, dan skema tepat yang harus diikuti setiap pemanggilan
• Pola interaksi: Bagaimana pemanggilan alat dan hasilnya ditambahkan ke percakapan, dan kapan loop berhenti untuk meminta masukan Anda
• Lingkungan eksekusi: Di mana perintah dijalankan, apa yang bisa diakses, dan apa yang membutuhkan persetujuan Anda

Secara sederhana, harness menentukan bagaimana model melihat tugas dan bagaimana keputusannya berubah menjadi tindakan.

Open Interpreter memiliki serangkaian mode harness bawaan. Ini yang paling sering Anda gunakan:

• native: Harness milik Open Interpreter sendiri, diturunkan dari Codex

• claude-code: Meniru prompt dan permukaan alat dari Claude Code milik Anthropic

• kimi-code: Implementasi ulang Rust dari harness Kimi Code yang direkomendasikan Moonshot untuk model Kimi-nya

• qwen-code: Meniru Qwen Code CLI milik Alibaba untuk model Qwen

• swe-agent: Meniru SWE-agent, agen riset yang dibangun untuk menyelesaikan isu GitHub

Daftar lengkapnya juga memiliki varian seperti claude-code-bare, kimi-cli, deepseek-tui, zcode, dan minimal. Jalankan /harness di sesi untuk melihat apa yang didukung versi Anda.

Anda dapat beralih harness di tengah sesi dengan /harness, atau menetapkan default di ~/.openinterpreter/config.toml:

harness = "kimi-code"
harness_guidance = true

Pengaturan harness_guidance menambahkan panduan keandalan di tempat harness mengizinkannya. Atur ke false jika Anda menginginkan emulasi yang lebih ketat. Jika Anda membiarkan harness tidak diatur, Open Interpreter memilih salah satu berdasarkan keluarga model, seperti yang Anda lihat di bagian sebelumnya.

Mengapa harness penting

Kebanyakan vendor model menyetel model koding mereka di dalam penyiapan agen tertentu, dan mereka menerbitkan harness yang direkomendasikan untuk digunakan bersamanya.

Model terbiasa dengan harness itu. Model mempelajari gaya prompt-nya, nama alatnya, format edit berkasnya, dan cara hasil alat dikembalikan.

Katakanlah Anda menjalankan model yang disetel untuk edit cari-dan-ganti di dalam harness yang mengharapkan berkas patch penuh. Model tahu perubahan mana yang harus dilakukan, tetapi terus mendeskripsikan perubahan dalam format yang salah. Loop agen menghabiskan token tanpa kemajuan.

Hasil alat bekerja dengan cara yang sama. Jika harness mengembalikan hasil dalam format yang belum pernah dilihat model, model akan salah membacanya. Jika harness menghapus penalaran model di antara giliran, model yang berpikir kehilangan jejak rencananya sendiri.

Ini berarti model yang sama bisa terlihat bagus di satu agen dan buruk di agen lain, tanpa perubahan pada bobotnya. Ini juga alasan mengapa hasil benchmark koding biasanya menyebutkan harness yang digunakan untuk setiap run.

Model frontier cenderung bisa pulih dari harness yang tidak familiar, tetapi model yang lebih kecil dan lebih murah biasanya tidak. Open Interpreter tidak memaksa setiap model ke satu format, melainkan mengubah format agar sesuai dengan model.

Anda dapat mengujinya sendiri dengan proyek demo. Pulihkan berkas asli dengan git restore habits.py, ganti harness dengan /harness, dan berikan prompt yang sama lagi ke agen. Lalu bandingkan berapa banyak langkah yang dibutuhkan dan bagaimana ia memformat editnya.

Fitur Utama Open Interpreter

Anda sudah melihat sebagian besar fitur ini di artikel. Berikut manfaat masing-masing dalam pengembangan sehari-hari.

Koding paham repositori

Open Interpreter bekerja di dalam repositori Git Anda. Ia membaca struktur proyek dan melacak apa yang diubahnya.

Dua perintah slash membantu di sini. /diff menampilkan perubahan working-tree, dan /review meminta agen memeriksa perubahan saat ini untuk bug dan regresi sebelum Anda commit. Anda dapat menjalankan ulasan yang sama tanpa membuka sesi:

interpreter exec review --uncommitted

Sesi juga disimpan. Jika Anda berhenti di tengah tugas, interpreter resume --last melanjutkannya dari tempat Anda berhenti.

Terminal dan eksekusi perintah

Agen menjalankan perintah yang sama seperti yang Anda lakukan, misalnya test suite, linter, skrip build, dan manajer paket. Semuanya berjalan di dalam sandbox native pada macOS, Linux, dan Windows.

Perintah berdurasi lama dapat berjalan di latar belakang. Gunakan /ps untuk mendaftar dan /stop untuk menghentikannya.

Untuk skrip dan pipeline CI, interpreter exec menjalankan tugas tanpa UI interaktif:

interpreter exec "fix the failing test"

Fleksibilitas model

Anda dapat mengganti penyedia dan model kapan saja dengan /model. Konfigurasi Anda, AGENTS.md, dan skill tetap berlaku setelah pergantian.

Profil membantu di sini. Misalnya Anda menginginkan model murah untuk pekerjaan rutin dan yang lebih kuat untuk ulasan kode. Anda dapat mendefinisikan keduanya di konfigurasi Anda:

[profiles.review]
model_provider = "deepseek"
model = "deepseek-v4-pro"
sandbox_mode = "read-only"

Lalu mulai dengan interpreter --profile review saat Anda membutuhkannya.

Penggantian harness

/harness mengubah bagaimana model melihat tugas tanpa mengubah model. Ini hal pertama yang dicoba saat model kesulitan dengan pemanggilan alat, sebelum Anda beralih ke model yang lebih besar.

MCP dan alat

Model Context Protocol (MCP) menghubungkan agen ke alat yang tidak dirancang untuk bekerja dengannya, seperti server dokumentasi atau basis data. Anda menambahkan server di konfigurasi:

[mcp_servers.docs]
command = "npx"
args = ["-y", "your-docs-mcp-server"]
default_tools_approval_mode = "prompt"

Jalankan /mcp untuk melihat server yang dikonfigurasi dan alatnya. Pengaturan default_tools_approval_mode membuat agen bertanya sebelum menggunakan alat dari server tersebut.

Berlaku sebaliknya juga. interpreter mcp-server mengekspos Open Interpreter sebagai server MCP, dan interpreter acp menjalankannya di dalam editor yang mendukung Agent Client Protocol, standar terbuka untuk menghubungkan editor ke agen koding.

Skill dan AGENTS.md

AGENTS.md adalah berkas Markdown di repositori Anda dengan aturan proyek yang dibaca agen pada setiap tugas. Untuk pelacak kebiasaan, bisa seperti ini:

# AGENTS.md
- Run the tests with python -m pytest before you finish a task.
- Use the Python standard library only. Don't add new dependencies.

Anda juga dapat menjalankan /init, dan agen akan menuliskan versi pertama untuk Anda.

Skill adalah alur kerja yang dapat digunakan ulang, dikemas sebagai folder di .agents/skills di dalam proyek Anda atau ~/.agents/skills untuk pengguna Anda. Agen mengambil skill secara otomatis saat tugas cocok dengannya. Jalankan /skills untuk melihat mana yang tersedia.

Keduanya adalah format bersama, sehingga berkas yang sama bekerja dengan agen koding lain yang mendukungnya. Open Interpreter juga mendukung hook, yang menjalankan perintah Anda sendiri pada titik tertentu dalam sesi. Anda meninjau dan mempercayainya dengan /hooks.

Sandboxing dan persetujuan

Dua pengaturan mengontrol apa yang dapat dilakukan agen:

• Mode sandbox: read-only, workspace-write, atau danger-full-access

• Kebijakan persetujuan: untrusted, on-request, atau never

Sandbox menentukan apa yang mungkin, dan kebijakan persetujuan menentukan kapan agen akan bertanya terlebih dahulu. Dengan workspace-write dan on-request, agen dapat mengedit proyek Anda dan menjalankan tes, tetapi akan bertanya sebelum membutuhkan akses di luar itu.

Anda dapat mengubah keduanya dengan /permissions atau dengan flag -s dan -a. Ada juga flag --yolo yang melewati keduanya, dan dokumentasinya menandainya berbahaya. Saya akan membahas pengaturan ini lebih detail di bagian keamanan.

Open Interpreter untuk Model Lokal dan Terbuka

Open Interpreter menggambarkan dirinya sebagai agen koding yang dibangun untuk model berbiaya rendah.

Agen koding kepemilikan terbesar dibangun di sekitar model milik vendornya. Open Interpreter memberi Anda satu agen yang bekerja dengan model kepemilikan, model open-weight hosted, dan model lokal.

Model open-weight

Model open-weight seperti Kimi, DeepSeek, GLM, dan Qwen memiliki bobot publik. Anda dapat menggunakannya melalui penyedia pihak ketiga atau di perangkat keras Anda sendiri.

Itu memberi Anda dua keuntungan. Model open-weight hosted biasanya lebih murah per token dibanding model frontier kepemilikan. Dan Anda tidak terbatas pada satu host, karena model yang sama berjalan di mana pun bobotnya bisa dijalankan.

Open Interpreter memiliki panduan penyedia khusus untuk Kimi K3, DeepSeek, dan GLM. Ia juga memilih harness yang cocok untuk keluarga model ini.

Inferensi lokal

Ollama dan LM Studio adalah penyedia bawaan, sehingga Anda dapat menjalankan model di mesin Anda sendiri tanpa kunci API atau biaya per token.

Biayanya adalah perangkat keras. Saat saya menguji devstral-small-2 pada MacBook Pro M1 Max dengan memori terpadu 64GB, model itu sendiri memakan 26 GB. Jendela konteks default Ollama terlalu kecil untuk loop agen, dan pada 128k token, penggunaan memori terus naik turun hingga sesi macet.

Agen koding membutuhkan jendela konteks besar, karena system prompt, definisi alat, konten berkas, dan output perintah semuanya harus muat. Ollama merekomendasikan setidaknya 64k token untuk agen gaya Codex. Dan jendela konteks yang lebih besar menggunakan lebih banyak memori di atas modelnya sendiri.

Biaya dan privasi

Open Interpreter berjalan di mesin Anda, tetapi modelnya tidak harus demikian.

Ke mana kode Anda pergi bergantung pada penyedia:

• Penyedia lokal: Prompt, konten berkas, dan output perintah tetap berada di mesin Anda
• Penyedia hosted: Semua itu pergi ke server penyedia, bahkan ketika modelnya open-weight

Konfigurasi, sesi, dan log Anda disimpan secara lokal di bawah ~/.openinterpreter apa pun yang terjadi.

Jika Anda membutuhkan kontrol lebih, Anda dapat menambahkan penyedia kustom yang menunjuk ke server inferensi Anda sendiri. Server apa pun dengan API yang kompatibel OpenAI berfungsi, misalnya deployment vLLM di GPU perusahaan Anda. Dengan cara ini, Anda mendapatkan penyiapan hosted di mana infrastrukturnya milik Anda.

Kinerja penggunaan alat

Model terbuka tidak sama baiknya dalam pemanggilan alat. Anda akan melihat penggunaan alat yang lemah muncul sebagai pemanggilan yang salah format, loop, berhenti dini, atau output perintah yang diabaikan.

Harness yang tepat membantu, tetapi tidak dapat memperbaiki model yang tidak bisa merencanakan tugas multi-langkah. Model lokal yang lebih kecil paling banyak bermasalah di sini.

Sebelum Anda mengarahkan model baru ke proyek nyata, uji pada repositori kecil seperti pelacak kebiasaan yang saya tunjukkan di artikel ini. Jika menunjukkan kelemahan, coba harness berbeda sebelum Anda beralih ke model yang lebih besar.

Berikut rekap cepat opsi Anda:

Opsi Open Interpreter untuk model lokal dan terbuka

Open Interpreter vs. Agen Koding AI Lain

Open Interpreter memiliki banyak kesamaan dengan agen koding terminal lain. Perbedaannya terletak pada siapa yang memiliki alat dan model apa yang menjadi dasar pembuatannya.

Open Interpreter vs. Claude Code

Claude Code adalah agen koding terminal milik Anthropic. Perbedaan pertama adalah kepemilikan - Claude Code bersifat kepemilikan, sedangkan Open Interpreter bersumber terbuka di bawah lisensi Apache 2.0. Anda dapat membaca dan mengubah setiap bagian Open Interpreter.

Pilihan model adalah perbedaan kedua. Claude Code dibangun untuk model Claude. Anda dapat mengarahkannya ke endpoint yang kompatibel dengan Anthropic dari penyedia lain, tetapi harness-nya tetap disetel untuk Claude. Open Interpreter memperlakukan pilihan model sebagai fitur inti.

Perbandingan harness menjadi menarik di sini. Claude Code sendiri adalah salah satu harness yang ditiru Open Interpreter. Dengan mode claude-code, model apa pun mendapatkan prompt dan alat bergaya Claude Code di dalam runtime Open Interpreter. UI dan perintah slash tetap milik Open Interpreter, jadi ini bukan produk yang sama dengan model berbeda.

Keduanya berorientasi terminal. Masing-masing memiliki sesi interaktif dan mode non-interaktif untuk skrip dan CI. Untuk instruksi proyek, Claude Code membaca CLAUDE.md, sementara Open Interpreter menggunakan format bersama AGENTS.md.

Claude Code memiliki ekosistem yang lebih besar. Ia hadir dengan ekstensi IDE, aplikasi desktop dan web, marketplace plugin, subagen, dan SDK. Open Interpreter lebih muda, dan mengandalkan standar bersama seperti MCP, skill, AGENTS.md, dan Agent Client Protocol alih-alih ekosistem sendiri.

Jika Anda bekerja dengan model Claude dan menginginkan pengalaman paling matang, Claude Code adalah pilihan yang lebih aman. Jika Anda ingin menjalankan model lain atau menghindari alat kepemilikan, pilih Open Interpreter.

Open Interpreter vs. OpenCode

OpenCode adalah pasangan terdekatnya. Keduanya bersumber terbuka, berorientasi terminal, dan dibangun untuk bekerja dengan daftar panjang penyedia model.

Dukungan model mirip di atas kertas. OpenCode mendukung lebih dari 75 penyedia, dan Open Interpreter menghasilkan daftar penyedia dari katalog model publik. Keduanya menjalankan model lokal melalui Ollama.

Pengalaman terminal lebih berbeda. OpenCode memiliki TUI sendiri dengan integrasi Language Server Protocol (LSP), yang memberi makan diagnostik kode seperti kesalahan tipe kembali ke model. TUI Open Interpreter berasal dari Codex.

Untuk konfigurasi, OpenCode menggunakan berkas opencode.json, dan Open Interpreter menggunakan config.toml dengan profil.

Arsitektur agen adalah perbedaan utama. OpenCode berjalan sebagai klien dan server, di mana TUI adalah salah satu klien dari server lokal yang juga dapat dihubungkan oleh klien lain. Ia memiliki agen build dan plan bawaan, dan mendukung agen kustom serta subagen. Ia menyesuaikan system prompt untuk setiap keluarga model, tetapi alat dan loop tetap milik OpenCode sendiri. Open Interpreter melangkah lebih jauh dan menukar seluruh harness, termasuk skema alat dan format pesan. Build yang lebih baru bahkan menyertakan mode harness opencode.

Di sisi pengembangan, OpenCode adalah basis kode tersendiri, dibangun oleh tim dan komunitasnya. Open Interpreter dibangun di atas fork Codex, sehingga sebagian besar runtime-nya berasal dari upstream. Itu adalah pertukaran. Open Interpreter mendapatkan sandbox dan runtime milik Codex secara gratis, sementara OpenCode mengendalikan seluruh tumpukannya.

Open Interpreter vs. Codex

Keduanya bukan kompetitor dalam arti biasa. Open Interpreter adalah fork dari Codex.

Keduanya berbagi runtime Rust, TUI, sandboxing, persetujuan, AGENTS.md, skill, MCP, mode exec, dan sebagian besar perintah slash. Saat saya menjalankan Open Interpreter, petunjuk melanjutkan sesi masih bertuliskan codex resume.

Codex adalah agen milik OpenAI, dibangun di sekitar model OpenAI. Ia mendukung model lokal dengan --oss dan penyedia kustom, tetapi pengalaman default menargetkan OpenAI.

Open Interpreter memperluas Codex dalam beberapa arah:

• Emulasi harness: Mengubah prompt, skema alat, dan format pesan agar sesuai setiap keluarga model

• Dukungan penyedia: Memiliki katalog penyedia yang dihasilkan dan panduan khusus untuk Kimi K3, DeepSeek, dan GLM

• Chat Completions: Flag --chat-completions menjalankan penyedia yang kompatibel OpenAI mana pun

• Override Codex SDK: Aplikasi yang dibangun di atas Codex SDK dapat berjalan melalui Open Interpreter sebagai gantinya

Open Interpreter juga menyimpan konfigurasi dan sesinya di bawah ~/.openinterpreter, sehingga tidak bentrok dengan pemasangan Codex.

Jika Anda kebanyakan menggunakan model OpenAI, Codex adalah pilihan yang lebih baik. Jika Anda menggunakan model lain, Open Interpreter memberi Anda alur kerja yang sama dengan dukungan yang lebih baik untuk model tersebut.

Berikut rekap cepat:

Open Interpreter dibandingkan dengan agen koding AI lain

Keamanan dan Izin Open Interpreter

Dampak terburuk dari chatbot adalah memberi jawaban buruk, yang bisa Anda abaikan. Agen koding menjalankan perintah di mesin Anda, membaca dan menulis berkas, dan dapat menjangkau jaringan. Keputusan buruk dari model, atau injeksi prompt, bisa menimbulkan kerusakan nyata. Injeksi prompt berarti instruksi yang tersembunyi dalam konten yang dibaca agen, seperti berkas README atau halaman web.

Open Interpreter mewarisi model keamanannya dari runtime Codex. Ia memiliki dua lapisan - sandbox yang membatasi apa yang mungkin, dan kebijakan persetujuan yang menentukan kapan agen bertanya kepada Anda terlebih dahulu.

Eksekusi perintah dan akses filesystem

Setiap perintah yang dijalankan agen melewati sandbox tingkat OS di macOS, Linux, dan Windows. Ada tiga mode sandbox:

• read-only: Agen dapat membaca berkas, tetapi tidak bisa mengubah apa pun

• workspace-write: Agen dapat mengedit berkas dan menjalankan perintah di dalam folder proyek Anda

• danger-full-access: Tidak ada sandbox sama sekali

Dengan workspace-write, penulisan berkas dibatasi pada workspace aktif. Agen dapat memperbaiki kode Anda, tetapi tidak dapat mengedit berkas di tempat lain di mesin Anda.

Akses jaringan

Dalam mode workspace-write, perintah tidak memiliki akses jaringan secara default. Ini memblokir unduhan dan menghentikan agen mengirimkan kode Anda ke mana pun.

Beberapa tugas membutuhkan jaringan, misalnya menginstal paket. Anda dapat menyalakan akses jaringan di konfigurasi Anda:

sandbox_mode = "workspace-write"

[sandbox_workspace_write]
network_access = true

Nyalakan hanya untuk proyek yang membutuhkannya.

Persetujuan

Kebijakan persetujuan menentukan kapan agen berhenti dan bertanya:

• untrusted: Bertanya sebelum menjalankan perintah yang tidak ada di daftar tepercaya

• on-request: Bertanya saat tugas membutuhkan akses lebih dari yang diizinkan sandbox

• never: Tidak pernah bertanya

Untuk proyek yang dikontrol versi, workspace-write dengan on-request adalah default yang baik. Agen bekerja di dalam proyek Anda dan bertanya sebelum melangkah lebih jauh. Git memberi Anda jalan kembali jika ada yang salah.

Flag --yolo mematikan sandbox dan persetujuan. Gunakan hanya di lingkungan yang dapat dibuang, seperti container atau VM.

Kredensial dan rahasia

Perintah yang dijalankan agen mewarisi lingkungan shell Anda. Jika kunci API Anda ada di variabel lingkungan, perintah tersebut dapat melihatnya.

Anda dapat membatasinya dengan shell_environment_policy:

[shell_environment_policy]
inherit = "core"
exclude = ["AWS_*", "*_TOKEN"]

Pengaturan core hanya meneruskan variabel dasar seperti HOME dan PATH, dan exclude menghapus apa pun yang cocok dengan pola.

Berkas juga merupakan risiko. Agen dapat membaca berkas .env di proyek Anda bahkan dalam mode read-only. Dengan penyedia hosted, apa pun yang dibaca agen akan menuju ke server penyedia tersebut.

Hal yang perlu diingat adalah sandbox membatasi kerusakan, tetapi tetaplah menganggapnya sebagai jaring pengaman, bukan jaminan.

Sebelum Anda membiarkan agen berjalan sendiri, jalankan /status dan periksa mode sandbox dan kebijakan persetujuannya.

Evolusi Open Interpreter

Jika Anda menemukan artikel Open Interpreter yang dimulai dengan pip install, itu tidak salah. Itu menjelaskan proyek yang berbeda.

Open Interpreter asli diluncurkan pada 2023 sebagai proyek Python. Ia memungkinkan model bahasa menjalankan kode Python, JavaScript, dan shell di mesin Anda, dan dikenal sebagai alternatif sumber terbuka untuk Code Interpreter milik ChatGPT. Versi selanjutnya menambahkan kendali komputer, sehingga model juga bisa bekerja dengan desktop Anda.

Proyek utama saat ini adalah penulisan ulang dalam Rust berdasarkan Codex. Fokusnya pada agen koding dan emulasi harness, bukan kendali komputer umum.

Versi Python tidak hilang. Versi itu berlanjut sebagai fork komunitas di endolith/open-interpreter.

Kedua versi menggunakan nama yang sama, riwayat repositori GitHub yang sama, dan perintah interpreter yang sama, sehingga mudah tertukar.

Tetapi penanda yang sangat jelas adalah:

• pip install open-interpreter: Versi Python legacy

• curl atau penginstal PowerShell: Versi Rust saat ini

Kelebihan dan Keterbatasan Open Interpreter

Open Interpreter bukan alat yang tepat untuk setiap penyiapan. Berikut kapan masuk akal dan kapan tidak.

Kelebihan

• Sumber terbuka: Berlisensi Apache 2.0, sehingga Anda dapat membaca, mengaudit, dan mem-fork seluruh basis kode

• Pilihan model: Anda dapat menggunakan model hosted, open-weight, dan lokal dari satu agen, dan beralih di tengah sesi

• Banyak harness agen: Anda mendapatkan performa yang lebih mendekati yang disetel untuk model, yang jarang ditawarkan agen koding lain

• Pengembangan native terminal: Masuk ke alur kerja shell dan Git Anda yang ada, dan mode exec bekerja di skrip dan CI

• Model terbuka dan lebih murah: Proyek dibangun di sekelilingnya, dengan panduan penyedia khusus dan harness yang cocok

• Ekstensibilitas: MCP, skill, hook, AGENTS.md, Agent Client Protocol, dan override Codex SDK memungkinkan Anda menghubungkannya ke alat lain

Keterbatasan

• Kualitas model bervariasi: Agen hanya sebaik model di belakangnya, dan tidak ada harness yang memperbaiki model yang tidak bisa merencanakan tugas multi-langkah

• Model lokal butuh perangkat keras serius: Dalam pengujian saya, devstral-small-2 saja memakan 26 GB memori, sebelum jendela konteks besar yang dibutuhkan agen koding

• Penyiapan butuh lebih banyak usaha: Anda mengelola penyedia, jendela konteks, harness, dan pengaturan sandbox sendiri. Ada juga sisi kasar, seperti merek Codex yang tersisa dan peringatan metadata untuk model Ollama

• Eksekusi perintah berisiko: Sandbox dan persetujuan mengurangi risiko, tetapi tidak menghilangkannya

• Kode tetap perlu ditinjau: Tes yang lolos tidak menjamin perbaikan benar, jadi Anda harus membaca setiap diff

Kesimpulan

Open Interpreter adalah agen koding sumber terbuka yang bekerja dengan model pilihan Anda, apakah model itu hosted, open-weight, atau berjalan di mesin Anda sendiri.

Alur kerjanya sederhana. Anda memilih model dan harness, mengarahkan agen ke sebuah proyek, dan membiarkannya memeriksa, mengedit, dan menjalankan perintah hingga tugas selesai. Lalu Anda meninjau hasil kerjanya.

Emulasi harness membuatnya berbeda dari para pesaing. Open Interpreter tidak memaksa setiap model ke satu penyiapan agen. Ia mengubah penyiapan agar sesuai dengan model, dan itu bisa menjadi pembeda. Model juga menentukan seberapa baik hasil kerja, dan izin menentukan apa yang dapat diubah agen. Tinjauan Anda adalah pemeriksaan terakhir sebelum perubahan apa pun masuk ke basis kode Anda.

Jika Anda ingin mendapatkan sertifikasi insinyur AI, daftar di jalur Associate AI Engineer for Developers dan beralih ke dunia AI sesuai ritme Anda.