โหมด Antigravity swarm ที่ใช้กับ Gemini 4 Neon ทำงานแบบนี้: เลือก Gemini 4 Neon ในตัวเลือกโมเดล พิมพ์ /swarm ตามด้วยงานและวิธีตรวจสอบความถูกต้อง แล้วบทสนทนาของคุณจะกลายเป็นตัวประสานงาน Neon จะแบ่งงานให้ worker ที่มีชื่อแต่ละตัว เพิ่ม @verifier และรายงานผลกลับมาเมื่อเทสต์ผ่าน ขอ worker เป็น Gemini 4 Hydrogen ในพรอมป์เพื่อประหยัดโควตาของคุณ
Antigravity swarm mode กับ Gemini 4 Neon คืออะไร?
/swarm เป็นคำสั่งตัวอย่าง (preview) ใน Google Antigravity ที่รันทีมเอเจนต์ที่มีชื่อหลายตัวบนงานเดียว บทสนทนาปัจจุบันของคุณจะกลายเป็นตัวประสานงาน: แบ่งงาน สรุปงานให้ worker แต่ละตัว เพิ่ม verifier ที่อ่าน diff และรันเทสต์ และรายงานผลกลับมาให้คุณ เมื่อเลือก Gemini 4 Neon ไว้ Neon จะเป็นตัวประสานงาน
Google เปิดตัว Neon เมื่อวันที่ 18 พฤศจิกายน 2026 พร้อมคำอธิบายว่าทำหน้าที่ “เป็น Orchestrator ที่รวดเร็วและมีวิจารณญาณสูง คอยกำกับ subagent ของ Hydrogen ที่ทำงานขนานกันใน Google Antigravity” ดีโมตอนเปิดตัวสองรายการ คือชิ้นงาน bench ห้องแล็บ 3 มิติที่สร้างผ่าน Blender MCP และงานสร้างห้องทำงานของ Alan Turing ในปี 1936 แบบ 3 มิติ ล้วนสร้างด้วย /swarm
สำหรับข้อมูลพื้นฐานของโมเดล อ่านบทความ Gemini 4 Neon คืออะไร ส่วนฟีเจอร์ตอนเปิดตัวพร้อม Carbon ดูได้จากบทความ อธิบาย Google Antigravity /swarm ของเรา ขั้นตอนด้านล่างนี้มาจากเอกสารของ Google และ swarm ยังอยู่ในช่วง preview ดังนั้นเมนูต่าง ๆ อาจเปลี่ยนแปลงได้
ใครใช้ /swarm กับ Gemini 4 Neon ได้บ้าง?
คุณต้องมีแพลน Google AI Pro หรือ Google AI Ultra นี่คือสิ่งที่แต่ละแพลนได้รับใน Antigravity ตามเอกสาร Choose a model:
| ฟีเจอร์ | Free และ Google AI Plus | Google AI Pro | Google AI Ultra |
|---|---|---|---|
คำสั่ง /swarm |
ไม่ได้ | ได้ | ได้ |
| Gemini 4 Neon | ไม่ได้ | ได้ (แพลนแบบเสียเงิน หรือทดลองใช้บนอุปกรณ์พรีเมียมที่รองรับ) | ได้ |
| Gemini 4 Hydrogen | ไม่ได้ | ได้ (เฉพาะสมาชิกแบบไม่ใช่ช่วงทดลอง) | ได้ |
| Orchestrator (Neon) | ไม่ได้ | ได้ (แพลนแบบเสียเงิน หรือทดลองใช้บนอุปกรณ์พรีเมียมที่รองรับ) | ได้ |
| รีเฟรชโควตา | รายสัปดาห์ | ทุก 5 ชั่วโมง จนถึงขีดจำกัดรายสัปดาห์ | ทุก 5 ชั่วโมง ขีดจำกัดรายสัปดาห์สูงสุด |
มีสามเรื่องที่คนมักสับสน:
- Neon เป็นค่าเริ่มต้น ในแพลนที่รวม Neon ไว้ Neon จะอยู่บนสุดของตัวเลือกโมเดลและเป็นค่าเริ่มต้นสำหรับบทสนทนาใหม่ เว้นแต่คุณเลือกโมเดลอื่นไปแล้ว
- คอนเท็กซ์ใน Antigravity จะเล็กกว่า API ให้หน้าต่าง 1M token แต่เอกสารของ Antigravity ระบุ Neon ไว้ที่ “สูงสุด 512K token”
- Swarm เปลืองโควตาเร็วมาก เอกสารของ Google เตือนว่า “worker แต่ละตัวเป็นเอเจนต์ของตัวเอง ดังนั้น swarm ใช้โควตาเร็วกว่าบทสนทนาเดียวมาก” ผู้ใช้ Pro และ Ultra เปิดใช้ AI credit overages ในการตั้งค่าได้หากโควตาหมด
/swarm ทำงานบนโควตาการสมัครสมาชิกของคุณ ไม่ใช่ API key สำหรับอัตราค่าบริการ API ของ Neon ดูคู่มือราคา Gemini 4 Neon ของเรา
วิธีรัน /swarm กับ Gemini 4 Neon ทีละขั้นตอน
ขั้นตอนใน Antigravity App มีดังนี้:
- เปิดโปรเจกต์ของคุณแล้วเริ่มบทสนทนาใหม่
- เลือก Gemini 4 Neon ในตัวเลือกโมเดลใต้กล่องพรอมป์ เลือก Gemini 4 Neon ธรรมดา ไม่ใช่ Orchestrator (Neon) เหตุผลอยู่ด้านล่าง
- เลือกระดับ thinking Neon มีให้เลือก Low, Medium, High (ค่าเริ่มต้น) และ Extra ระดับ High เป็นจุดเริ่มต้นที่เหมาะสำหรับตัวประสานงาน
- พิมพ์
/swarmแล้วกด Tab (หรือ Enter) เพื่อแทรกคำสั่ง - อธิบายงานและวิธีตรวจสอบ เช่น:
/swarm Add input validation to the handlers in src/routes/users.ts and src/routes/orders.ts, add tests next to each, and have a verifier run npm test. - เปิดหน้าต่าง Swarm จากลิงก์ “Open the Swarm UI” ท้ายคำตอบของตัวประสานงาน
- คุยกับตัวประสานงานต่อได้เรื่อย ๆระหว่างที่ swarm ทำงาน สอบถามสถานะหรือปรับขอบเขตงานได้ตลอดเวลา
แท็บ Board, Members และ Graph ในหน้าต่างนั้นแสดงโพสต์แบบเรียลไทม์ สถานะและโมเดลของ worker แต่ละตัว และว่าใคร mention ใคร

