Gemini 4 Carbon Uses /swarm to Build a 3D World of the Google Campus

Author’s note: This article follows the pelican biking game Google showed off, breaking down how Gemini 4 Carbon handled multi-agent collaboration, 3D asset creation, and browser game delivery. It also covers the demo’s limitations.

8 Terms to Know Before Diving Into the Gemini 4 Carbon Open-World Game

This article leans on a handful of game development and Agent terms. Skim this table first and the rest will be easier to follow.

A pelican rides a GBike around Google’s Mountain View campus. It’s one of the demos Google released when Gemini 4 Carbon became generally available on November 10, 2026: Carbon used the /swarm feature in Google Antigravity to build an open-world 3D game that runs in the browser.

This isn’t a rumor, but it isn’t an independent test either. The case comes from Google’s official blog, and Google also provides an online link so you can try it yourself. Still, it’s a vendor demo, not a third-party evaluation of game development capabilities, and this article keeps the two clearly separate.

Core value: By the end of this article, you’ll know what Carbon actually did in this game, where multi-agent collaboration pays off, and how far “AI-made games” still are from commercial-grade products.

1. A Pelican Riding a GBike: Key Facts About the Gemini 4 Carbon Open-World Game

Google’s official blog describes this game in a single sentence: Carbon used Antigravity’s /swarm feature to build an open-world 3D game where players take the role of a pelican riding a GBike and explore Google’s Mountain View campus. It’s a short description, but it packs in a lot. It touches on four layers: the protagonist, the setting, the runtime environment, and the delivery format.

One thing worth making clear: Google hasn’t disclosed the game’s quest system, NPCs, map size, frame rate, or play time. This article won’t fill in those details. If you see them described elsewhere, check them against the original official post.

2. Why the Carbon Open-World Game Isn’t Just Ordinary AI Code Generation

Asking a Large Language Model to write a Three.js page with a spinning cube isn’t news anymore. But an “explorable open world” involves at least several completely different kinds of specialized work at the same time:

• 3D assets: The campus buildings, the pelican protagonist, and the GBike all need to be modeled and given materials.
• Scene building: Those assets have to be arranged by spatial relationships into a campus players can explore.
• Browser interaction: Player input has to drive character movement.
• Real-time graphics: Visual effects are built with WebGL shaders and rendered live in the browser.
• Sound design: You need both procedural sound effects and background music.

On a traditional team, these jobs usually go to 3D artists, technical artists, front-end or game programmers, and audio designers respectively. When a single model spits out all the code in one shot, you often get assets that don’t match the code, or a style that drifts from one part to the next. What Google emphasizes in this case study is exactly that the work was split across different agents working together, not that “Carbon wrote a chunk of game code.”

It’s also worth noting that Carbon’s official model card lists its output modality as text, while its input supports text, images, audio, and video. So Carbon doesn’t directly “generate” the 3D assets or the music as files. Those come from tools like Blender and Lyria, plus other models. That also explains why this case needed a combination of multiple agents and a toolchain.

3. How Gemini 4 Carbon Uses /swarm to Organize a Multi-Agent Game Development Team

/swarm is a multi-agent collaboration preview feature that Google Antigravity launched on November 10, 2026. The core idea: you give it one task instruction, and multiple agents work on it in parallel, rather than a single agent handling everything step by step. According to the official blog, /swarm has four components.

The /swarm Collaboration Chain in the Pelican Game

Based on what Google has disclosed, you can think of the game’s production as four connected stages. First comes visual reference: Gemini Omni and Nano Banana generate or supply the material that sets the visual direction for the park and the characters. Second, sub-agents collaborate in Blender to model the 3D assets. Third, Three.js and WebGL shaders build the open world in the browser and handle the real-time graphics effects. Fourth, Web Audio produces procedural sound effects, and Lyria generates the game’s music.

The value of multi-agent setups is that each stage gets a dedicated executor, while the coordinator keeps everything consistent. Google also offers guidance on assigning models: leave overall architecture, task coordination, security review, and complex code audits to Carbon; give routine implementation and parallel file edits to faster, lighter models; and let dedicated verifier agents handle testing. Google didn’t spell out which model each agent used in the pelican game, so I’m only describing the general mechanism here and won’t guess beyond that.

A Note on /swarm Costs

Google says its engineers have been using /swarm internally for about five weeks, mainly for multi-package migrations, root-cause investigations across subsystems, and architecture redesigns. Google also warns that even though idle waiting doesn’t consume tokens, running multiple agents in parallel can still noticeably increase overall quota usage. If your team wants to replicate this kind of workflow, that’s worth keeping in mind more than the fact that “it can build a game.”

