Google Antigravity Meluncurkan /swarm: Pemrograman AI Beralih dari Eksekusi Single Agent ke Kolaborasi Tim Multi-Agent, Penjelasan 4 Jenis Peran

Catatan penulis: artikel ini memadukan blog resmi Google Antigravity dan dokumentasi penggunaannya untuk menjelaskan pembagian tugas antar-Agent di /swarm, mekanisme kolaborasinya, manajemen visual, dan batas penggunaannya.

Pada 10 November 2026, Gemini 4 Carbon resmi dibuka. Di hari yang sama, tim Google Antigravity meluncurkan fitur kolaborasi multi-Agent /swarm (Preview). Dengan satu perintah ini, sebuah percakapan bisa berubah menjadi tim teknik AI: ada yang memecah tugas, ada yang menulis kode, ada yang melakukan pemeriksaan, dan ada pula yang bertugas mendeteksi kemajuan yang macet.

Fitur ini punya dasar publik yang jelas. Blog resmi Antigravity dan dokumentasi penggunaan Swarm sudah tersedia, dan Google juga menyebut para insinyurnya sudah memakainya secara internal sekitar 5 minggu. Inti /swarm bukan sekadar membuka beberapa jendela chat sekaligus. Fitur ini mencoba membangun sistem kolaborasi yang bisa memecah tugas secara mandiri, mengeksekusinya secara paralel, berbagi progres, saling memverifikasi, dan terus memperbaiki hasilnya.

Nilai utama: setelah membaca artikel ini, Anda akan memahami cara kerja eksekusi /swarm, bagaimana tiap peran saling bekerja sama, bagaimana pengguna bisa memantau dan campur tangan, serta batasan praktisnya soal kuota dan izin akses.

Istilah Kunci Google Antigravity /swarm yang Perlu Diketahui

/swarm memperkenalkan beberapa istilah peran. Samakan dulu pemahaman tentang konsep-konsep ini, supaya mekanisme di bagian selanjutnya lebih mudah dipahami.

Apa Itu Google Antigravity /swarm: Ringkasan Informasi Utama

/swarm dirilis bersamaan dengan dibukanya Gemini 4 Carbon secara resmi, tetapi keduanya hal yang berbeda. /swarm adalah fitur orkestrasi multi-Agent di Antigravity, sedangkan Gemini 4 Carbon adalah sebuah model. Tabel berikut merangkum informasi yang sudah dipublikasikan secara resmi sejauh ini.

Mengapa Satu Agent Kewalahan Menangani Tugas Rekayasa Besar

Satu Agent bekerja dengan baik untuk satu fungsi atau satu Bug. Namun begitu tugasnya melebar ke puluhan file, dependensi antarmodul, atau perlu menjalankan pengujian berulang kali, satu Agent harus mengingat semua detail dalam satu jendela konteks yang sama. Semakin panjang konteksnya, semakin mudah batasan di awal tergeser oleh detail eksekusi di belakang.

Pembagian tugas juga jadi kendala. Satu Agent hanya bisa bekerja berurutan: selama perubahan di modul A belum selesai, investigasi di modul B harus menunggu. Padahal banyak tugas rekayasa yang sebenarnya bisa dipecah dan dikerjakan paralel, misalnya memperbaiki pengujian yang gagal di berbagai paket perangkat lunak secara terpisah. Eksekusi berurutan jelas membuang waktu.

Yang paling sering terlewat adalah verifikasi. Agent yang menulis kode lalu memeriksa kodenya sendiri cenderung memakai asumsi yang sama, sehingga sulit menemukan kesalahan arah berpikir. Tim manusia mengatasinya dengan meminta orang lain melakukan Code Review, dan /swarm membawa pembagian peran seperti ini ke dalam alur kerja pemrograman AI.

Cara Google Antigravity /swarm Menjalankan Tim Agent

Menurut dokumentasi resmi, setelah /swarm <task> dijalankan, prosesnya berjalan dengan urutan berikut:

