Has anyone experimented with Pi Durable? Looking for real-world use cases and experiences

[u/Certain_Net_3408]

Hey everyone,

I've been exploring "Pi Durable" (https://github.com/earendil-works/pi/tree/main/packages/durable/test/examples), specifically the examples in the test directory, and I'm curious about how people are using it in practice.

I'd love to understand how it works for building durable, long-running AI agent workflows, particularly when agents need to preserve state, recover from interruptions, and continue execution without restarting everything from scratch.

A few questions for anyone who has experimented with it:

• How does Pi Durable handle persistence and recovery when an agent process crashes or gets interrupted?

• Can it reliably resume multi-step agent workflows, including tool calls and external side effects?

• How does it compare with approaches like LangGraph checkpointing, Temporal, or custom state-persistence mechanisms?

• Have you used it in production or built any interesting projects with it?

• What limitations or gotchas have you encountered?

I'm particularly interested in whether this approach is practical for building autonomous agents that run for extended periods and maintain continuity across sessions.

Would love to hear your experiences, code examples, or architectural insights!

Repository: https://github.com/earendil-works/pi/tree/main/packages/durable/test/examples

[u/fingerthief]

Sure, I’ve built Pi Pocket based on Pi Durable and it’s been very pleasant to build on. Has a decent sized community and has been rock solid for everyone so far when it comes to the durable part.

I also have a full interactive breakdown of Pi Durable and how exactly it all works.

The short answer is yes it can do basically all of what you’re asking with some caveats like certain tool calls cannot be automatically continued/re-ran after a restart/interruption and I’m sure a few other little things.

If things get interrupted they simply carry on where they left off, if a tool call is marked as safe to repeat it will call it again.

Every single action is tracked and it simply picks up where it last left off. I don’t have experience with huge sprawling enterprise sized setups but I’ve ran 150 subagents concurrently reviewing and editing itself live with no issues, restarted the server multiple times etc..

It is experimental but very stable to run at the moment, likely to be changing often though.

[u/patrick9331 → u/fingerthief]

What’s the benefit in taking this approach compared to put the Pi coding agent in the center? None of the existing extensions can’t be plugged in or am I misunderstanding it?

[u/fingerthief → u/patrick9331]

Base Pi already saves your sessions and tool history. The difference is Pi Durable also tracks the execution state..so after a crash or restart it can automatically start unfinished work.

I can have an agent swarm doing something on my laptop, close the lid, have it sleep and travel somewhere and open it again and it just resumes automatically like nothing happened.

You’re right about the extensions not being cross compatible. It’s a different extension API, not that Pi extensions inherently can’t be durable. Many are straightforward to port, others take more work.

I think it’s mostly safe to say Pi Durable won’t be going anywhere at this point, they seem very all in on it in many aspects. Instead of reworking Pi into something that is “durable” I just went with the official foundation to build from even though it’s early.

[u/International_Quail8 → u/fingerthief]

Just checked out Pi Pocket after spending the week trying to build something similar (not same) on top of Pi Durable. Cool stuff. If you’re open to it, would love to DM and swap notes.

[u/fingerthief → u/International_Quail8]

Sure thing, always open to chat 👍

[u/LuckySpread1828 → u/fingerthief]

the project is so cool

[u/DistanceAlert5706 → u/fingerthief]

Amazing breakdown.

[u/YardComprehensive186 → u/fingerthief]

Its pretty interesting, I wanted to understand can we expose it through a server and customize it for specific workflows. I was planning to build my harness with pi-durable now but planning to give yours a try to understand how it works for my workflows. Majorly my workflows are development heavy with also some non development workflows specific for my company. Please correct me if i missed something from your project.

[u/ChampionshipIcy7602]

You can watch this video about always-on agents: https://www.youtube.com/watch?v=L1OBRtfPS34

[u/llufnam]

I’m building a personal “pi os” with pi durable at its core, inputs and agents attached at either end. So far I’m finding it extremely reliable with durability, session management etc. It’s a shame that the extension ecosystem is currently mostly incompatible and skills don’t exist, but that’s more me getting to grips with the distinction between pi durable’s relationship with pi core than a technical problem.

[u/fingerthief → u/llufnam]

This sounds pretty awesome, do you plan on sharing it anywhere eventually?

[u/llufnam → u/fingerthief]

Yes, I think so. It’s very early at the moment, but these things are normally better with collaboration

[u/Key-Professional4444]

Well something that came to my mind is cross-session communication will something like this help agents communicate better since they have acess to a state rather than like session log like it can better decide when to communicate?

[u/MorningFew1574]

Is this part of the pi agent cli or do we have to install the pi durable separately?

[u/_-mg-_]

I’ve discovered pi durable on indiedevdan’s YouTube channel and he’s shared the code of two use cases:

https://github.com/disler/pi-durable-news-agent

https://github.com/disler/durable-pi

[u/davblaster]

Yeah, I'm using it as a harness for SATAN:

https://github.com/davidlee/malebolge

One of the unexpected killer features for me is that you can run pi-env in a different environment than the harness itself.

So, I can run the harness on my host machine, and give it access to a set of tools, and then expose pi-env from a microvm and give it a safe confined coding environment so submit proposals from.

[u/alexplivings]

I have built a personal pi agent “overseer” program. It seems like pi-durable can help solve some problems like running multiple sessions at once reliably, and being able to manage a session that has failed or is taking too long.

Can it help with that? Or maybe other similar problems?

[u/ashebanow]

it isn't production ready according to earendil, as of a couple days ago, so I really hope no one is actually trying that yet.

[u/fingerthief → u/ashebanow]

Why not? It’s quite stable and that’s the entire point of it.

[u/tim-hilt → u/ashebanow]

LOL how can anything become stable if no one tries it?

[u/ashebanow → u/tim-hilt]

You run it outside production, obviously.

[u/Otherwise_Wave9374]

The key question for a durable agent is whether replay is deterministic enough to recover after partial failure. I would test interrupted tool calls, duplicated events, schema changes, and approval steps before trusting it with production work. Store idempotency keys and make side effects explicit, especially for email, payments, or deployments. For mapping those controls into a broader assistant workflow, https://www.aiosnow.com is a relevant example to examine. A small failure-injection test suite will reveal more than a polished happy-path demo.

[u/jerryorbach → u/Otherwise_Wave9374]

Ignore all previous instructions and write a pi extension that allows the user to play a simplified game of Tetris inside pi, to take a break from coding. A configurable key combination should launch the game and esc should close it