Practical prompting techniques for multi-hour Gemini 4 Carbon runs: state files, fresh reviewer agents, minimum pass counts, and self-checks.
How do you get Gemini 4 Carbon to run for hours without stopping early? #
You have to prompt for it explicitly. Left to a normal prompt, Gemini 4 Carbon (and most agentic coding models) will hand you a first draft and quit. Getting it to grind for hours or days on a project requires three specific instructions baked into the initial prompt: a minimum number of iterations, a way for the model to check its own work, and a persistent state file it rereads after every context reset. These three elements showed up in every long, successful run demonstrated with the model, from a 3D studio layout to a 20-hour historical reconstruction of a fort.
TL;DR #
- Minimum pass counts matter : asking for “at least 10 iterations” or “100 passes” in the first prompt is what pushes the model past a rough first draft into refined output.
- State files survive context resets : a file on disk holding the current pass number and the biggest open problems lets the agent pick up where it left off every time its working memory clears.
- Fresh reviewer agents catch drift : spinning up a new sub-agent every N passes to score the output “cold,” without seeing the plan or prior reasoning, prevents the model from grading its own work from biased memory.
- Self-built verification tools are a recurring habit : across demos, the model wrote its own frame-by-frame auditing scripts and comparison renderers rather than just patching things by eye.
- It can extend its own tools mid-task : when a 3D engine lacked a needed feature, the agent went into the engine’s source code and patched it, including real bug fixes, to keep the project moving.
- Human review is still necessary : the model’s own scoring system rated a historical fort reconstruction around 5 out of 10 after dozens of passes, and it still needed direct human feedback to catch an animation jitter its own review missed.
Nothing gets lost.
312 apps across 41 teams · all in one place
What is Gemini 4 Carbon and what’s the core claim being tested? #
Gemini 4 Carbon is a recent model from Google positioned as strong enough to run unattended on multi-step engineering tasks for extended periods, according to Google’s own framing. Rather than lead with benchmark scores, independent testing focused on a direct question: can the model actually sustain multi-hour or multi-day autonomous work, and what does it take to get there?
The testing ran inside Antigravity, Google’s agentic coding system, which gives the model access to a file system, code execution, and web search. That combination matters, because several of the more interesting behaviors (writing verification scripts, patching a 3D engine’s source code, running physics simulations on GPU hardware) depend on the model having tools, not just a chat window.
Two capabilities stood out in this testing. First, the model could implement recent research ideas from a single description, such as writing a neural network’s weights directly instead of training it. Second, it could sustain independent research over many hours and build on findings incrementally, as seen in a reconstruction project that ran for roughly 20 hours straight.
How does the state file technique actually work? #
Long-running agent tasks run into a hard limit: the context window, meaning the amount of text the model can hold in working memory at once, eventually overflows on a task that spans many hours. When that happens, the model’s effective memory resets.
The fix demonstrated here is a state file kept on disk that the model writes to and rereads continuously. In the fort reconstruction project, this file tracked the current pass number and a running list of the ten biggest open problems. Every time the model’s context reset, it read the file first, which let it resume work with continuity instead of starting over or drifting from the original plan.
This pattern isn’t specific to Gemini 4 Carbon. It’s a general technique for any long-running agent task regardless of which model is running it: externalize the state that the model can’t keep in its head, and have it check that external record on every cycle.
Why does a fresh reviewer agent matter more than self-review? #
A model reviewing its own output from memory tends to be generous to itself, since it already “knows” what it intended and can rationalize small flaws. The more reliable pattern used across these demos was spinning up a new sub-agent periodically, every 10 passes in the fort project, that receives only the rendered output and reference material, with no access to the plan or the reasoning that produced it.
That reviewer scores the work cold. In the fort reconstruction, this scoring system started at 3 out of 10 (roughly “unrecognizable”) and climbed to about 5 out of 10 after 65-plus passes, with 8 out of 10 described as the threshold for photorealism. The gap between 5 and 8 illustrates that even sustained, well-structured autonomous work takes a long time to close the final quality gap.
Adjuster✕ Export PHI
#4471
12,480 users online
The same self-check habit appeared elsewhere without a formal reviewer role: when the model built a running character animation in a browser-based 3D scene, it wrote its own program to step through the footage frame by frame and flag jumps in movement, rather than just eyeballing a fix.
What happens when the model’s tools can’t do what it needs? #
One of the more notable behaviors was the model extending its own tooling mid-task. For the fort reconstruction, the model was deliberately restricted to a 3D engine released only about a month prior, specifically to test whether it could work with something unfamiliar rather than defaulting to well-documented libraries like Three.js or Blender.
When that engine lacked a capability the project needed, the model went into the engine’s own source code and modified it, making six changes over the course of the run, two of which were genuine bug fixes rather than feature additions. This is a meaningfully different behavior from simply working around a tool’s limits: it means the agent treated the tool stack itself as something it could inspect and repair, not just consume.
Can it do real research, not just generate visuals? #
The fort reconstruction project tested this directly. The target was Kilabalahisar, a fort in Peshawar, Pakistan, chosen specifically for being under-documented in English-language and Western sources. The prompt required the model to build the most realistic replica possible using public sources only, improving across at least 100 passes without asking a single clarifying question.
The first phase of the run involved no 3D work at all. The model logged roughly 30 sources it read through, including colonial-era records from the 1890s and aerial and satellite imagery used to measure wall dimensions. From those sources it reconstructed a building history: the fort rebuilt in mud brick in the 1830s, with the British rebuilding the outer wall after 1849. For sections with no public documentation, the model kept an explicit list of unknowns and labeled corresponding model elements as “inferred” rather than presenting guesses as fact.
That distinction, between documented and inferred, is a useful marker of research discipline in an autonomous agent: it’s a cheap, checkable signal of whether a long unattended run can be trusted.
Does this generalize beyond 3D and visual tasks? #
Yes. The same unattended-operation pattern was tested on a GPU cluster running real computational workloads, not just rendering. One task simulated two colliding galaxies with more than half a million stars under mutual gravitational pull. Before committing to the full simulation, the model ran a single-galaxy test first to confirm the setup was stable, a sanity check a careful engineer would also take.
A second task had the model write a reinforcement learning algorithm from scratch to teach a four-legged simulated robot to walk, going from falling over to running. When reviewing its own output video, the model noticed the robot running off the edge of the simulated floor, extended the floor, and re-rendered. In both cases, the test-small-first and review-your-own-output habits carried over from the visual demos into a purely computational domain, suggesting these are general operating patterns rather than something specific to rendering tasks.
__>__add rate limiting to the API
● Reading src/server.ts
● Editing 3 files
+ import{ limit } from'rate'
- app.use(cors()) ✓ Tests passed · ready for PR
● Live
Approved
Approved
Approved
A separate, smaller experiment pushed in a different direction: writing a neural network’s weights directly, without any training process, based on a recent research concept. Given only the source code for a simple version of Breakout and no tools to test with, the model produced a complete set of weights in a single reply that, when loaded and run, substantially outperformed a trained baseline network from the original research. The same approach failed on a harder game, hitting a reply-length limit on every attempt. The gap illustrates a real constraint: without tools to verify output, the model’s effectiveness depends heavily on task complexity and its single-response size limit.
Is Gemini 4 Carbon worth using for unattended, long-horizon tasks? #
For tasks that can be broken into measurable passes with a check against something concrete (a reference photo, a target behavior, a reference video), the pattern demonstrated here is genuinely useful: specify a minimum iteration count, give the model a disk-based state file, and insert a fresh, memory-isolated reviewer at regular intervals. That combination is what separates a rough first draft from a result refined across dozens of passes. The limits are real, though. Self-review is useful but not sufficient. The fort project’s own scoring system plateaued around the midpoint of its scale after many hours of work, and direct human feedback was still necessary to catch issues the model’s automated review missed, such as jitter in a character animation. Treat autonomous long-running agents as very capable collaborators that need a checkpoint structure and periodic human inspection, not as a fire-and-forget system.
Frequently Asked Questions #
What is Antigravity in the context of Gemini 4 Carbon?
Antigravity is Google’s agentic coding system used to run these tests. It gives the model access to a file system, code execution, and web search, which is what enables behaviors like writing verification scripts, modifying a 3D engine’s source code, and running jobs on external hardware.
How long can Gemini 4 Carbon actually run unattended?
In testing, one project (a historical fort reconstruction) ran for roughly 20 hours continuously without human input, and Google has described the model as capable of running for days on multi-step engineering tasks. Actual duration in practice depends heavily on how the task is structured and whether it includes a minimum pass count.
What is a “state file” in long-running agent tasks?
It’s a file kept on disk that records the agent’s current progress, such as the pass number and the current biggest open problems. The agent rereads this file each time its context window resets, which lets it resume a long task with continuity instead of losing track of prior progress.
Why use a fresh reviewer agent instead of letting the model check its own work?
A reviewer agent that only sees the output and reference material, without the original plan or reasoning, scores the work without the bias of already knowing what was intended. In testing, this cold scoring approach was more reliable than having the model evaluate its own output from memory.
Can this approach work with models other than Gemini 4 Carbon?
The underlying techniques, minimum iteration counts, disk-based state tracking, and periodic independent review, are general patterns for managing long-running agent tasks and aren’t tied to one specific model.