Claude Managed Agents vs OpenAI Agents API: Perbandingan

Bayangkan sebuah tim yang menjalankan agent loop buatan sendiri untuk back office ERP di Jakarta. Sebuah worker Python memanggil model, menjalankan tool di dalam container Docker, memangkas history ketika terlalu panjang, dan melanjutkan dari checkpoint setiap kali VPS reboot. Setiap bagian itu adalah kode yang harus dirawat tim. Sepanjang 2026, Anthropic dan OpenAI sama-sama menawarkan untuk menjalankan loop itu bagi mereka, Anthropic lewat Claude Managed Agents pada April dan OpenAI lewat Agents API pada September, sehingga pertanyaannya berubah menjadi: perlukah worker itu dihapus?

Perbandingan Claude Managed Agents vs OpenAI Agents API ini ditulis tepat untuk keputusan tersebut. Isinya mencakup model objek yang sama, tabel fitur lengkap, satu tugas yang ditulis dengan kedua SDK, custom tool, sandbox, penjadwalan, kontrol data, dan biaya. Setiap klaim berasal dari dokumentasi resmi kedua vendor per 1 Oktober 2026. Kedua produk masih beta, jadi periksa halaman yang ditautkan sebelum mengambil keputusan.

Claude Managed Agents vs OpenAI Agents API: satu model objek

Kedua produk ini berakhir dengan istilah yang hampir sama. Keduanya mengenal agent, environment, session, dan events yang mengalir antara aplikasi Anda dan agent yang sedang berjalan. Tabel berikut memetakannya satu per satu; perbedaannya ada di detail, bukan di konsep.

Ada dua perbedaan yang terasa dalam praktik. Claude memperlakukan agent dan environment sebagai resource jangka panjang yang dibuat sekali lalu diberi versi, cocok untuk banyak session yang berbagi satu konfigurasi yang sudah direview. OpenAI membolehkan satu request membawa semuanya dan menambahkan environment bertipe none, cocok untuk agent yang hanya bicara dengan MCP server remote dan tidak pernah butuh shell.

Tabel perbandingan lengkap

Inilah tabel yang perlu ditunjukkan kepada siapa pun yang menyetujui arsitektur. Jika sebuah sel bertuliskan tidak didokumentasikan, artinya halaman vendor per Oktober 2026 tidak menyebut apa-apa, dan itu tidak sama dengan tidak ada.

Baca baris ZDR dan residensi sebelum baris fitur. Kedua vendor mengambil trade-off yang sama: harness hosted yang stateful menyimpan transkrip Anda di server mereka, sehingga tidak ada yang menawarkan Zero Data Retention untuk produk ini. Baris fiturnya cukup mirip, jadi kebanyakan tim akan memutuskan berdasarkan kontrol data, penjadwalan, dan keluarga model mana yang sudah lolos evaluasi mereka.

Satu tugas yang sama di kedua SDK

Cara tercepat merasakan perbedaannya adalah menulis satu pekerjaan dua kali. Blok di bawah meminta tiap platform merekonsiliasi export stok terhadap extract buku besar untuk satu gudang, dalam Python, hanya memakai method yang ditunjukkan dokumentasi masing-masing vendor. Nama model mengikuti yang dipakai dokumentasi tersebut pada Oktober 2026.

# --- Claude Managed Agents -------------------------------------------
from anthropic import Anthropic

claude = Anthropic()  # the SDK adds the managed-agents-2026-04-01 beta header

# Agent and environment are separate, reusable resources. Create them once,
# keep the IDs in config, and reference them from every session.
agent = claude.beta.agents.create(
    name="Stock reconciler",
    model="claude-opus-5-5",
    system="Reconcile the stock export against the GL extract. Report, never post.",
    tools=[{"type": "agent_toolset_20260401"}],  # bash, files, web search/fetch
)
environment = claude.beta.environments.create(
    name="recon-env",
    config={"type": "cloud",
            "networking": {"type": "limited", "allow_package_managers": True}},
)
session = claude.beta.sessions.create(agent=agent.id, environment_id=environment.id)

