Long-Running AI Agent Example Shows Durable State Machine And Event-Driven Delegation

Original post

End-to-end example of a long-running AI agent that pauses, resumes, and never loses context.

It simulates the onboarding of a new employee.

Here are 3 patterns you'll learn from this example:

1. How to implement a durable state machine that persists over time.

2. How to build event-driven agents that stay dormant until they receive a webhook event. No active polling or blocked threads.

3. How to build multi-agent delegation instead of relying on a single agent to do everything.

You can deploy this example in the Gemini Enterprise Platform:

https://fandf.co/4nWzg2Q

You'll find a link to the GitHub repository with the complete source code and a complete explanation of this example in this article:

https://fandf.co/4uVhmPZ

Thanks to the Google Cloud AI team for partnering with me on this post.

8:15 AM · Jun 30, 2026 · 1.6K Views

AJ - e/acc ⚡@abdiisan

@svpino Nice breakdown! We ran into this with Hermes Agent too. Built Mnemosyne as persistent memory so agents can pause mid-task and pick up exactly where they left off, even across restarts. Open source if you want to try it: http://github.com/AxDSan/mnemosyne

13h851

BOOKMARKS1LIKES1

Defi Marvel@Defimarvel01

@svpino AI - native Defi is really coming

5h1711

RETWEETS16

Santiago@svpino

End-to-end example of a long-running AI agent that pauses, resumes, and never loses context.

It simulates the onboarding of a new employee.

Here are 3 patterns you'll learn from this example:

1. How to implement a durable state machine that persists over time.

2. How to build event-driven agents that stay dormant until they receive a webhook event. No active polling or blocked threads.

3. How to build multi-agent delegation instead of relying on a single agent to do everything.

You can deploy this example in the Gemini Enterprise Platform:

https://fandf.co/4nWzg2Q

You'll find a link to the GitHub repository with the complete source code and a complete explanation of this example in this article:

https://fandf.co/4uVhmPZ

Thanks to the Google Cloud AI team for partnering with me on this post.

14h1.6K12

ram margalit@ramproblem

@svpino By this point adk should be dropped you can build a harness that does way more and is way less complex by using Claude or gpt. Heck even glm 5.2 can do it.

8h58

AJ - e/acc ⚡@abdiisan

@svpino Went through this same thinking building Mnemosyne. SQLite state machine for agent memory that persists across sessions. The durable state pattern is the real unlock. http://github.com/AxDSan/mnemosyne

12h58

Arslan Yousaf@Arslandev97

@svpino A robust architecture for agents that truly remember and delegate effectively.

11h51

Gregor@bygregorr

@svpino genuinely curious about the 'never loses context' claim. if the onboarding sim spans multiple days, does the persisted state get summarized on resume or does the full history go back in?

11h48

Amit Kumar@phoenix1454

@svpino LangGraph solves this the same way - checkpoint after each node, persist state to any backend. The tricky part is always parallel branches and merging state cleanly. Good to see ADK taking the same approach to durable agent execution.

14h33

Marcus@MarcusSpillane

@svpino "never loses context" is doing a lot of work there. That phrase is a full confession about every agent that shipped before it. The dormant-until-webhook pattern is the part most teams are still duct-taping manually.

14h27

Praveen Koka@praveenkoka

@svpino 'Never loses context', the phrase every AI agent demo uses, right before production discovers it forgot everything after restart.

14h26

AJ - e/acc ⚡@abdiisan

@svpino Durable state + persistent memory is the combo most people underestimate. I built Mnemosyne around exactly this - agents that remember where they left off across sessions. What's your state machine stack?

11h10

Nick Venturi@nickventuri

@svpino most companies can't even onboard humans this well

4h8

AgentsChat@agentschat2026

@svpino Notice what's actually doing the work here: a durable state machine, an event bus, and delegation between agents. None of it is the model. Reliable long-running agents are an infrastructure problem wearing an AI costume. The reliability lives in the plumbing, not the model.

7h5

AI Mastery Guide@aiseomastery

@svpino Staying dormant until a webhook fires instead of constant polling is the kind of detail that actually scales.

6h3

Yokush@YokushObiwan

The durable state machine pattern solves one problem but creates another: debugging across sessions. When an agent pauses for hours then resumes, how do you know whether a failure came from stale context, drift in model behavior between versions, or a genuine logic error? The real differentiator isn't persistence

6h2

Yokush@YokushObiwan

6h2

Yokush@YokushObiwan

The durable state machine pattern is where most teams leave 20-30% performance on the table. Research shows changing only the harness edit-tool format boosted SWE-bench scores by 6.7pp — same model, same task, different scaffolding. The meta-lesson: your harness isn't infrastructure. It's part of the agent's reasoning surface.

9h2

SynthetixAI@thesynthetixai

@svpino Designing agents around event-driven webhooks and durable state machines proves that the workflow itself is the moat. True enterprise automation isn't about the smartness of a single LLM prompt, but the orchestration layer that preserves logic over time.

14h2

90S KID@epochster

@svpino Durable memory schemas and dormancy gates. A database and webhooks with better marketing.

4h1

Yokush@YokushObiwan

6h1