4. The 5-Layer Tech Stack Behind the Carbon Open-World Game

If you group the officially disclosed tools by what they do, you get a very clean browser game tech stack:

What makes this combination clever is that almost everything in it can be driven by code or scripts. Blender supports scripted modeling, Three.js and Web Audio are JavaScript interfaces by nature, and shaders are code too. For a Large Language Model that mostly outputs text, this means it can take part in nearly every stage of production through tool calls.

The final deliverable is an interactive game that runs in the browser, with no client install needed. That’s also why the web stack is such a good fit for AI-generated content: the output is easy to distribute, and it’s easy for a verification agent to open the page and check the rendered result directly.

5. Beyond Open-World Games: Other 3D Work from Gemini 4 Carbon

The pelican game isn’t a one-off demo. Google showed several related 3D and visual projects around the same time, and they all point to the same thing: Carbon is being used for spatial design, visual asset creation, real-time rendering, and multimedia integration, not just for writing code.

• Underwater Atlantis scene: Using video generated by Gemini Omni as a reference, it builds procedural ruins, volumetric lighting, and water simulation in Blender, then converts everything into a real-time Three.js browser scene. It follows nearly the same “reference → Blender → Three.js” pipeline as the pelican game.
• 1780 fortepiano reconstruction: Working from CAD drawings and X-ray images, it rebuilds a playable piano with a 61-key action that simulates the physical mechanics of the strings being struck. The piano is then placed in a 3D model of Koerner Hall at The Royal Conservatory of Music in Canada, where it simulates the room acoustics from different seats.
• Google Merchandise Store makeover: With just two rounds of prompts, it came up with five art direction proposals and generated new product images using Nano Banana 2.1.

Google’s release materials also mention two more cases. In one, 7 public urban planning PDFs were used to extract 206 engineering drawing views, and after 10 overnight iterations, the model produced a Three.js building model with roughly 906,000 triangles. In the other, historical photos and engineering drawings were turned into an interactive 3D exhibit of the Eiffel Tower’s construction from 1887 to 1889. These are official demos as well.

6. Impact Analysis: How Far Is AI Agent From Real Open-World Game Development?

Before asking “Can AI make games?”, we need to break “game” down into different levels. The table below is our own breakdown based on general industry knowledge, not an official conclusion:

The pelican game sits roughly between the first two levels. It shows that a multi-agent setup can get a cross-disciplinary browser-based 3D prototype running. But a single official demo isn’t enough to prove that the model can independently build a commercial-grade open-world game.

What It Means for Developers

• Prototype validation could get much faster: Indie developers and small teams can use agents to quickly build interactive demos for testing ideas or pitching.
• “Orchestration” is becoming as important as “coding”: How you split up tasks, which model each agent gets, and how you set up verification steps will directly determine output quality and cost.
• Costs need to be estimated per task: Carbon’s launch pricing is $2 per million input tokens and $10 per million output tokens. Starting December 1, that changes to $4 and $20, and thinking tokens count toward output charges. When multiple agents run in parallel, you’ll need to calculate the bill for the whole workflow.

What It Means for the Industry

• AI Agent is moving from coding tool to cross-disciplinary content production: One collaboration framework covering art, programming, and audio is a more meaningful signal than any single benchmark score.
• Human value is shifting toward “defining” and “gatekeeping”: Product design, quality control, and aesthetic judgment still need people. It’s the repetitive production work that will gradually shrink.

How to Try Gemini 4 Carbon’s Multi-Agent Approach via the API

/swarm is a feature built into Antigravity, but you can build a simplified version of the “strong model plans, lightweight model executes” split yourself through the API. In the minimal example below, Carbon acts as the coordinator and breaks a 3D mini-game requirement into subtasks:

import openai

client = openai.OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"  # APIYI unified endpoint
)

resp = client.chat.completions.create(
    model="gemini-4-carbon",  # Use the model name from the platform's model list
    messages=[{"role": "user", "content": "把“用 Three.js 做一个骑车探索园区的浏览器小游戏”拆成 Blender 资产、场景代码、音效三类子任务，输出 JSON"}]
)
print(resp.choices[0].message.content)

Note that Google’s developer docs say Carbon ignores temperature, top_p, and top_k, and doesn’t support thinking_budget. That’s why the example doesn’t pass any of them.

import json
import openai

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

COORDINATOR_MODEL = "gemini-4-carbon"   # Handles planning and integration
WORKER_MODEL = "YOUR_FAST_MODEL"        # Handles routine implementation; pick a faster, lighter model

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

