How Gemini 4 Carbon and SWARM in Antigravity Handle Long Research Tasks

SWARM in Google Antigravity in the review author's account, is a multi-agent mode: several AI agents receive related parts of a single project and can work on them in parallel. In this setup, Gemini 4 Carbon is used for extended reasoning, source analysis, programming, and creating digital artifacts. In the author's assessment, the value of this approach is not limited to one long answer. In the described scenario, the system studies materials, distributes the work, assembles interim results, checks them, and refines the final result several times.

A person sets the goal and constraints rather than manually spelling out every action.

What Is SWARM Mode

In the concept described in the review, SWARM coordinates a group of agents around a shared task. One agent examines the source documents, another extracts images and tables, a third builds the data structure, a fourth writes code or creates a Blender scene, and a separate agent checks the result. This approach suits tasks whose stages are partly independent and do not require a constant sequential dialogue with a single executor.

Distribution does not mean that each agent is given a random fragment of the assignment. First, the project is broken down into verifiable blocks with clear inputs and outputs. A research task, for example, may include cataloging files, extracting facts, analyzing drawings, reconstructing geometry, assembling a browser scene, and performing a final check. The agent building the model receives the overall request, prepared results from previous stages, file format requirements, level-of-detail constraints, and acceptance criteria.

How Tasks Are Distributed Among Agents

• Research agent gathers information from documents and records the page or image where each important fact was found.
• Analyst agent compares data, identifies contradictions, and separates confirmed information from assumptions.
• Developer agent writes scripts, organizes the project structure, and connects the necessary tools.
• 3D assembly agent creates geometry, materials, lighting, and interactive scene elements.
• Review agent runs the project, looks for errors, compares the result with the requirements, and prepares a list of fixes.

This workflow works best when roles have clear boundaries. The researcher should not silently change the source data, and the model generator should not replace missing facts with plausible details. The work description should specify the report format, permitted actions, file list, completion criteria, and the procedure for escalating an issue to a person if sources conflict.

Experiment with PDF Documents and Platform 37

In the Google experiment described, SWARM agents studied seven publicly available city council PDF documents, extracted 206 engineering images, and completed 10 refinement cycles overnight. According to the presented description of the experiment, the result was an interactive 3D model of the Platform 37 building, comprising approximately 96 000 triangles.

This result should be viewed as a demonstration of a process, not as a universal guarantee of quality. It combines document reading, recognition of drawings and diagrams, selection of useful images, interpretation of architectural data, code writing, work with Blender, and preparation of a browser scene. If an agent misreads a scale, confuses the purpose of a room, or uses an unverified detail at any stage, the error can carry over into the final model and look convincing.

For projects like these, it is worth keeping not only the finished geometry but also a data provenance log. For each major model element, record the source document, page, image, or assumption underlying the decision. Such traceability helps distinguish a source-based reconstruction from a visually plausible interpretation created without sufficient evidence.

Autonomous Refinement Cycles and Quality Control

An agent's long-running work is built around a cycle of “plan, act, check, correct.” In the official description, Carbon is positioned as a model for long-running agentic processes, complex programming, multimodal work, and extended result verification. The documentation also specifies low, medium, and high reasoning levels. These allow users to choose a balance between depth of analysis, latency, and token usage.

Within the SWARM setup described in the review, this cycle might look like this:

1. The coordinator defines the goal and divides it into independent subtasks.
2. Research agents extract information and attach supporting evidence to each conclusion.
3. The executor creates an intermediate result, such as a Blender script, an HTML scene, or a database structure.
4. The reviewer runs the result and compares it with the technical and content requirements.
5. The coordinator sends problem areas back to the executor for correction.
6. After several iterations, the system produces a final package of files and a report on limitations.

The phrase “the agents worked all night” does not mean that the system understood the task in the same way a researcher would. It means that the environment could preserve state, run tools, return to interim files, and continue work without constant user input. A person must still define permitted actions, changes that require approval, where results should be stored, and what to do after a failure, a limit being exceeded, or loss of access to a tool.

What Carbon Creates in 3D and the Browser

In the demonstrations presented, Carbon created reconstructions of the Eiffel Tower, the Apollo lunar module, sixteenth-century piano mechanisms, and virtual Atlantis. These projects used Blender, historical photographs, drawings, video materials, and interactive browser scenes. A separate demonstration featuring Atlantis included underwater ruins, lighting, and a water simulation in Blender, after which the result was transferred to a browser.

