How to Run Multi-Day Persistent Tasks with the Gemini Agent and Subagents

Introduction

Most AI tools are built for one prompt and one answer. A multi-day task is a different kind of work: research that takes days, a model that depends on that research, and a deck that depends on the model. If you hand that whole chain to one agent in one session, you get one long, fragile run that you have to watch. Google’s Gemini agent, announced on October 8, 2026 at the Gemini at Work event, is built for the other shape. You delegate an outcome, the agent plans the work, and temporary subagents handle pieces of it in parallel or in sequence while the main run continues in the cloud. This tutorial shows how to structure that kind of task so it survives the weekend, stays auditable, and ends with work a human has actually checked.

Quick answer

Give the Gemini agent one written outcome with a deadline and a deliverable, split it into parallel research and sequential build steps, give each subagent only the context it needs, and set a spend cap first.

Evidence: what Google actually announced

Start with the facts, because the announcement is easy to over-read. Google Cloud CEO Thomas Kurian introduced the Gemini agent as “your new single, universal agent for work” and summarized the delegation model in one line: “You give it objectives, not instructions. You delegate an outcome and come back to finished work.” The Google Cloud announcement describes four capabilities that matter for multi-day work. First, persistent execution: the agent runs in the cloud, keeps one set of memories and context across devices, and work that takes hours or days keeps running after you close your laptop. Second, multi-agent orchestration: Gemini dynamically creates temporary, job-specific subagents, each with its own identity, and coordinates them across parallel and sequential steps that can run for hours or days. Third, coworker agents: a persistent agent with a defined role gets its own Workspace account, including an email address, calendar, Drive, and presence in the company directory, and only has access to the context the team provides. Fourth, cost controls: real-time, per-project spend caps set in the Cloud Billing Console pause an agent when triggered, and work resumes with a single click.

The scale numbers in the same announcement explain why Google is pitching this to enterprises rather than individuals. As of October 2026, nearly 500 Google Cloud customers each processed more than one trillion tokens over the preceding year, nearly 80% of all Google Cloud customers use its AI products, and nearly 90% of the Fortune 100 use Gemini Enterprise. On the customer side, PayPal routes 10 million multi-model requests every week, and Bradesco cut document review time from one hour to five minutes with Gemini Enterprise. Those figures describe existing Gemini Enterprise adoption, not measured results for the new agent itself, and Google has not published reliability benchmarks for multi-day agent runs. Treat the announcement as a capability description and a pilot invitation, not a performance guarantee.

One more honesty note. Launch coverage describes a tasks inbox that shows the agent’s reasoning, delegated sub-tasks, loaded skills, and code written. That progress view is how you would follow a multi-day run, but Google’s announcement itself does not publish a public interface tour, and access remains gated. The workflow below therefore separates what you control, the brief, the split, the permissions, the cap, and the review, from what the product renders, so it stays useful whether you are in the preview or preparing for it.

Prerequisites

• A Gemini Enterprise relationship or a Google Cloud account team contact, because the agent is not self-serve at announcement time.
• One real multi-day objective with a deadline, not a demo prompt. If the task fits in one sitting, it does not need subagents.
• The source material the task genuinely needs: documents, data, and system access, collected before the run starts.
• A named human reviewer and a named sponsor for the agent’s Workspace identity, if a coworker agent is involved.
• A Cloud Billing project dedicated to the pilot, so the spend cap and the chargeback apply to this work alone.
• A review checklist for outputs: citations checked, numbers recomputed, and claims verified before anything leaves the team.

Step-by-step guide

Step 1: Confirm you can run this, or prepare as if you can

Ask your Google Cloud account team whether your Workspace domain is in the Gemini agent preview, and which plans it covers. If the answer is no, do not wait idly: run the rest of this tutorial as a design exercise with your current agent tooling, and keep the brief, the split, and the review checklist ready. The most common failure in agent pilots is starting a multi-day run with no owner, no cap, and no review step, and discovering all three on day three.

Step 2: Write a one-page outcome brief, not a prompt

A multi-day run needs a document, not a sentence. Write one page with five sections: the outcome (what “done” looks like as a deliverable), the deadline, the sources the agent may use, the constraints (budget, systems it may not touch, people it may not contact), and the acceptance checks (which claims a human will verify). Google’s own example shows the shape: research market trends, build a financial model in Sheets, then create a deck that presents both, without re-explaining the project at each step. Your brief is what makes that handoff possible, because each subagent reads the brief, not your memory of the project.

A good outcome sentence names the deliverable and its audience: “A launch readiness document for the regional marketing team, based on the Q3 pipeline sheet and the three competitor announcements from October, delivered as a Doc by Friday.” A bad one names a topic: “Research competitors.” The first can be checked. The second cannot, and a multi-day agent will fill the gap with its own guesses.

Step 3: Split the work into parallel and sequential lanes

Draw the dependency map before delegating anything. Research lanes run in parallel: one subagent per source set, for example one per competitor, one per market, or one per document set. Build lanes run in sequence: the model cannot be built until the research lands, and the deck cannot be written until the model is checked. Google says subagents can run steps in parallel or in sequence, and your job is to say which steps are which. If two subagents need the same source document, that is fine. If one subagent’s output is another’s input, that is a sequence, and the second subagent must not start until the first subagent’s output passes review.

Keep each subagent’s job small enough to verify in one sitting. A subagent asked to “research the market” returns a wall of text nobody checks. A subagent asked to “extract every pricing change from these five announcements into a table with a source link per row” returns something a human can verify in ten minutes. Small jobs also fail small: when one research lane goes wrong, you redo one lane, not the whole week.

Step 4: Give each subagent only the context it needs