ใน Antigravity CLI
ขั้นตอนในเทอร์มินัลแทบจะเหมือนกัน เริ่ม CLI โดยเลือก Neon ไว้:
agy --model gemini-4-neon
# or, for the deepest reasoning on the coordinator:
agy --model gemini-4-neon-xhigh
พิมพ์ /swarm กด Tab แล้วอธิบายงาน เปิดบอร์ดแบบเรียลไทม์ด้วย /swarm board หรือ Alt+S (บน macOS ใช้ได้เฉพาะเมื่อเทอร์มินัลส่งปุ่ม Option เป็น Meta) ดูรายชื่อ worker ด้วย /agents และส่งข้อความถึงตัวใดตัวหนึ่งโดยตรง เช่น @verifier also run the integration tests
Neon เป็นตัวประสานงาน Hydrogen เป็น worker: วิธีผสมโมเดล
โดยค่าเริ่มต้น worker ทุกตัวจะใช้โมเดลเดียวกับบทสนทนาของคุณ เลือก Neon แล้วคุณจะได้ swarm ที่เป็น Neon ทั้งหมด: เก่งแต่เปลืองโควตา
โพสต์เปิดตัวของ Neon บรรยายรูปแบบที่ต่างออกไป: Neon ทำหน้าที่ตัดสินงาน ส่วนเอเจนต์ Gemini 4 Hydrogen ที่เร็วกว่าเป็นคนลงมือทำ Antigravity ให้คุณขอแบบนั้นด้วยภาษาธรรมชาติได้ เอกสารระบุว่า “หากต้องการใช้โมเดลอื่นสำหรับ worker ตัวใดตัวหนึ่งหรือทุกตัว ให้ระบุไว้ในพรอมป์” โมเดลนั้นต้องเป็นโมเดลที่คุณเลือกได้ในตัวเลือกโมเดลของคุณ
ตัวอย่างพรอมป์ที่กำหนดการแบ่งงานแบบนี้:
/swarm Build the /users and /orders endpoints described in openapi.yaml.
Give each resource its own worker and run every worker on Gemini 4 Hydrogen.
Keep the verifier on Gemini 4 Neon. The verifier must run the API tests
and send each failure back to the worker that owns the endpoint.
ทำไมไม่ใช้ Orchestrator (Neon)?
Orchestrator (Neon) เป็นตัวเลือกในตัวเลือกโมเดลที่จับคู่ Neon เป็นผู้วางแผนกับ Hydrogen เป็นผู้ลงมือทำภายในเอเจนต์เดียว เอกสารพูดตรง ๆ ว่า “Orchestrator ใช้เอเจนต์เดียวในบทสนทนาของคุณ” มันรันด้วยคอนฟิกคงที่ คุณจึงตั้งระดับ thinking ไม่ได้ และเอกสารเรื่อง swarm ของ Google ไม่ได้บอกว่า swarm จะทำงานอย่างไรเมื่อ Orchestrator เป็นโมเดลของบทสนทนา
ดังนั้นให้เลือกตามรูปแบบของงาน:
| สิ่งที่คุณต้องการ | ให้เลือก |
|---|---|
| เอเจนต์เดียว Neon วางแผน Hydrogen ลงมือทำ ใช้โควตาน้อยกว่า | Orchestrator (Neon) |
| หลายเอเจนต์ทำงานขนานกันบนไฟล์แยกกัน พร้อม verifier | Gemini 4 Neon + /swarm |
| ให้ Neon ตัดสินใจทุกขั้นตอน ปรับระดับ thinking ได้ | Gemini 4 Neon โดยไม่ใช้ swarm |
คู่มือ Gemini 4 Hydrogen Orchestrator ของเราอธิบายวงจรส่งงานต่อแบบเอเจนต์เดียวอย่างละเอียด
ตัวประสานงานควรใช้ระดับ thinking แบบไหนของ Neon?
เริ่มที่ High Google ระบุว่า Neon ที่ระดับ High มีต้นทุนต่องานต่ำกว่า Carbon ถึง 32% ในขณะที่ยังได้คะแนนสูงบน Artificial Analysis Intelligence Index คะแนนสูงสุดของมัน (61 อันดับ #3) ได้มาที่ระดับ Extra High
เลื่อนไป Extra (xhigh) เมื่อตัวประสานงานแบ่งงานพลาดซ้ำ ๆ เช่นจับ worker สองตัวแก้ไฟล์เดียวกัน และให้ลด worker ลงเป็น Hydrogen ก่อนที่จะลดตัวประสานงานลงเป็น Medium เพราะหน้าที่ของมันคือการตัดสินใจ ไม่ใช่การพิมพ์โค้ด ดูการถ่วงน้ำหนักทั้งหมดได้จาก คู่มือระดับ thinking ของ Gemini 4 Neon ของเรา
เขียนพรอมป์ /swarm ให้แบ่งงานได้สะอาด
เอกสาร swarm ของ Antigravity ให้กฎเดียวที่สำคัญกว่าทุกอย่าง: ระบุว่าคุณต้องการอะไรและจะตรวจสอบอย่างไร แล้วปล่อยให้ตัวประสานงานตัดสินใจวิธีแบ่งงานเอง มีสี่นิสัยที่ช่วยได้:
- ระบุขอบเขตให้ชัด ระบุไฟล์หรือ resource เพื่อให้ worker แต่ละตัวเป็นเจ้าของส่วนของตัวเองโดยลำพัง
- ระบุวิธีตรวจสอบ เช่น
npm test,go test -race ./...หรือการรัน API test ถ้าไม่ระบุ verifier จะได้แค่อ่าน diff - บอกว่าอะไรต้องไม่ถูกแก้ การระบุว่า “ห้ามลบ assertion” ช่วยกันไม่ให้ worker ทำเทสต์อ่อนแอลง
- ขอ working copy เมื่อการแก้ไขซ้อนทับกัน worker แชร์ workspace เดียวกับคุณโดยค่าเริ่มต้น
ใช้ /swarm กับงานกว้าง ๆ ที่แบ่งได้สะอาด สำหรับบั๊กยาก ๆ เพียงตัวเดียว Google แนะนำให้ใช้ /boost ส่วนโปรเจกต์ที่รันเป็นชั่วโมงหรือหลายวัน ให้ใช้ /teamwork
worker ที่รออยู่ไม่ใช้ token จนกว่าจะมีคน mention สมาชิกที่โควตาหมดจะหยุดทำงานและจะไม่เริ่มเองเมื่อโควตารีเฟรช: ให้โพสต์ลงบอร์ด เปลี่ยนโมเดลของมัน หรือส่งข้อความถึงมัน
ให้ verifier ของ swarm ทดสอบ API อย่างจริงจังด้วย Apidog CLI
เมื่อ swarm สร้าง API verifier ที่อ่านแค่ diff ก็แค่เดาเท่านั้น มอบ spec แบบ OpenAPI และเทสต์ที่รันได้ให้มัน “verified” ก็จะหมายความว่า request จริงผ่านตาม contract

Apidog CLI ช่วยให้เอเจนต์ import spec เขียน test case และรันจากเทอร์มินัลพร้อมผลลัพธ์ JSON ที่มัน parse ได้ ตั้งค่าครั้งเดียวในโปรเจกต์:
npm install -g apidog-cli@latest
apidog auth login --with-token <YOUR_TOKEN>
npx -y skills add https://apidog.com # pick your agent when prompted
หรือบอกเอเจนต์ของคุณว่า: “Read https://apidog.com/apidog-cli-installation-guide.md and set up Apidog CLI.” คู่มือนั้นเขียนไว้สำหรับเอเจนต์ ส่วนการตั้งค่าเฉพาะสำหรับ Antigravity ดูที่ วิธีใช้ Apidog CLI ใน Antigravity
จากนั้นเพิ่มขั้นตอนเทสต์ลงในพรอมป์ของ swarm:
/swarm Build the /users and /orders endpoints in openapi.yaml, one Gemini 4
Hydrogen worker per resource. Before building, import openapi.yaml into Apidog
project <projectId> on a new AI branch and create one test case per endpoint
that asserts the status code and response schema. The verifier stays on
Gemini 4 Neon, runs every case against environment <envId>, and treats any
failed run as a failed change, whatever the diff looks like.
verifier จะอ่าน schema ของ payload แต่ละตัวก่อนเขียนอะไรก็แล้ว จากนั้นรันคำสั่งลักษณะนี้:
apidog branch create --project <projectId> --type ai --name "ai/20261119-from-main-neon-swarm" --from main
apidog import --project <projectId> --format openapi --file ./openapi.yaml --branch "ai/20261119-from-main-neon-swarm"
apidog cli-schema get test-case-create
apidog cli-schema validate test-case-create --file case.json
apidog test-case create --project <projectId> --file case.json --branch "ai/20261119-from-main-neon-swarm"
apidog run --test-case <caseId> --project <projectId> --branch "ai/20261119-from-main-neon-swarm" -e <envId> -r cli,json
flag ทุกตัวด้านบนมาจาก apidog <cmd> --help บน Apidog CLI 2.2.12 AI branch ช่วยให้การแก้ไขที่เอเจนต์เขียนไม่ไปอยู่บน main branch ของคุณจนกว่าคุณจะรีวิว ซึ่งสำคัญมากเมื่อ worker หลายตัวแตะ endpoint เดียวกันพร้อมกัน
รายงาน JSON จะระบุ request ที่ล้มเหลว ทำให้ verifier โพสต์ไปที่ @users-api หรือ @orders-api ได้ตรงจุดแทนที่จะใช้ @all เพิ่ม --upload-report เพื่อรีวิวผลรันใน Apidog ภายหลังได้
คำสั่ง apidog run ... -r junit เดียวกันใช้ใน CI ได้เลย contract ที่ swarm ทดสอบก็คือ contract เดียวกับที่ pipeline ของคุณบังคับใช้ ดู Apidog CLI ใน CI/CD pipeline แพลน Free ของ Apidog รองรับผู้ใช้ได้สูงสุด 4 คน
คำถามที่พบบ่อย
Antigravity /swarm ฟรีหรือไม่?
ไม่ฟรี เอกสารของ Google ระบุว่า /swarm ใช้ได้เฉพาะแพลน Google AI Pro และ Google AI Ultra และ Gemini 4 Neon ไม่สามารถใช้ได้ในแพลน Free หรือ Plus ใน Antigravity
worker ของ swarm ใช้โมเดลอะไร?
ใช้โมเดลเดียวกับบทสนทนาของคุณ เว้นแต่พรอมป์จะระบุไว้เป็นอย่างอื่น ขอ worker เป็น Gemini 4 Hydrogen และ verifier เป็น Neon ด้วยภาษาธรรมชาติ โดยใช้โมเดลที่มีในตัวเลือกโมเดลของคุณ
swarm ของ Neon รันเอเจนต์ได้กี่ตัว?
Google ไม่ได้เผยแพร่ขีดจำกัด ตัวประสานงานเป็นผู้ตัดสินใจว่าจะเพิ่ม worker กี่ตัว โดยปกติจะเพิ่ม @verifier หนึ่งตัวต่อ worker สองถึงสี่ตัว บวกกับ @monitor อีกหนึ่งตัว
Neon มีคอนเท็กซ์ 1M token ใน Antigravity หรือไม่?
ตามเอกสารของ Antigravity ที่ระบุ Neon ไว้สูงสุด 512K token ใน Antigravity คำตอบคือไม่ หน้าต่าง 1M ใช้กับ Gemini API เท่านั้น
/swarm เหมือนกับ Orchestrator (Neon) หรือไม่?
ไม่เหมือน Orchestrator (Neon) เป็นเอเจนต์เดียวที่สลับระหว่าง Neon สำหรับวางแผนและ Hydrogen สำหรับลงมือทำ ส่วน /swarm รันเอเจนต์ที่มีชื่อหลายตัวขนานกันบนบอร์ดร่วม พร้อม verifier เฉพาะตัว