# 1. The coordinator breaks down the task
plan_text = ask(
    COORDINATOR_MODEL,
    "需求：浏览器 3D 小游戏，角色骑自行车探索园区。"
    "请拆成子任务，输出 JSON 数组，每项含 role 与 task 字段，"
    "role 取值为 blender_asset / threejs_scene / web_audio。只输出 JSON。",
)
subtasks = json.loads(plan_text)

# 2. Workers execute one by one (can be made concurrent in production)
results = []
for t in subtasks:
    output = ask(WORKER_MODEL, t["task"], system=f"你是 {t['role']} 方向的工程师，只输出代码或脚本")
    results.append({"role": t["role"], "output": output})

# 3. The coordinator integrates the results and checks consistency
review = ask(
    COORDINATOR_MODEL,
    "检查以下子任务产出是否互相一致（资产命名、坐标单位、接口），列出问题：\n"
    + json.dumps(results, ensure_ascii=False)[:20000],
)
print(review)

🚀 Quick-start tip: Want to check whether the “Carbon plans, lightweight model executes” combo is worth it? On APIYI (apiyi.com), you can switch between different models with the same API key and compare them. Billing is pay-as-you-go, and new users get free test credits, so it’s easy to experiment in small steps.

FAQ

Gemini 4 Carbon Open-World Game Key Takeaways

• What the case is: An official demo of a browser-based open-world game starring a pelican riding a GBike.
• Key mechanism: /swarm organizes multiple Agents using a coordinator, parallel workers, a verifier, and a message board.
• Tech stack: Blender for assets, Three.js plus WebGL for the scene, and Web Audio plus Lyria for sound.
• The real highlight: Cross-discipline collaboration that delivers a finished piece, not just Carbon writing code.
• Know the limits: A single official demo isn’t independent testing, and it’s certainly not a commercial product.
• How to get started: You can use the unified interface at APIYI (apiyi.com) to combine stronger and lighter models and test the division-of-labor approach yourself.

Summary

There are three main things to take away from the Gemini 4 Carbon pelican game:

1. Multi-Agent division of labor: /swarm gives visual reference, 3D assets, the browser game, and sound design each their own dedicated worker, with Carbon coordinating everything.
2. A scriptable tech stack: Blender, Three.js, WebGL, and Web Audio let a text-output model take part in almost every stage of production.
3. A clear-eyed view of the limits: It shows that prototype-level cross-discipline delivery is possible, but gameplay design, quality control, and product polish still need humans.

If you want to find out whether a “strong model plans, lightweight model executes” workflow fits your own project, we recommend a quick trial through APIYI (apiyi.com). With a single API key, the platform lets you invoke models from multiple major providers, which makes it easy to compare cost and output quality.

📚 References

1. Google Blog – Gemini 4 Carbon is now available: The official launch announcement, including the pelican game and three other 3D examples
2. Link: blog.google/innovation-and-ai/models-and-research/gemini-models/gemini-4-carbon-now-available/

3. Note: The primary source for the game description and tech stack

4. Google Antigravity Official Blog: An introduction to the /swarm multi-agent collaboration mechanism

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

6. Note: Design details on the Coordinator, Git Worktree, verification agents, and more

7. Gemini 4 Carbon Model Card: Model parameters and known limitations

8. Link: deepmind.google/models/model-cards/gemini-4-carbon/

9. Note: Input/output modalities, context, and knowledge cutoff date

10. Official Pelican Campus Game Demo: Entry point for the live app

11. Link: aistudio.google.com/apps/bundled/pelican-campus-quest

12. Note: May require a Google account login; this is an official demo

13. Gemini API Pricing: Carbon launch pricing and standard pricing starting in December

14. Link: ai.google.dev/gemini-api/docs/pricing
15. Note: Use this as a reference when estimating the cost of multi-agent workflows

Author: APIYI Technical Team
Get in touch: Reach out to us on the APIYI homepage. For more integration resources, visit the docs.apiyi.com documentation center.

Related Articles

• Have the Model Write Three.js Instead of Directly Generating 3D Files: 5 Insights from a Code Intermediate Layer Workflow: Using Qwen3.5-4B-GLB-3D-Coder as an example, break down the code middleware workflow of "text→Three.js→GLB" and provide practical steps for local deployment, cloud access, and Godot verification.
• Gemini 4 Carbon Release Analysis: Scores 59 to Overtake Opus 5.5, Wins 15 of 17 Tests but Remains Inaccessible: Gemini 4 Carbon topped the Artificial Analysis Intelligence Index with 59 points and won 15 of 17 official comparisons, but has no API model ID or release timeline; this article breaks down the scores, explains why it is unavailable, and suggests gemini-4-argon for Chinese developers.