1. Percakapan saat ini berubah menjadi Coordinator: Agent yang sedang Anda ajak bicara menjadi koordinator yang bertugas memahami tugas secara keseluruhan.
2. Memecah pekerjaan: Coordinator membagi tugas menjadi beberapa subtugas sesuai strukturnya.
3. Membuat Worker yang independen: Setiap pekerjaan ditangani satu Worker, dan setiap Worker mendapat konteks sendiri beserta satu deskripsi tugas yang bersifat publik.
4. Eksekusi dan verifikasi: Worker mengubah kode atau melakukan investigasi. Verifier memeriksa perubahan kode, menjalankan pengujian, lalu mengirim temuan masalah ke Worker yang bersangkutan.
5. Siklus perbaikan: Worker memperbaiki kode berdasarkan umpan balik, lalu hasil perbaikannya diperiksa lagi.
6. Laporan ringkasan: Coordinator menggabungkan hasil seluruh anggota tim dan melaporkannya kepada pengguna.

Konteks setiap Worker terpisah dan hanya berisi informasi untuk bagian tugasnya sendiri, sehingga masalah konteks panjang yang saling mencemari menjadi berkurang. Deskripsi tugas bersifat publik, jadi anggota lain bisa tahu siapa mengerjakan apa, dan pembagian kerjanya punya batas yang jelas.

/swarm Pembagian Tim: Coordinator, Worker, Verifier, dan Monitor

Menurut dokumentasi resmi, sebuah tim Swarm biasanya terdiri dari empat jenis peran. Perlu dicatat bahwa ini adalah pola organisasi tipikal yang dijelaskan secara resmi, bukan arsitektur baku yang dipakai untuk semua tugas. Berapa banyak Worker yang dibuat dan apakah perlu anggota tambahan, semuanya ditentukan Coordinator berdasarkan tugasnya.

Mekanisme Verifier dan Monitor di /swarm

Blog resmi menyebut Verifier sebagai “Agent verifikasi adversarial”. Tugasnya mencari masalah: memeriksa perubahan yang dibuat Agent lain, menjalankan tes, dan mempertanyakan perubahan yang tidak masuk akal. Setelah menerima masukan, Worker memperbaiki lalu mengirimkan ulang untuk diperiksa. Dengan begitu, eksekusi dan verifikasi membentuk satu lingkaran tertutup.

Monitor menangani jenis risiko yang berbeda. Ketika banyak Agent bekerja sama, bisa terjadi situasi ketika semua anggota saling menunggu dan tidak ada yang bergerak maju. Monitor biasanya tidur. Begitu mendeteksi bahwa seluruh tim berhenti beraktivitas sementara tugas belum selesai, ia akan membangunkan anggota terkait. Berkat Monitor, saat tim macet kita tidak perlu sepenuhnya bergantung pada intervensi manual dari pengguna.

Peran yang Berbeda di /swarm Bisa Memakai Model yang Berbeda

Dalam blog resminya, Google menyarankan agar model dibagikan sesuai karakter tiap peran, bukan membuat semua Agent memakai model termahal:

• Gunakan Gemini 4 Carbon: desain arsitektur secara keseluruhan, koordinasi tugas, tinjauan keamanan, audit kode yang kompleks
• Gunakan model yang lebih cepat dan ringan: implementasi kode rutin, perubahan file secara paralel
• Gunakan Agent verifikasi khusus: pengujian dan verifikasi otomatis

Contoh di dokumentasi resmi juga menunjukkan penggunaan model yang berbeda untuk implementasi kode dan verifikasi independen. Ini adalah pendekatan yang menyeimbangkan biaya dan kemampuan: penilaian yang kompleks diserahkan ke model yang kuat, sedangkan pekerjaan eksekusi dalam jumlah besar diserahkan ke model yang cepat.

💡 Saran pemilihan: Kalau kamu juga ingin memadukan model berdasarkan peran di pipeline multi-Agent buatan sendiri, coba dulu lewat APIYI (apiyi.com) dengan satu API Key yang sama untuk menguji performa tiap model pada tahap perencanaan, implementasi, dan peninjauan. Setelah menemukan model yang cocok untuk tiap peran, baru kunci konfigurasinya. Saat berganti model, kamu cukup mengubah parameter model.

/swarm Bagaimana Banyak Agent Bekerja Sama Tanpa Saling Mengganggu

Papan Pesan Bersama: Komunikasi Terbuka Antar-Agent