# Open the stream BEFORE sending the event, so nothing is emitted unseen.
with claude.beta.sessions.events.stream(session.id) as stream:
    claude.beta.sessions.events.send(session.id, events=[{
        "type": "user.message",
        "content": [{"type": "text", "text": "Run the reconciliation for JKT-01."}],
    }])
    for event in stream:
        if event.type == "session.status_idle":
            break  # check event.stop_reason: end_turn OR requires_action

# --- OpenAI Agents API -----------------------------------------------
from openai import OpenAI

oai = OpenAI()

# Agent and environment can be inline; OpenAI provisions the sandbox.
# To reuse settings, save one with oai.beta.agents.create and pass agent_id.
with oai.beta.agents.sessions.create(
    agent={"model": "gpt-6-astra",
           "instructions": "Reconcile the stock export against the GL extract. "
                           "Report, never post."},
    environment={"type": "openai_hosted", "network": {"access": "disabled"}},
    input="Run the reconciliation for JKT-01.",
    stream=True,
) as events:
    for event in events:
        # The turn outcome is the signal. agent.session.idle is not success.
        if event.type in ("agent.session.turn.completed",
                          "agent.session.turn.failed",
                          "agent.session.turn.cancelled"):
            break

Claude butuh tiga panggilan sebelum pekerjaan dimulai, karena agent, environment, dan session adalah resource terpisah. Sebagai gantinya, agent ID bisa dipakai ulang dan berversi, sehingga code review cukup menyetujui satu konfigurasi untuk semua session berikutnya. OpenAI cukup satu panggilan. Kondisi berhentinya juga berbeda: di Claude, session.status_idle dengan stop_reason end_turn berarti agent sudah tidak punya pekerjaan, sedangkan OpenAI melaporkan hasil turn secara eksplisit, completed, failed, atau cancelled, dan hasil itulah yang perlu ditunggu oleh job runner.

Custom tool: kedua platform berhenti dan menunggu Anda

Tool bawaan berjalan di dalam sandbox, tetapi apa pun yang menyentuh ERP sebaiknya kode Anda sendiri: lookup stok read-only, draft jurnal, pencarian vendor. Kedua platform mengimplementasikannya dengan cara yang sama. Agent meminta sebuah panggilan, session berhenti sementara, aplikasi Anda menjalankan fungsinya lalu mengirim hasilnya kembali sebagai event.

# Claude: tool declared on the agent as {"type": "custom", "input_schema": ...}.
# The session emits agent.custom_tool_use, then idles with requires_action.
if event.type == "session.status_idle" and event.stop_reason.type == "requires_action":
    for event_id in event.stop_reason.event_ids:
        call = seen_tool_uses[event_id]          # the agent.custom_tool_use event
        claude.beta.sessions.events.send(session.id, events=[{
            "type": "user.custom_tool_result",
            "custom_tool_use_id": event_id,
            "content": [{"type": "text", "text": run_erp_lookup(call.name, call.input)}],
        }])

# OpenAI: tool declared as {"type": "function", "parameters": ...}.
# The stream emits agent.session.requires_action; the session holds the details.
pending = oai.beta.agents.sessions.retrieve(session_id).required_actions
for action in pending:
    if action.type != "function_call":
        continue                                 # environment_connection, etc.
    oai.beta.agents.sessions.events.create(session_id, events=[{
        "type": "agent.session.input.tool_result",
        "turn_id": action.turn_id,
        "call_id": action.call_id,
        "success": True,
        "output": json.dumps(run_erp_lookup(action.name, action.arguments)),
    }])

# Both: persist (session, call id) -> result BEFORE you send it. After a crash
# you resend the saved result instead of running a side effect twice.

Bentuknya berbeda di satu hal yang berguna. Claude menaruh ID event yang memblokir langsung di event idle, jadi handler streaming sudah memegang semua yang dibutuhkan. Event requires_action dari OpenAI hanya memberi tahu bahwa ada yang perlu dicek, dan daftar required_actions pada session yang di-retrieve memberi tahu apa yang harus dilakukan. Desain kedua ini lebih mudah dipulihkan setelah restart, karena sumber kebenarannya cukup satu pembacaan API, bukan stream yang mungkin sudah terlewat.

