Jev TypeSafe.ai + Claude: Decision Engine untuk Agentic AI

Jev dari TypeSafe AI membawa gagasan yang agak berlawanan dengan arus utama AI saat ini: tidak semua pekerjaan membutuhkan model yang pandai menulis. Banyak pekerjaan di dalam software sebenarnya hanya membutuhkan satu keputusan kecil—“ini urgent atau tidak?”, “tool mana yang harus dipanggil?”, “perubahan ini melanggar aturan?”, atau “model mana yang perlu menangani tugas ini?”.

Di situlah Jev menarik. TypeSafe menyebutnya sebagai System One Model: model yang menerima state dan pertanyaan bertipe, lalu mengembalikan keputusan terstruktur beserta probabilitas dan confidence. Jev tidak dirancang untuk menulis esai, menghasilkan kode, atau melakukan percakapan panjang. Ia dirancang agar hasil inferensi bisa langsung menjadi input bagi program.

Konsep ini menjadi semakin menarik ketika dipasangkan dengan Claude Code. Claude dapat menjadi “otak” yang mengurai pekerjaan kompleks, membaca repository, menulis kode, menjalankan tool, dan melakukan iterasi. Jev dapat ditempatkan di titik-titik kecil yang membutuhkan keputusan cepat dan bounded—seperti router, classifier, verifier, atau gate.

TypeSafe sendiri meluncurkan Jev pada September 2026 setelah sekitar dua tahun berada dalam stealth. Perusahaan menyebut arsitekturnya, parallel sampler, dan teknik Reinforcement Learning for Calibrated Decisions (RLCD) sebagai fondasi pendekatan tersebut.

Jev itu sebenarnya apa?

Cara termudah memahami Jev adalah dengan membandingkannya dengan API LLM biasa.

LLM konvensional menerima prompt lalu menghasilkan token demi token. Bahkan ketika kita meminta JSON, pada dasarnya kita tetap meminta model generatif menghasilkan sebuah string yang kebetulan harus mengikuti struktur tertentu. Aplikasi kemudian perlu melakukan parsing, validasi schema, retry jika format rusak, dan menangani kemungkinan jawaban yang tidak sesuai.

Jev membalik kontrak tersebut.

Kita menentukan terlebih dahulu bentuk keputusan yang diperbolehkan. Secara sederhana, TypeSafe menyediakan tiga primitive utama:

Choice — memilih satu opsi dari sekumpulan pilihan.
Score — memberikan posisi pada skala yang telah didefinisikan.
Noul — memberikan probabilitas untuk sebuah pertanyaan ya/tidak.

Output Jev bukan paragraf penjelasan. Ia adalah data yang dapat langsung digunakan oleh program.

Misalnya, sebuah tiket support:

Customer: Saya sudah ditagih dua kali dan sangat kecewa.

Daripada meminta LLM menulis JSON dan kemudian memvalidasi hasilnya, workflow Jev dapat mendefinisikan keputusan secara eksplisit:

department = Choice("technical", "billing", "sales")
is_urgent = Noul("Permintaan ini membutuhkan perhatian segera")
frustration = Score(...)

Aplikasi kemudian mendapatkan nilai yang sesuai dengan tipe tersebut.

Inilah alasan TypeSafe menyebut Jev sebagai sesuatu yang lebih mirip function call untuk intelligence daripada chatbot.

“Tidak bisa hallucinate” bukan berarti selalu benar

Ada satu nuansa penting yang perlu diperjelas.

TypeSafe menggunakan bahasa seperti “zero hallucinations” dalam konteks type-safety: model tidak dapat keluar dari schema yang telah ditentukan. Jika pilihan hanya billing, technical, dan sales, Jev tidak tiba-tiba mengembalikan marketing.

Tetapi type-safe bukan synonym dari factually correct.

Model tetap bisa salah memilih billing ketika sebenarnya tiket tersebut masuk kategori technical. Karena itu probabilitas dan confidence menjadi bagian penting dari desain Jev.

Untuk sistem produksi, pola yang lebih sehat bukan:

Jev bilang A → selalu lakukan A

melainkan:

Jev → probabilitas/confidence → policy di kode → action atau human review

TypeSafe sendiri menekankan bahwa confidence dapat digunakan untuk menentukan kapan software bertindak otomatis dan kapan kasus perlu dieskalasikan.

Intinya: Jev menghilangkan kelas error “output tidak sesuai schema”, bukan menghilangkan ketidakpastian dunia nyata.

Mengapa pendekatan ini menarik secara ekonomi?

TypeSafe memosisikan Jev sebagai inference primitive yang sangat murah dan cepat.