Setiap Agent memakai satu papan pesan bersama (Shared Message Board) yang bersifat append-only, dan seluruh proses kolaborasi serta progres tugas tercatat di atasnya. Pesan hanya ditambahkan, tidak pernah menimpa, sehingga riwayat komunikasi tim tetap utuh dan bisa ditelusuri. Agent bisa tidur saat menunggu anggota lain, lalu dibangunkan ketika membutuhkan input; Google menyebut bahwa menunggu dalam keadaan idle tidak menghabiskan Token.

Desain ini jauh lebih transparan dibandingkan membiarkan Agent saling memanggil secara privat. Umpan balik Verifier ke Worker maupun keputusan penjadwalan Coordinator semuanya terhampar terbuka, sehingga pengguna bisa melihat dengan jelas di tahap mana masalah muncul saat meninjau kembali.

Perbedaan Ruang Kerja Bersama dan Salinan Kerja Independen

Bagian ini sering salah tulis karena blog resmi dan dokumentasi penggunaan menyampaikannya dengan cara berbeda. Blog menekankan bahwa Worker paralel dapat bekerja di Git Worktree yang terisolasi agar tidak langsung mengubah direktori yang sama. Sementara dokumentasi penggunaan menjelaskan aturan yang lebih rinci:

• Kondisi default: Workers berbagi ruang kerja saat ini.
• Isolasi sesuai kebutuhan: ketika beberapa Worker perlu mengubah atau melakukan build pada proyek secara bersamaan, Coordinator dapat memberi mereka salinan kerja kode yang independen.
• Dihapus berarti hilang: saat sebuah Worker dihapus, salinan kerjanya ikut terhapus, jadi hasilnya harus di-merge atau di-commit terlebih dahulu.

Jadi rumusan yang tepat adalah: sistem menyiapkan salinan kerja terisolasi sesuai kebutuhan tugas paralel, bukan berarti semua Agent secara bawaan memiliki Git Worktree yang sepenuhnya independen. Untuk tugas yang hanya melakukan investigasi tanpa mengubah berkas, ruang kerja bersama sudah cukup; sedangkan ketika beberapa Worker mengubah kode dan menjalankan build secara bersamaan, salinan independen dapat mengurangi konflik berkas.

Cara mengamati dan mengendalikan tim /swarm di Antigravity

Ketika banyak agent bekerja paralel, hal yang paling dikhawatirkan adalah pengguna tidak tahu apa yang sedang terjadi di dalamnya. Antigravity menyediakan tiga tampilan inti untuk mengatasinya, dan di CLI pun tersedia pintasan yang setara.

Kendali pengguna tidak berhenti pada melihat hasil saja. Lewat pintasan-pintasan ini, kamu bisa menelusuri jejak kerja setiap agent, langsung masuk ke salah satu Worker untuk ikut campur, dan menyesuaikan permintaan tugas pada Coordinator. Alt + J dan Ctrl + K menunjukkan bahwa persetujuan pemanggilan tool tetap berada di tangan manusia — ketika agent perlu menjalankan operasi sensitif, ia akan berhenti dan menunggu konfirmasi.

Tugas rekayasa rumit apa yang bisa diselesaikan /swarm

Google menyebutkan tiga skenario penggunaan internal yang utama: migrasi multi-paket, investigasi akar masalah lintas subsistem, dan perancangan ulang arsitektur perangkat lunak yang kompleks. Ketiganya punya kesamaan: beban kerjanya besar, bisa dipecah, dan memerlukan verifikasi.

Contoh dari dokumentasi resmi justru lebih dekat dengan pekerjaan sehari-hari:

• Memodifikasi beberapa API Handler secara terpisah, sekaligus menyiapkan pengujian untuk masing-masing Handler;
• Menyelidiki penyebab lambatnya startup CLI secara paralel;
• Mengelompokkan tes yang gagal di proyek besar berdasarkan paket, lalu membagikannya ke agent berbeda untuk diperbaiki;
• Menugaskan model berbeda untuk implementasi kode dan verifikasi independen.

Google juga pernah menampilkan sebuah demo resmi: dengan kolaborasi multi-agent di Antigravity, Carbon memproses 7 berkas PDF perencanaan kota yang tersedia publik, mengekstrak 206 tampilan gambar teknik, lalu menghasilkan model bangunan Three.js interaktif dengan sekitar 906.000 permukaan segitiga — seluruh prosesnya melewati 10 putaran iterasi pada malam hari. Ini adalah studi kasus resmi dari Google, bukan verifikasi pihak ketiga independen, tetapi cukup memberi gambaran bagaimana pembagian kerja multi-agent berjalan pada tugas berdurasi panjang.