Sandbox managed atau self-hosted: apa yang benar-benar tetap di dalam

Kedua platform membolehkan sandbox berjalan di mesin Anda sendiri, dan keduanya tegas bahwa yang dipindahkan adalah eksekusi, bukan agent loop. Harness dan modelnya tetap di sisi vendor.

• Claude Managed Agents menjalankan session di cloud sandbox yang dikelola Anthropic secara default, atau di sandbox self-hosted untuk workload dengan kebutuhan compliance atau residensi data, dengan filesystem yang bertahan lintas interaksi.
• Sandbox yang di-host OpenAI adalah workspace Linux berisi Python, Node.js, dan tool command-line di /workspace, berukuran small 1 vCPU dan 1 GB, medium 2 vCPU dan 4 GB sebagai default, atau large 4 vCPU dan 16 GB, dengan akses jaringan enabled, disabled, atau dibatasi hingga 100 host tertentu.
• Sandbox yang di-host OpenAI bisa dihapus setelah satu jam tanpa aktivitas atau keep-alive, dan timeout itu tidak bisa diubah. File di /workspace/outputs dipublikasikan sebagai artifact immutable saat turn selesai dan tetap bisa diunduh setelah sandbox kedaluwarsa.

Konsekuensinya menyangkut apa yang bisa Anda janjikan ke klien. Sandbox self-hosted menjaga file yang dikerjakan agent, proses yang dijalankannya, dan network egress-nya tetap di sisi Anda, dan itu bernilai nyata ketika agent butuh database yang tidak bisa diakses publik. Namun percakapannya tidak tetap di sisi Anda: perintah dan hasil tool tetap dikirim ke harness vendor agar model bisa memutuskan langkah berikutnya. Jika syaratnya data tidak boleh keluar dari server Anda, tidak ada produk yang memenuhinya, dan jawaban yang jujur adalah library agent yang berjalan di proses Anda sendiri.

Penjadwalan: hanya Claude yang menyediakan cron

Agent back office biasanya dijadwalkan, bukan diajak mengobrol: rekonsiliasi tiap malam, ringkasan umur piutang setiap Senin, pengecekan akrual akhir bulan. Claude Managed Agents menjawabnya dengan scheduled deployments, yang memulai session dari ekspresi cron dalam timezone tertentu. Dokumentasi OpenAI Agents API membahas session, streaming, dan webhook tetapi tidak ada scheduler, sehingga pemicunya tetap di infrastruktur Anda sendiri.

# Claude scheduled deployment: the platform starts a session on a cron.
deployment = claude.beta.deployments.create(
    name="Nightly stock reconciliation",
    agent=agent.id,
    environment_id=environment.id,
    initial_events=[{                     # at least one event is required
        "type": "user.message",
        "content": [{"type": "text",
                     "text": "Reconcile yesterday's movements for every warehouse."}],
    }],
    # Asia/Jakarta has no DST, so the skipped/doubled 2 AM trap never applies.
    schedule={"type": "cron", "expression": "30 4 * * *", "timezone": "Asia/Jakarta"},
)
print(deployment.schedule.upcoming_runs_at)  # confirm the fire times

# A trigger that fails creates a run record, not a session. Alert on these.
for run in claude.beta.deployment_runs.list(deployment_id=deployment.id, has_error=True):
    print(run.created_at, run.error.type)    # e.g. session_rate_limited_error

# OpenAI Agents API: no scheduler is documented, so the cron is yours,
# e.g. a worker that calls oai.beta.agents.sessions.create(...) at 04:30 WIB
# and listens for agent.session.idle / agent.session.failed webhooks.