Dalam pengumuman peluncurannya, TypeSafe menyebut harga input Jev sebesar $0,042 per satu juta token, dengan output tidak dikenakan biaya token, serta membandingkannya dengan biaya LLM yang lebih tinggi. Situs TypeSafe saat ini juga menampilkan klaim performa hingga ratusan kali lebih murah dan lebih cepat dalam workload tertentu. Angka tersebut adalah klaim dan benchmark dari TypeSafe, sehingga tetap perlu diuji pada workload produksi masing-masing.

Yang lebih penting sebenarnya bukan angka headline-nya.

Bayangkan sebuah coding agent menjalankan 50–100 keputusan kecil selama satu sesi:

apakah prompt membutuhkan tool?
apakah file tertentu relevan?
apakah perubahan menyentuh aturan security?
apakah sebuah command cukup berisiko untuk meminta approval?
apakah context lama masih relevan?
apakah subtask ini pantas memakai model mahal?
apakah hasil tool perlu diverifikasi?

Jika semua keputusan kecil tersebut dilempar ke frontier LLM, kita menggunakan mesin besar untuk pekerjaan yang kadang secara logis hanya membutuhkan classifier.

Di sinilah Jev punya tempat.

Lalu apa hubungannya dengan Claude?

Hubungan Jev dan Claude paling menarik jika dilihat sebagai komplementer, bukan kompetisi langsung.

Claude adalah model generatif dan reasoning yang cocok untuk pekerjaan seperti:

memahami requirement;
menjelaskan masalah;
menulis dan mengubah kode;
merancang solusi;
melakukan eksplorasi repository;
menggunakan tools;
melakukan iterasi ketika solusi pertama belum berhasil.

Claude Code sendiri memiliki arsitektur agentic dengan tools, subagents, hooks, background tasks, dan integrasi MCP. Anthropic menjelaskan bahwa hooks dapat digunakan untuk memicu tindakan tertentu pada titik-titik workflow, sementara subagents memungkinkan pembagian pekerjaan menjadi tugas-tugas khusus.

Jev berada di lapisan berbeda.

Ia cocok untuk pertanyaan seperti:

Claude: "Saya menemukan 12 file. Mana yang paling relevan?"

Jev:
A = auth.ts
B = payment.ts
C = logger.ts
...

atau:

Claude sedang akan menjalankan:
rm -rf ./tmp/cache

Jev:
is_this_command_dangerous = 0.03

Atau sebaliknya:

Claude sedang akan menjalankan:
rm -rf /var/lib/...
Jev:
is_this_command_dangerous = 0.97

Lalu kode policy yang menentukan apakah action tersebut diteruskan, diminta approval, atau diblokir.

Jev tidak menggantikan Claude. Ia menjadi komponen keputusan di sekitar Claude.

Integrasi resmi TypeSafe dengan Claude Code

TypeSafe menyediakan Agent Skill resmi untuk coding agent. Repository resmi typesafe-ai/skills mendokumentasikan instalasi sebagai plugin Claude Code:

claude plugin marketplace add typesafe-ai/skills
claude plugin install typesafe@typesafe-ai

Skill tersebut ditujukan untuk membantu agent merancang workflow TypeSafe, memilih primitive keputusan, dan menyusun typed judgments di dalam kode. Repository tersebut menyebut Claude Code secara eksplisit sebagai salah satu target integrasi.

Ini berbeda dengan mengatakan bahwa Anthropic dan TypeSafe membuat satu produk bersama.

Yang dapat diverifikasi adalah bahwa TypeSafe menyediakan integration path untuk Claude Code, termasuk plugin/skill resmi. Di luar itu terdapat pula berbagai proyek komunitas yang memasang Jev sebagai MCP server atau hook di Claude Code.

Pola arsitektur: Claude sebagai reasoning layer, Jev sebagai decision layer

Salah satu cara paling masuk akal menggunakan keduanya adalah memisahkan pekerjaan berdasarkan jenis output.

                 ┌───────────────────────┐
                 │       Claude Code     │
                 │ reasoning + planning  │
                 │ coding + tool usage   │
                 └───────────┬───────────┘
                             │
                 ┌───────────▼───────────┐
                 │     Decision Layer    │
                 │          Jev          │
                 │ choice / score / noul │
                 └───────────┬───────────┘
                             │
                 ┌───────────▼───────────┐
                 │    Policy in Code    │
                 │ threshold + fallback │
                 └───────────┬───────────┘
                             │
                    ┌────────┴────────┐
                    │                 │
                 Auto Action       Human Review

Desain seperti ini menarik karena policy tetap berada di software, bukan disembunyikan di prompt.