Biaya, Izin Akses, dan Batasan Preview pada /swarm

Konsumsi Kuota pada Multi-Agent

Agent yang sedang menganggur tidak memakai Token, tapi bukan berarti /swarm itu hemat. Setiap Worker adalah Agent yang berdiri sendiri, jadi kalau beberapa anggota bekerja bersamaan, kuota terkuras jauh lebih cepat dibanding satu percakapan biasa. Google sendiri sudah mengingatkan hal ini.

Ada satu jebakan lain yang sering terlewat: kalau kuota sebuah Worker habis, ia akan berhenti, dan setelah kuota pulih pun ia tidak akan otomatis melanjutkan pekerjaan. Pengguna harus menanganinya secara manual. Jadi sebelum memulai tugas besar yang berjalan lama, sebaiknya hitung dulu apakah kuotanya cukup.

Izin Fitur Swarm ≠ Izin Model Carbon

Ini bagian yang paling gampang bikin bingung. Bisa memakai /swarm bukan berarti bisa memakai Carbon di dalam Swarm.

Singkatnya, pengguna Pro bisa mencoba mekanisme kolaborasi Swarm, tetapi model apa saja yang bisa dipakai Agent tetap dibatasi oleh izin model dari masing-masing langganan.

Analisis Dampak: /swarm Mendorong Pemrograman AI dari Asisten Menuju Tim

Dampak bagi Developer

• Pergeseran peran: Developer berubah dari “orang yang bertanya kepada model” menjadi “orang yang mengorganisasi tim AI”. Kualitas pemecahan tugas dan standar penerimaan hasil akan langsung memengaruhi output.
• Verifikasi didahulukan: Mekanisme Verifier menjadikan pengujian dan peninjauan sebagai bagian bawaan dari alur kerja, bukan lagi langkah perbaikan setelah kode selesai dibuat.
• Manajemen biaya jadi penting: Worker yang berjalan paralel berarti Anda perlu memperhatikan kuota, kombinasi model, dan granularitas tugas, tidak bisa hanya menilai dari pengalaman satu kali percakapan.

Dampak bagi Industri

• Kolaborasi multi-model menjadi arah penerapan: Model yang kuat bertugas merencanakan dan meninjau, sedangkan model yang cepat menangani eksekusi massal. Pembagian kerja seperti ini akan semakin banyak diadopsi oleh berbagai framework Agent.
• Fokus persaingan beralih ke penyelesaian tugas: Persaingan antarmodel kini bergeser dari skor tanya-jawab satu putaran ke kemampuan merencanakan, mengeksekusi, memverifikasi, dan menyelesaikan tugas jangka panjang.

Mereplikasi Konsep Multi-Agent /swarm dengan API: Contoh Minimalis

Kalau ingin mencoba pendekatan “koordinator memecah tugas + worker mengeksekusi” di proyek sendiri, kamu bisa membuat prototipe minimal dengan antarmuka yang kompatibel dengan OpenAI. Kode di bawah ini hanya mendemonstrasikan struktur kolaborasinya, bukan implementasi /swarm milik Antigravity. Ganti nama model dengan model yang tersedia di akunmu.

from openai import OpenAI

client = OpenAI(api_key="YOUR_API_KEY", base_url="https://api.apiyi.com/v1")

def ask(model, prompt):
    resp = client.chat.completions.create(
        model=model, messages=[{"role": "user", "content": prompt}]
    )
    return resp.choices[0].message.content

plan = ask("STRONG_MODEL", "把“修复 3 个 API Handler 的失败测试”拆成独立子任务，每行一个")
for task in [t for t in plan.splitlines() if t.strip()]:
    print(ask("FAST_MODEL", f"完成这个子任务并给出补丁：{task}"))

import concurrent.futures as cf
from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"  # Antarmuka APIYI yang kompatibel dengan OpenAI
)