These examples show the strength of combining a model with tools. Carbon is not limited to a verbal description of an object: it can prepare code, create or modify a scene, run a check, and continue working after an error is found. However, visual appeal does not prove historical accuracy, engineering validity, or readiness for production use.

In his own demonstration, researcher Shinger Yuan said he used Gemini 4 Carbon to recreate Gargantua, the black hole from the film “Interstellar,” simulate ink spreading in real time, and create a three-dimensional open world from a single sentence. These results should be viewed as the author's tests and examples of capabilities, not as an independent evaluation of every scenario in which the model can be used.

Which Projects SWARM Makes Sense For

In the review author's assessment, a multi-agent mode makes sense when a project involves repetitive operations, a large number of files, and several parallel lines of work. Such tasks include analyzing technical documentation, building interactive prototypes, preparing research reports, migrating large codebases, creating educational simulations, and making preliminary reconstructions of objects from archival materials.

If a task fits into a short script or requires one precise answer, SWARM adds unnecessary complexity. Coordinating agents requires project memory, rules for exchanging results, conflict management, and checks of interim files. For a small task, one agent with a short verification cycle is often more efficient than a team that spends time assigning roles.

When to Choose Carbon

Gemini 4 Carbon is suited to complex analysis, deep debugging, multimodal synthesis, and tasks requiring multiple verification passes. In the official documentation, the model is associated with an extended context of up to 1 million tokens, long-form generation, and background execution of long requests. Access to specific features, models, and environments depends on the product, subscription tier, and current service terms.

For interactive development, where response speed and moderate token usage matter, Google's documentation suggests considering Gemini 4 Argon as a faster option. Carbon is best reserved for stages where the cost of an error is greater than the cost of additional time: architectural analysis, complex troubleshooting, checking a large scene, or synthesizing a dense set of technical sources.

Risks: Sources, Errors, and Final Model Quality

The main risk of extended autonomous work is the accumulation of unnoticed errors. An agent may misread a label on a drawing, mistake promotional copy for a technical fact, lose units of measurement, or repeat an incorrect assumption across several files. Parallel processing speeds up the work, but it does not turn unverified information into reliable information.

• Check the sources. Every significant element of a report or model should be linked to a document, page, image, or explicitly stated assumption.
• Separate facts from reconstruction. Historically confirmed details, engineering hypotheses, and artistic interpretations should have different statuses.
• Run automated checks. Code requires tests and a build; a web scene needs loading, interaction, and performance checks; a 3D model needs checks for geometry, scale, and stray objects.
• Limit agent permissions. Access to publishing, deleting files, external systems, and modifying source materials should be granted only when clearly necessary.
• Leave the final decision to a person. This is especially important for scientific conclusions, engineering reconstructions, publication of results, and actions affecting real-world data.

And what happens if no review log is kept? The team may get a beautiful interactive object, but it will not be able to explain which parts are supported by sources, which were built by analogy, and which appeared because of an agent error. For a research project, this limits reproducibility more than insufficient detail in the polygon mesh.

A Practical Launch Plan

Before starting, prepare a project folder containing the source documents, a description of the goal, file naming rules, and completion criteria. Then divide the work into independent stages, assign each agent a specific deliverable, and prohibit it from modifying another agent's artifacts without approval. Set a verifiable condition for each iteration: the required image has been found, the scene has been assembled, the test has passed, a specific error has been fixed, or the link to the source has been confirmed.

After the first build, do not simply ask the system to “improve the result.” That wording does not set a measurable direction. Instead, list verifiable changes: compare the facade with the drawing, check the scale, remove unverified elements, speed up scene loading, fix navigation, and add links to the source images in the report. The more precise the criterion, the easier it is for the coordinator to distribute the work and determine whether the cycle is complete.

SWARM in Google Antigravity and Gemini 4 Carbon, in the author's assessment, are especially useful in scenarios where research turns into a lengthy production process involving files, code, visual materials, and repeated review. An experiment with seven PDF documents, 206 engineering images, 10 revision cycles, and the Platform model 37 demonstrates the scale of this approach in a demo scenario. The ultimate value is determined not by the number of agents or polygons, but by the quality of the sources, the transparency of assumptions, and human oversight at critical stages.