Misalnya:

if (decision.probability >= 0.95) {
  return allow();
}

if (decision.probability <= 0.20) {
  return deny();
}

return requireHumanApproval();

Nilai 0.95 dan 0.20 di atas hanyalah contoh. Threshold produksi harus dikalibrasi menggunakan data nyata, bukan dipilih karena terlihat keren.

Use case 1: routing model di Claude Code

Tidak semua subtask membutuhkan model dengan kemampuan reasoning yang sama.

Claude Code dapat menerima pekerjaan besar lalu membuat beberapa subtask. Jev dapat membantu menentukan karakteristik task tersebut:

Input:
"Tambahkan unit test untuk fungsi parser pada src/parser.ts"

Jev:
task_type = "focused_edit"
complexity = 1
needs_deep_reasoning = 0.12

Policy kemudian bisa memetakan:

focused_edit + low complexity → model lebih ringan
architecture change → model reasoning lebih tinggi
security-sensitive change → model kuat + review

Beberapa proyek komunitas sudah mengeksplorasi pola serupa untuk Claude Code, termasuk model routing dan sub-agent sizing. Namun proyek-proyek tersebut adalah integrasi komunitas, bukan fitur resmi Anthropic.

Use case 2: guardrail untuk tool call

Ini mungkin salah satu use case paling menarik.

Agentic AI tidak hanya menghasilkan teks. Ia menjalankan command, mengubah file, memanggil API, dan berinteraksi dengan sistem.

Anthropic sendiri menekankan bahwa agent yang semakin otonom membutuhkan mekanisme oversight, permissions, dan kontrol yang jelas. Dalam framework mereka, human approval tetap penting untuk action berisiko tinggi.

Jev dapat digunakan sebagai classifier tambahan:

Tool call
   ↓
Plain-code rules
   ↓
Clearly safe? ───────────→ Execute
   │
   └── Ambiguous
          ↓
         Jev
          ↓
   probability / score
          ↓
   ┌──────┼────────┐
   │      │        │
 allow  review    block

Keuntungan desain ini adalah Jev tidak diberi kekuasaan final. Ia memberikan sinyal; policy engine yang memutuskan.

Use case 3: context pruning

Context window yang besar tidak otomatis berarti semua context harus selalu dibawa.

Dalam sesi coding panjang, agent dapat memiliki:

hasil pencarian lama;
output tool;
percakapan;
file yang sudah tidak relevan;
error dari eksperimen sebelumnya;
keputusan yang masih penting.

Jev dapat digunakan untuk menjawab pertanyaan bounded seperti:

Apakah record ini masih relevan dengan task aktif?

atau memilih record mana yang layak dipertahankan.

Salah satu proyek komunitas Claude-Jev secara spesifik mengeksplorasi penggunaan Jev untuk compaction dan context selection di Claude Code. Itu contoh menarik tentang bagaimana model keputusan dapat ditempatkan di bagian yang sangat kecil dari agent loop.

Use case 4: verification

Pola lain adalah membuat Claude menghasilkan solusi, lalu Jev melakukan pemeriksaan sempit.

Misalnya Claude mengatakan:

“Perubahan ini tidak menyentuh authentication.”

Daripada meminta model kedua menulis review panjang, kita bisa mengubah pertanyaannya menjadi:

Noul:
"Apakah diff ini memodifikasi authentication atau authorization behavior?"

Output yang diperlukan aplikasi hanya probabilitas.

Jika tinggi:

→ tambahkan security review

Jika rendah:

→ lanjutkan workflow

Untuk review yang benar-benar kompleks, Claude tetap dapat menjadi reviewer utama. Jev lebih cocok sebagai pemeriksaan kecil yang berulang dan terstruktur.

MCP membuat kombinasi ini semakin menarik

Model Context Protocol atau MCP menyediakan cara bagi agent seperti Claude Code untuk berinteraksi dengan tools dan layanan eksternal. Anthropic menjelaskan MCP sebagai protokol open source untuk menghubungkan Claude dengan services, tools, dan data.

Karena Jev memiliki API dan berbagai integrasi komunitas, arsitekturnya bisa menjadi:

Claude Code
    │
    ├── filesystem
    ├── git
    ├── terminal
    ├── MCP tools
    │
    └── Jev
          ├── classify
          ├── check
          ├── score
          └── route

Dengan model ini, Claude tidak perlu melakukan semua pekerjaan dengan satu jenis intelligence.

Ini mirip arsitektur software tradisional: kita tidak menggunakan database untuk melakukan authentication, dan kita tidak menggunakan compiler untuk mengirim email. Setiap komponen diberi pekerjaan yang sesuai dengan kontraknya.