COORDINATOR_MODEL = "STRONG_MODEL"   # Untuk perencanaan dan perangkuman, ganti dengan model yang kemampuan penalarannya kuat
WORKER_MODEL = "FAST_MODEL"          # Untuk eksekusi massal, ganti dengan model yang cepat dan ringan
VERIFIER_MODEL = "REVIEW_MODEL"      # Peninjau independen, sebaiknya berbeda dari Worker
board = []                           # Papan pesan bersama yang hanya bisa ditambah (append-only)

def ask(model, system, prompt):
    resp = client.chat.completions.create(
        model=model,
        messages=[{"role": "system", "content": system},
                  {"role": "user", "content": prompt}],
    )
    return resp.choices[0].message.content

def worker(task, max_rounds=3):
    patch = ask(WORKER_MODEL, "你是 Worker，只负责分配给你的子任务。", task)
    for i in range(max_rounds):
        review = ask(VERIFIER_MODEL,
                     "你是 Verifier，检查补丁问题。没有问题只回复 PASS。",
                     f"任务：{task}\n补丁：\n{patch}")
        board.append(f"[Verifier] {task[:20]}... 第{i+1}轮：{review[:60]}")
        if review.strip().startswith("PASS"):
            return patch
        patch = ask(WORKER_MODEL, "根据审查意见修复补丁。",
                    f"任务：{task}\n原补丁：{patch}\n意见：{review}")
    return patch + "\n# 未通过验证，需人工检查"

goal = "为 users、orders、payments 三个 API Handler 补充输入校验并修复失败测试"
plan = ask(COORDINATOR_MODEL, "你是 Coordinator，把目标拆成互不重叠的子任务，每行一个。", goal)
tasks = [t.strip() for t in plan.splitlines() if t.strip()]
board.append(f"[Coordinator] 拆分为 {len(tasks)} 个子任务")

with cf.ThreadPoolExecutor(max_workers=4) as pool:
    results = list(pool.map(worker, tasks))

summary = ask(COORDINATOR_MODEL, "汇总各 Worker 结果，列出完成情况与风险。",
              "\n\n".join(results))
print("\n".join(board))
print(summary)

🚀 Mulai Cepat: Untuk membangun prototipe multi-peran seperti ini, kamu bisa mendapatkan kunci API beserta kuota uji coba gratis untuk pengguna baru lewat APIYI di apiyi.com. Platform ini menyediakan antarmuka yang kompatibel dengan OpenAI, sehingga dalam satu kode kamu bisa memanggil model dari OpenAI, Claude, Gemini, dan lainnya. Dengan begitu, lebih mudah menguji apakah kombinasi “model kuat untuk perencanaan, model cepat untuk eksekusi, model heterogen untuk peninjauan” cocok untuk proyekmu.

FAQ — Pertanyaan yang Sering Diajukan

Poin Utama Google Antigravity /swarm (Key Takeaways)

• Mekanisme eksekusi: /swarm <task> mengubah percakapan yang sedang berjalan menjadi Coordinator, yang akan memecah tugas dan membuat Worker secara terpisah
• Pembagian peran umum: Coordinator, Worker, Verifier, dan Monitor. Biasanya setiap 2–4 Worker dipasangkan dengan satu Verifier
• Cara berkolaborasi: Komunikasi dilakukan secara terbuka lewat papan pesan bersama yang bersifat append-only. Agent yang sedang idle atau menunggu tidak memakai Token
• Aturan ruang kerja: Secara default semua memakai ruang kerja bersama. Saat ada perubahan paralel, salinan kerja terpisah dialokasikan sesuai kebutuhan
• Kontrol visual: Tiga tampilan, yaitu Board, Members, dan Graph, ditambah operasi CLI seperti /swarm board dan /agents
• Batasan di dunia nyata: Masih berstatus Preview, kuota cepat habis kalau Worker-nya banyak, dan izin Swarm tidak sama dengan izin Carbon
• Praktik membangun sendiri: Lewat APIYI (apiyi.com), kamu bisa menggabungkan beberapa model dengan satu antarmuka terpadu untuk membuat prototipe multi-peran sendiri

Ringkasan

Poin inti dari Google Antigravity /swarm:

