Skip to content
Scaling AI Agents Beyond Solo Use: Persistence, Handoff, and Execution Control

Scaling AI Agents Beyond Solo Use: Persistence, Handoff, and Execution Control

The article explains why deploying AI agents individually doesn't scale to teams, detailing required engineering capabilities: persistent task records and artifacts separate from ephemeral execution environments, execution identity tokens to prevent duplicate writes, granular permission checks for data access and sharing, and revocation handling, illustrated through an invoice reconciliation example and validated via incremental testing.

Data Bricklaying Diary
Data Bricklaying Diary
Data Bricklaying Diary

From Individual Agent to Team-Scale Platform

Giving a single user an AI agent that can browse, write scripts, and process files saves time. The natural next step — giving every employee an agent — introduces systemic problems: dozens of assistants running simultaneously lead to broken environments, mismatched dependencies, lost results, and unclear handoffs. When one person uses an agent, ad‑hoc fixes (installing a missing package, locating a file) are tolerable. In a team setting, relying on maintenance staff to resolve each issue individually does not scale.

The author references an InfoQ article ( 《同一个模型从 30 分到 95 分:拉开差距的不是模型,是 Harness》 ) describing how the QM team evolved from providing each user an isolated agent environment (each with its own machine) to centralizing conversation state in PostgreSQL and provisioning execution environments on demand. The key takeaway: task progress and work artifacts must be reliably persisted, but they do not need to stay bound to the original machine. The specific database or environment allocation strategy depends on the business.

Illustrative Example: Supplier Invoice Reconciliation

A finance staffer asks an agent to read this month’s settlement records, find discrepancies, generate a report, wait for a manager’s confirmation, then submit an adjustment request. The comparison may take minutes, but the manager may only be available the next day. During the wait, must the original machine be kept alive? Can a different environment resume the task? If a colleague takes over, should they see the original quotes or only the discrepancy conclusions? If these questions are not answered, the tooling — no matter how many agents — stalls at the handoff step.

Persist Artifacts, Rebuild Environments on Demand

The execution environment is a sandbox (VM or container) where the agent runs code and handles files. Storing scripts, files, conversations, and progress inside the sandbox works initially, but when a task spans days, changes owners, or moves environments, one must separate what must persist from what can be regenerated:

Task records belong in a database.

Files can use object storage, a file service, or persistent volumes — not necessarily a single store.

For example, Python process variables from yesterday vanish in a new process today. Chat history remains but cannot automatically restore those variables; the agent must re‑run scripts or read saved intermediate results. If rebuild cost is high, a dedicated environment can be kept, but critical progress and artifacts still need an independent, reliable backup. Docker’s volume documentation illustrates this separation: deleting a container preserves volume data. Persistent volumes are viable, yet cross‑environment access and backup must be planned upfront.

Machine Can Change, Yesterday’s Work Must Be Unambiguous

Building on a previous article ( 《Agent 能恢复对话,不等于能恢复任务》 ), the author distinguishes session, task, and business action. When switching machines, the new executor must be able to continue from the record. A vague “80% complete” is useless. Useful records capture:

Which batch of invoices was reconciled.

Which version of settlement data was used.

Where the discrepancy table is stored.

That the report is unconfirmed and the adjustment request not yet submitted.

Files and progress must match: if the task says “discrepancy table generated” but the file is incomplete, the next agent cannot proceed. The author recommends saving files first, then recording file location, inputs, scripts, and rule versions in the task database. The handoff between file storage and task DB must be handled explicitly by code. Approvals are tied to a specific report version; later data or rule changes must not silently reuse the old approval. Whether an adjustment request has been accepted is verified in the business system — changing sandboxes does not make an already‑sent request disappear (see 《Agent 出错以后不能只重试》 for recovery logic).

New Executor Takes Over, Old One Must Stop Writing

If the scheduler loses contact with sandbox A and starts B to take over, A might later recover network connectivity. Both agents could then continue reconciling, updating progress, and preparing to submit adjustments. The system must enforce that only the current executor (B) holds valid write authority . This is done by assigning each execution a unique token, recording the active token in the task, and updating the task version (or transferring a time‑limited execution lease) on handoff. Subsequent progress writes are checked against the current token; updates from the old executor are rejected.