This is the governance step, and Google’s design supports it directly. A coworker agent acts under its own identity rather than yours, and it sees only what you share with it. Apply the same rule to temporary subagents: share the folders, documents, and system connections that one lane requires, and nothing else. A pricing research subagent does not need your HR documents. A deck-writing subagent needs the checked model, not the raw inbox.

For developer teams, the same least-privilege habit has a concrete form today. Skills are reusable instruction sets that teach an agent how to perform a multi-step task, and the Agent Skills open standard defines a skill as a self-contained directory built around a SKILL.md file. Our guide to sharing Gemini skills with your team through a registry shows how a team publishes those skills in Git so every agent run uses the same version. For the enterprise agent, the equivalent is the shared company skills registry Google describes in the announcement: publish the team’s way of doing a task once, and every subagent that needs it loads the same version. Either way, the principle is identical. A subagent should load a reviewed skill, not improvise a method.

Step 5: Set the spend cap before the first run

Open the Cloud Billing Console, pick the pilot’s dedicated project, and set a hard per-project spend limit before delegating anything. Google says Gemini monitors token usage and sandbox costs, pauses the project’s agent when a cap is triggered, and lets you resume with a single click in the console. Set the cap low for the first run: a multi-day task that pauses is an inconvenience, while a multi-day task that burns a month of budget overnight is an incident. Because tracking is per project, the pilot’s cost stays visible separately from production spend, and the department that benefits can be charged back.

Also decide in advance what a pause means. A cap pause is not a failure, and it is not permission to click resume blindly. When a run pauses, review what it spent the budget on, which lanes produced usable output, and whether the remaining work is worth the next tranche. The audit trail, which Google attributes to the agent rather than to a person, only helps if a human reads it at the pause points.

Step 6: Define check-in points, then leave the run alone

A persistent run is valuable precisely because it does not need babysitting, so do not recreate the babysitting with hourly check-ins. Set three check-in points: when all parallel research lanes land, when the sequential build passes its first human review, and at delivery. At each point, the reviewer opens the cited sources for every consequential claim, recomputes at least one number, and either approves the lane or sends it back with a specific correction. Between check-ins, let the run continue in the cloud. The agent keeps one set of memories and context across devices, so you do not need to re-brief it when you switch from laptop to phone, and it does not need you watching to keep working.

If a lane comes back wrong, fix the lane, not the whole plan. Common causes are a vague brief (rewrite the outcome sentence), a missing source (add the document and rerun only that lane), or a skill that does not match the task (publish a corrected skill version and rerun). A lane that cannot be verified in one sitting needs a smaller job, not more agents.

Step 7: Close the run like a project, not a chat

When the deliverable is approved, close three things. First, archive the outcome brief, the lane outputs, and the review notes together, so the next person can see what was claimed, what was checked, and what was corrected. Second, confirm the temporary subagents are retired: they were created for this job, and a job-specific agent should not linger with access after the job ends. Third, review the spend and the audit trail with the sponsor, and decide whether the coworker agent, if one was created, keeps its role or is retired too. Our guide to Gemini industry agents for financial services and legal shows the same close-out discipline in regulated pilots, where matter-level permissions and audit fields are part of the deliverable.

Troubleshooting

The run produces a lot of text but no verifiable deliverable

This is almost always a brief problem, not a model problem. “Research competitors” cannot be checked, so the agent fills pages. Rewrite the outcome sentence to name the deliverable, its audience, and its deadline, then split it into lanes with one checkable output each, such as a table with a source link per row. Rerun one lane with the new brief before rerunning the whole task.

A subagent uses a source it should never have seen

This is a permissions problem. The agent only sees what the team shares with it, so an over-shared folder or an over-broad system connection is the cause. Remove the source from that lane’s context, check the audit trail to see what it accessed, and tell the reviewer which outputs may be tainted. Then fix the sharing rule for the next run: one lane, one source set, reviewed before delegation.

The run pauses at the spend cap halfway through

Treat the pause as a review point, not an error. Open the Cloud Billing Console, check what the spend bought, and approve or reject each completed lane before resuming. If the remaining work is worth it, raise the cap deliberately and note the new limit. If the lanes so far are unusable, do not resume: fix the brief or the skill first, or the next tranche buys more of the same output. For a first pilot, a low cap that pauses early is the system working as designed.

Parallel lanes contradict each other

Contradictions are good news: they mean the lanes actually did independent work. Do not average them. Send both lane outputs to the reviewer with their cited sources, decide which source is authoritative for the deliverable, and record the decision in the review notes. Then add the authoritative source to the brief so the next run does not rediscover the same conflict. If the contradiction comes from different dates on the sources, add a freshness rule to the brief, for example that pricing claims must come from sources dated within the last 90 days.

The deliverable looks finished but nobody can say what was checked

This is the most dangerous failure because it looks like success. Stop the delivery, open the audit trail, and run the review checklist lane by lane: citations opened, numbers recomputed, claims verified. If a lane cannot be checked after the fact, that lane’s output does not ship, no matter how polished it reads. Add the checklist to the outcome brief for the next run, and make the check-in points in Step 6 non-negotiable.

FAQ

The FAQ entries in the front matter answer the questions readers ask first: who can sign up, how subagents differ from coworker agents, what subagents can see, what a spend cap pause means, how to trust an output, and whether the workflow works before preview access arrives.

Conclusion

A multi-day task is a project with a deadline, a budget, and a reviewer, and the Gemini agent’s contribution is to run that project in the cloud while you do other work. Delegate one outcome, split it into parallel research and sequential build lanes, share only the context each lane needs, cap the spend before the run starts, and check the work at defined points. Start with one small multi-day objective, a low spend cap, and a review checklist, and let the second run be bigger than the first.

Frequently asked questions