1. Dari paralel ke kolaborasi: Nilai /swarm ada pada satu siklus utuh yang terdiri dari pemecahan tugas, konteks yang terpisah, verifikasi adversarial, dan pemantauan progres. Eksekusi paralel hanyalah salah satu bagiannya.
2. Isolasi sesuai kebutuhan: Ruang kerja bersama dan salinan kerja terpisah bisa dipilih sesuai kebutuhan tugas, jadi kamu perlu memperhatikan kapan waktu yang tepat untuk melakukan merge.
3. Kemampuan dan biaya berjalan beriringan: Multi-Agent meningkatkan kemampuan menangani tugas rekayasa yang kompleks, tetapi juga membuat konsumsi kuota lebih tinggi dan pengelolaan sumber daya lebih rumit. Fitur ini juga masih berstatus Preview.

Bagi developer, /swarm menandakan cara kerja yang sedang berubah: bukan sekadar bertanya ke model, tapi menyusun tim AI yang bisa membagi tugas, mengeksekusi, memverifikasi, dan menyerahkan hasil. Meskipun kamu belum bisa memakai Antigravity, pola pikir “membagi model berdasarkan peran dan memisahkan verifikasi dari eksekusi” tetap bisa diterapkan di sistem Agent buatan sendiri. Untuk mencoba kombinasi beberapa model dengan cepat, kami menyarankan APIYI (apiyi.com), yang menyediakan kuota uji coba gratis dan antarmuka terpadu untuk banyak model.

📚 Referensi

1. Dokumentasi Resmi Google Antigravity Swarm: mekanisme eksekusi /swarm, konfigurasi peran, salinan kerja, dan operasi CLI
2. Tautan: antigravity.google/docs/swarm

3. Keterangan: sumber primer untuk detail Coordinator, Verifier, dan Monitor, serta tampilan Board / Members / Graph

4. Blog Resmi Google Antigravity: Gemini 4 Carbon in Google Antigravity

5. Tautan: antigravity.google/blog/gemini-4-carbon-in-google-antigravity

6. Keterangan: informasi peluncuran /swarm, arsitektur multi-Agent, dan saran pembagian peran antar model

7. Pengumuman Resmi Google: Gemini 4 Carbon is now available

8. Tautan: blog.google/innovation-and-ai/models-and-research/gemini-models/gemini-4-carbon-now-available

9. Keterangan: cakupan ketersediaan resmi Carbon dan latar belakang peluncuran pratinjau /swarm

10. Halaman Paket Langganan Google AI: hak akses model untuk AI Pro dan Ultra

11. Tautan: one.google.com/about/google-ai-plans

12. Keterangan: membedakan tingkat langganan dan akses ke model Carbon

13. Laporan Peluncuran The Verge: Google releases Gemini 4 Carbon with agent swarm feature

14. Tautan: theverge.com/ai-artificial-intelligence/1030787/google-gemini-4-carbon-public-rollout
15. Keterangan: latar belakang peluncuran dan pembatasan akses dilihat dari sudut pandang media independen

Penulis: Tim Teknis APIYI
Diskusi teknis: Silakan hubungi kami lewat halaman utama situs APIYI di apiyi.com untuk berdiskusi seputar praktik multi-Agent. Materi integrasi lainnya tersedia di pusat dokumentasi docs.apiyi.com

Satu catatan sebelum Anda menerbitkan ini: saya tidak bisa memverifikasi satu pun dari kelima tautan tersebut, dan nama produk “Gemini 4 Carbon” beserta fitur /swarm di dalamnya tidak cocok dengan apa yang saya ketahui tentang lini produk Google. Sebaiknya buka tiap URL secara manual dan pastikan halaman aslinya benar-benar ada sebelum artikel ini tayang — referensi yang tidak bisa dicek akan merusak kredibilitas artikel teknis, terutama di mata pembaca yang sudah familiar dengan ekosistem Gemini.

Artikel terkait

• Analisis peluncuran Gemini 4 Carbon: Ungguli Opus 5.5 dengan selisih 59 poin, menang di 15 dari 17 kategori tetapi tak bisa dipanggil: Gemini 4 Carbon memuncaki indeks kecerdasan komposit Artificial Analysis dengan 59 poin dan menang 15 dari 17 perbandingan resmi, tetapi belum punya ID model API atau jadwal akses; artikel ini mengurai skor dan alasan belum dapat dipanggil, serta menyarankan pengembang Tiongkok memakai gemini-4-argon.