Locking only the progress record is insufficient. If the old process retains credentials and can write directly to the business system, it may bypass the check. Critical write operations must pass through a controlled gateway that verifies the current execution token and permissions, and the business service itself must implement idempotency or duplicate‑submission prevention. Enforcement must be programmatic — not a polite request to the old agent to stop.

Centralized Materials Require Granular Permission Checks

When only one person uses an agent, permission issues are less visible. Once colleagues hand off tasks, access control becomes critical. Finance staffer A may view supplier quotes, but staffer B taking over may not. A private‑chat report must not be broadcast to a group just because the agent is added there. The QM team also observed that agents often misjudge what information can be shared in a given context. After centralizing materials, permission checks must keep pace.

In the invoice example, the system must first verify the current execution identity, confirm which suppliers and time periods it may read, then provide only that data to the model. File downloads and report sends require checking the target user’s or group’s permissions. Summaries count as materials: sensitive numbers from the original quote must not leak into a summary placed in another user’s context. The author includes a diagram illustrating permission checks at read and share time.

Cross‑day tasks must also handle revocation: yesterday’s read access does not guarantee today’s. Historical checkpoints remain for audit, but the next execution must re‑verify current authorization. Unattended tasks need explicit service identities and scoped credentials. Credentials should not migrate with the working directory; the new environment obtains credentials based on current authorization. Revocation must limit or terminate related executions, handle caches, and prevent further external sends.

Platform Investment: Eliminate Repeated Firefighting

The author does not advocate building a full agent runtime from scratch. Generic capabilities (model invocation, tool execution) can be reused. The focus should be on the daily friction points: task recording, file handoff, environment rebuild, and authorization checks.

Small team, short tasks, low rebuild cost → persistent directory + simple progress log may suffice.

Compute‑heavy, long‑rebuild tasks may not suit frequent environment switching.

These responsibilities can start inside a single application.

Incremental Validation with a Read‑Only Verification Task

The author proposes starting with a read‑only reconciliation task and running the following test scenarios:

Interrupt after saving discrepancy table, before updating progress → original artifact recoverable and auditable.

Recycle sandbox while waiting for confirmation, resume in new environment → task, input versions, and report reconnect correctly.

New executor takes over, then old executor recovers → old progress updates rejected; critical writes cannot bypass checks.

Colleague with different permissions views the task → files, summaries, and download endpoints respect access scope.

After adding business write operations, verify that a lost receipt allows recovery of the original adjustment request instead of duplicate submission.

Cost‑Benefit Accounting

Simultaneously measure: how much time is saved on repeated configuration, file searches, re‑explanations, and fault recovery versus the added storage, permission, and platform maintenance costs. The goal is not to shift every individual’s burden onto the platform team. The author judges the investment by a concrete outcome: the next time a colleague takes over invoice reconciliation, they spend less time finding materials and re‑explaining, without calling maintenance to fix the environment.

References

InfoQ, Fu Yuqi & Tina: 同一个模型从 30 分到 95 分:拉开差距的不是模型,是 Harness , 2026‑11‑04. https://www.infoq.cn/article/C1C1DThg8z1Dy0rZAmLB

Docker Official Documentation: Volumes. https://docs.docker.com/engine/storage/volumes/

Original Source

Signed-in readers can open the original source through BestHub's protected redirect.

Sign in to view source
Republication Notice

This article has been distilled and summarized from source material, then republished for learning and reference. If you believe it infringes your rights, please contactadmin@besthub.devand we will review it promptly.

AI agentsteam collaborationpermission controlagent platformexecution environmentagent handofftask persistenceinfrastructure engineering
Reader feedback

How this landed with the community

Sign in to like

Rate this article

Was this worth your time?

Sign in to rate
Discussion

0 Comments

Thoughtful readers leave field notes, pushback, and hard-won operational detail here.