From Stateless to Stateful: 5 Architecture Patterns for Long‑Running Agents

Production workflows that process thousands of insurance claims, run week‑long sales outreach, or perform cross‑system reconciliation cannot fit into a single request‑response round because their execution spans days. Traditional agents are stateless, rebuilding context from the database each interaction, which loses inference chains and confidence signals.

Google announced at Cloud Next 26 that Agent Runtime now supports stateful execution for up to seven days. Building on this, the article organizes five architectural patterns that separate robust production systems from fragile demos.

Pattern 1: Checkpoint‑and‑Resume

Long‑running agents must persist intermediate results to a secure cloud sandbox. By treating the agent as a long‑lived service process, it can write logs and checkpoint files to disk, enabling graceful recovery after failures.

# Pattern 1: Checkpoint-and-Resume

def process_documents(docs, checkpoint_file="state.json"):
    state = load_checkpoint(checkpoint_file) or {"processed": 0, "results": []}
    for i in range(state["processed"], len(docs)):
        try:
            result = agent.analyze(docs[i])
            state["results"].append(result)
            state["processed"] = i + 1
            # Every 30 documents perform a checkpoint
            if (i + 1) % 30 == 0:
                save_checkpoint(checkpoint_file, state)
        except Exception as e:
            save_checkpoint(checkpoint_file, state)  # Save before crashing
            raise e
    return state["results"]

Saving every 30 documents balances persistence overhead with computational cost, allowing the agent to resume from the latest checkpoint.

Pattern 2: Delegated Approval (Human‑in‑the‑Loop)

Many frameworks claim human‑in‑the‑loop support, but implementations often serialize state to JSON and fire a webhook, losing implicit reasoning context and competing with other alerts. This pattern pauses the agent at an approval node, preserving the full execution state—including inference chain, working memory, tool‑call history, and pending actions.

The pause consumes zero compute resources; a cold start later incurs negligible latency.

# Pattern 2: Delegated Approval

@agent.tool
def request_human_approval(action_plan: dict, context: str):
    """Pause agent execution and request human review."""
    approval_id = db.create_approval_request(
        plan=action_plan,
        context=context,
        status="pending"
    )
    # Transfer control back to orchestrator; no compute used until webhook fires
    raise SuspendExecution(
        reason="human_approval_required",
        resume_webhook=f"/api/resume/{approval_id}"
    )

Pattern 3: Memory‑Layered Context

Agents that run for days need more than a session cache; they must retain information from previous sessions, user preferences from weeks ago, and organizational knowledge that does not fit in a single dialogue. The design separates a long‑term Memory Bank from a short‑term Memory Profile used for low‑latency queries.

Governance is essential to avoid memory drift and data leakage when multiple agents share a memory pool. Three core components enforce policy:

Agent Identity : IAM‑like identity that restricts which memory banks and tools an agent may access.

Agent Registry : Service‑discovery record of each agent, its prompt version, and current execution state.

Agent Gateway : API‑gateway‑style gate that evaluates each request, e.g., redacting PII before writing to long‑term storage.

# Pattern 3: Memory-Layered Context

class AgentGateway:
    def __init__(self, identity_provider, policy_engine):
        self.iam = identity_provider
        self.policies = policy_engine
    def write_to_memory_bank(self, agent_id, data):
        # 1. Verify identity
        if not self.iam.can_write(agent_id, "long_term_memory"):
            raise UnauthorizedError()
        # 2. Apply policies (e.g., PII redaction)
        safe_data = self.policies.redact_pii(data)
        # 3. Write to managed storage
        vector_db.upsert(
            collection="memory_bank",
            metadata={"source_agent": agent_id},
            content=safe_data
        )

Pattern 4: Ambient Processing

Not all long‑running agents interact with humans. Ambient agents continuously consume event streams and act autonomously. For example, a content‑moderation agent subscribed to a Pub/Sub topic processes user‑generated content for days, maintaining internal trend state and escalating only when confidence is low.

Policy decisions are kept out of the agent code and reside in the Agent Gateway, allowing a single rule change to affect the entire fleet instantly.

# Pattern 4: Ambient Processing

async def ambient_moderation_agent(pubsub_stream):
    """Run continuously, reacting to events without user prompts."""
    async for event in pubsub_stream.listen("user_content"):
        # Agent evaluates content autonomously
        analysis = await agent.evaluate(event.text)
        if analysis.flagged:
            if analysis.confidence > 0.95:
                # High‑confidence auto‑action
                await api.ban_user(event.user_id)
            else:
                # Escalate edge cases
                await request_human_approval(
                    action_plan={"action": "ban", "user": event.user_id},
                    context=analysis.reasoning
                )

Pattern 5: Fleet Orchestration

In production, agents rarely operate in isolation. A coordinator agent distributes sub‑tasks to specialist agents, each with its own identity, gateway, and registry entry. The example of a sales‑development workflow shows five specialists (Research, Scoring, Draft, Outreach, Reporting) coordinated by a central agent.

Because each specialist is an independent unit, updates can be rolled out to one without affecting the others.

# Pattern 5: Fleet Orchestration

async def coordinator_agent(lead_list):
    results = []
    for lead in lead_list:
        # 1. Research Agent – collect public data
        research = await fleet.call("research_agent", target=lead)
        # 2. Scoring Agent – rank lead
        score = await fleet.call("scoring_agent", data=research)
        if score > 80:
            # 3. Draft Agent – write personalized message
            draft = await fleet.call("draft_agent", context=research, tone="professional")
            # 4. Outreach Agent – send via appropriate channel
            await fleet.call("outreach_agent", lead=lead, message=draft)
            results.append({"lead": lead, "score": score, "draft": draft})
    # 5. Reporting Agent – summarize run
    await fleet.call("reporting_agent", summary=results)

Conclusion

The five patterns illustrate how AI agents move from a purely request‑response model to a structured, stateful, and governed execution model. By separating deterministic checkpointing from probabilistic inference, pausing execution instead of serializing JSON, and enforcing memory access through identity and policy, workflows retain their reasoning chains and can be reliably restored. Production‑grade AI therefore depends less on single‑turn cleverness and more on multi‑day reliability, governance, and coordinated scaling.