Ada tiga detail dari halaman scheduled deployments yang mengubah cara mengoperasikannya. Eksekusi diberi jitter hingga 15 persen dari interval, minimal 5 detik dan maksimal 9 menit, jadi job pukul 04.30 bisa mulai pukul 04.39. Trigger yang gagal, misalnya pembuatan session yang terkena rate limit, dicatat sebagai deployment run dengan tipe error dan tidak dicoba ulang sampai jadwal berikutnya. Lalu budget opsional disalin ke setiap session yang dimulai deployment, sehingga membatasi tiap run secara terpisah, bukan total seluruh run.

Kontrol data: ZDR, HIPAA, dan residensi

Kedua vendor menyampaikan hal yang nyaris sama. Claude Managed Agents stateful sejak desainnya, menyimpan history percakapan, state sandbox, dan output di server, sehingga tidak memenuhi syarat Zero Data Retention maupun cakupan HIPAA Business Associate Agreement. OpenAI Agents API menyimpan state session agar pekerjaan bisa berlanjut lintas turn, tidak mendukung Zero Data Retention, dan menyatakan bahwa memilih sandbox self-hosted tidak membuatnya memenuhi syarat. Keduanya memungkinkan session dihapus, dan Claude juga memungkinkan file yang diunggah dihapus secara terpisah.

Residensi adalah titik perbedaannya, itu pun tipis. OpenAI Agents API hanya mendukung residensi data di Amerika Serikat. Di Claude, konfigurasi model sebuah agent bisa mengunci inference_geo ke us, dengan tarif token 1,1 kali tarif standar untuk agent tersebut. Dokumentasi kedua produk tidak mencantumkan region Asia Tenggara.

Berapa biayanya, dan cara memilih

Harga Claude lebih mudah diprediksi. Token ditagih sesuai tarif model, dan runtime session dikenai $0.08 per session-hour, diukur hingga milidetik hanya selama session running dan tidak pernah saat idle menunggu input atau konfirmasi tool. Biaya ini menggantikan penagihan container-hour, bukan menambahinya; contoh di halaman harganya sendiri, session Claude Opus 5 selama satu jam dengan 50.000 token input dan 15.000 token output, totalnya $0.705. OpenAI tidak mencantumkan biaya agent terpisah: token sesuai tarif model, tool dengan tarif standar, dan sandbox hosted dengan tarif container, yang di halaman harganya ditetapkan $0.03, $0.12, dan $0.48 per session 20 menit untuk 1 GB, 4 GB, dan 16 GB, ditagih per menit dengan minimum 5 menit. Setelah bentuk biayanya jelas, empat pertanyaan berikut menentukan pilihan.

1. Bolehkah data berada di vendor sama sekali? Jika Zero Data Retention, BAA, atau penyimpanan di dalam negeri wajib, keduanya gugur dan Anda tetap menjalankan loop sendiri.
2. Keluarga model mana yang sudah lolos evaluasi Anda? Setiap harness hanya menjalankan model vendornya sendiri, jadi ini lebih menentukan daripada baris fitur mana pun.
3. Pekerjaannya terjadwal atau interaktif? Run back office terjadwal lebih cocok dengan deployments milik Claude; agent yang hanya memanggil MCP tool remote lebih cocok dengan environment bertipe none milik OpenAI.
4. Siapa yang menjalankan sandbox? Jika tidak ada, pakai yang hosted dan tentukan ukurannya; jika harus menjangkau sistem privat, anggarkan worker self-hosted beserta lifecycle-nya.

Apa pun pilihannya, simpan tool Anda sebagai fungsi biasa di balik adapter tipis. Kontrak custom tool di atas cukup mirip sehingga memindahkan sebuah tool hanya butuh satu sore, sementara history session sama sekali tidak bisa dipindahkan antar kedua vendor.

Aturan yang layak dibawa: harness agent hosted adalah keputusan data terlebih dahulu, baru keputusan fitur. Claude Managed Agents dan OpenAI Agents API menghilangkan pekerjaan yang sama, yaitu loop, sandbox, compaction, dan recovery, dan keduanya menyimpan transkrip Anda sampai Anda menghapusnya. Jika itu bisa diterima, pilih berdasarkan kualitas model, penjadwalan, dan bentuk harga. Jika tidak, tetap jalankan loop di proses Anda sendiri.