Jangan menggunakan Jev untuk semuanya

Ini bagian yang justru paling penting.

Jev bukan pengganti Claude.

Jika task-nya:

“Tuliskan artikel 2.000 kata.”
“Refactor modul ini.”
“Jelaskan mengapa sistem distributed tracing kita gagal.”
“Rancang arsitektur microservices.”
“Tulis implementasi OAuth.”
“Buat dokumentasi yang mudah dipahami manusia.”

maka model generatif seperti Claude lebih tepat.

Jev mulai menarik ketika task berubah menjadi:

“pilih A/B/C”;
“ya atau tidak?”;
“beri skor 1–5”;
“apakah ini relevan?”;
“apakah action ini berisiko?”;
“apakah request ini urgent?”;
“route ke model mana?”;
“apakah perlu human review?”.

Dengan kata lain:

Use Claude to reason and create. Use Jev to decide inside the workflow.

Itulah pembagian kerja yang paling masuk akal dari desain keduanya.

Tantangan yang perlu diperhatikan

1. Confidence bukan jaminan kebenaran

Confidence yang tinggi tetap bukan bukti bahwa keputusan benar. Sistem produksi perlu dievaluasi dengan data domain sendiri.

2. Threshold harus dikalibrasi

Jangan langsung menganggap 0.90 berarti aman untuk semua kasus. False positive dan false negative memiliki biaya yang berbeda-beda.

3. Latency bukan hanya latency model

Network round-trip, MCP overhead, serialization, queueing, dan policy engine semuanya ikut menentukan latency end-to-end.

4. Fail-open atau fail-closed harus eksplisit

Untuk guardrail security, kegagalan layanan mungkin sebaiknya membuat workflow meminta approval. Untuk fitur rekomendasi non-kritis, fallback ke workflow biasa mungkin lebih masuk akal.

5. Jangan mengirim context berlebihan

Jev dirancang untuk keputusan yang terdefinisi. State yang terlalu besar dan tidak relevan dapat membuat pertanyaan menjadi lebih sulit, bukan lebih akurat.

6. Versioning matters

Model, prompt/question definitions, threshold, dan policy sebaiknya diperlakukan sebagai komponen yang dapat diuji dan di-version-control.

Apakah Jev akan menggantikan LLM?

Lebih menarik jika pertanyaannya bukan “apakah Jev menggantikan Claude?”, tetapi:

berapa banyak keputusan kecil di dalam sistem AI yang selama ini secara tidak sengaja kita berikan kepada LLM generatif?

Sebuah agent bisa terlihat sederhana dari luar:

User → Claude → Tool → Result

Padahal di dalamnya ada puluhan keputusan:

Should I call a tool?
Which tool?
Which file?
Which model?
Is this result relevant?
Is this action safe?
Should I retry?
Should I ask the user?
Should I continue?

Jika semua keputusan tersebut dikerjakan oleh model generatif yang sama, sistem menjadi mahal, lebih sulit diprediksi, dan lebih sulit diuji secara deterministik.

Pendekatan Jev menawarkan alternatif: pecah intelligence menjadi primitive yang lebih kecil dan typed.

Claude tetap menjadi reasoning engine. Jev menjadi decision engine. Kode tetap menjadi policy engine.

Bagi developer, ini jauh lebih menarik daripada sekadar “model baru yang lebih cepat”.

Kesimpulan

Jev memperkenalkan cara berpikir yang berbeda tentang AI engineering.

Selama beberapa tahun terakhir, kita terbiasa membangun aplikasi AI dengan pola:

Prompt → LLM → Text/JSON → Parse → Validate → Retry

System One mencoba membuat pola yang lebih dekat dengan software:

State → Typed Decision → Probability → Code

Ketika dipasangkan dengan Claude Code, pembagian tugasnya menjadi jelas. Claude mengerjakan pekerjaan yang membutuhkan reasoning, konteks, generasi, dan iterasi. Jev menangani keputusan kecil yang sering muncul di sela-sela pekerjaan tersebut.

TypeSafe sudah menyediakan skill resmi untuk Claude Code, sementara ekosistem komunitas berkembang melalui MCP servers, hooks, router, dan berbagai agent skills.

Pertanyaan menarik ke depan bukan lagi sekadar “model mana yang paling pintar?”

Pertanyaannya berubah menjadi:

“Bagian mana dari workflow kita yang sebenarnya membutuhkan reasoning besar, dan bagian mana cukup membutuhkan keputusan kecil yang cepat, murah, terukur, dan typed?”

Kalau jawabannya adalah yang kedua, Jev punya alasan kuat untuk berada di sana.