Discover what's next in building software with coding agents. Every week, we explore emerging ideas and tools. Podcast hosted by @bkase_ and @christinetyip.
Joined July 2026
- Tweets188
- Following41
- Followers505
- Likes356
Pinned Tweet
Coding agents are getting alarmingly good at finding exploits.
But they also make one of the strongest tools for preventing entire classes of bugs accessible to almost anyone: formal verification.
@poteto's new 'create-formal-verification-skill' is really impressive. It:
- Finds high-value properties in your codebase worth proving
- Chooses the appropriate verification tool
- Sets up verification and check that it's proving the intended property
- Generates a reusable skill so future coding agents can maintain the verification
All without you having to become an expert in formal verification.
HOWEVER, there's an important catch.
With tools like TLA+ and Quint, you're often not proving your actual executable code. You're proving a simplified *model* of it.
And when coding agents keep modifying your implementation, that model can drift out of sync. Your proof might still pass, but you're no longer proving the behavior of the code you're shipping.
There are some really interesting approaches to closing this gap:
1. @VictorTaelin's Bend2 lets your agent write executable code and proofs in the same language. It's built with coding agents in mind. The code you're proving is the code you're running, eliminating the separate-model problem.
2. For state-machine-heavy applications, a more experimental approach is to make states and transitions explicit in the actual application code, then verify temporal logic properties directly against that same executable representation. No separate model to maintain. The challenge is making sure the checker itself is trustworthy.
And we're already seeing formal verification being applied in increasingly ambitious ways:
- @Anthropic used Claude to prove no-crash properties for 239 entry points across 123 open-source libraries, working at the compiled RISC-V code level.
- @HarmonicMath just launched Aristotle for formal verification of C software and Verilog hardware designs, with proofs that can be checked on every commit.
- And with @poteto's skill, individual developers can now start applying formal verification to their own projects without years of specialist expertise.
This could fundamentally change how we build reliable software with coding agents.
If you're thinking of adding formal verification to your coding-agent workflow, it's worth understanding the tradeoffs before you start trusting the proofs that pass the check.
We explored all of this in more detail in our latest Superlinear episode.
🧵👇 Links to Discord, YouTube, Apple Podcasts, and Spotify below.
00:00 Coding agents changed formal verification
02:04 Tests vs. formal verification
06:36 Poteto's formal verification skill
08:16 The catch: verified models drift from your code
12:17 General purpose languages like Bend2
14:28 TLA+ and Quint for state-machines
16:27 Build verification into the application
20:38 Statecharts and experimental TypeScript checker
27:27 Closing thoughts and Superlinear Discord
Superlinear retweeted
listening to youtube.com/watch?v=BB84EzZj… I realize that I'm not the only one that keeps crashing his laptop and ends up in "frozen OS" all the time now due to too many agents doing too much stuff on my laptop
Superlinear retweeted
what I'm most excited about is formal verification becoming part of the agent feedback loop
Coding agents are getting alarmingly good at finding exploits.
But they also make one of the strongest tools for preventing entire classes of bugs accessible to almost anyone: formal verification.
@poteto's new 'create-formal-verification-skill' is really impressive. It:
- Finds high-value properties in your codebase worth proving
- Chooses the appropriate verification tool
- Sets up verification and check that it's proving the intended property
- Generates a reusable skill so future coding agents can maintain the verification
All without you having to become an expert in formal verification.
HOWEVER, there's an important catch.
With tools like TLA+ and Quint, you're often not proving your actual executable code. You're proving a simplified *model* of it.
And when coding agents keep modifying your implementation, that model can drift out of sync. Your proof might still pass, but you're no longer proving the behavior of the code you're shipping.
There are some really interesting approaches to closing this gap:
1. @VictorTaelin's Bend2 lets your agent write executable code and proofs in the same language. It's built with coding agents in mind. The code you're proving is the code you're running, eliminating the separate-model problem.
2. For state-machine-heavy applications, a more experimental approach is to make states and transitions explicit in the actual application code, then verify temporal logic properties directly against that same executable representation. No separate model to maintain. The challenge is making sure the checker itself is trustworthy.
And we're already seeing formal verification being applied in increasingly ambitious ways:
- @Anthropic used Claude to prove no-crash properties for 239 entry points across 123 open-source libraries, working at the compiled RISC-V code level.
- @HarmonicMath just launched Aristotle for formal verification of C software and Verilog hardware designs, with proofs that can be checked on every commit.
- And with @poteto's skill, individual developers can now start applying formal verification to their own projects without years of specialist expertise.
This could fundamentally change how we build reliable software with coding agents.
If you're thinking of adding formal verification to your coding-agent workflow, it's worth understanding the tradeoffs before you start trusting the proofs that pass the check.
We explored all of this in more detail in our latest Superlinear episode.
🧵👇 Links to Discord, YouTube, Apple Podcasts, and Spotify below.
00:00 Coding agents changed formal verification
02:04 Tests vs. formal verification
06:36 Poteto's formal verification skill
08:16 The catch: verified models drift from your code
12:17 General purpose languages like Bend2
14:28 TLA+ and Quint for state-machines
16:27 Build verification into the application
20:38 Statecharts and experimental TypeScript checker
27:27 Closing thoughts and Superlinear Discord
Superlinear retweeted
In today's "overengineering is the new engineering", we can now formally verify everything! So let me propose the insane overengineering version of this...
@poteto's create-formal-verification-skill is so good. Go try it now if you haven't yet. It finds something important to formally verify in your codebase, picks the tool, sets it up, checks it's proving the right thing, and leaves a skill behind so future agents can maintain it.
I've run it on a few of my projects. It takes two seconds.
First, I do think you should learn a little bit about formal verification and the landscape of tools. You don't need to handwrite or even review any checks your agents write, but it will help you steer your agents and you can get more out of @poteto's skill or when you're just steering around your agents.
And for the overengineering part: The way the world works is not fixed. If something bothers you, and it's software, you can vibe it out of existence. The thing that bothers me is that the 'model' you formally prove is usually a different artifact from the application code. Bend fixes this, but when you're proving properties about state machines (aka so much of our software!) you'd typically reach for TLA+ or Quint. With these tools, you have to maintain a second copy of your code (the model you're proving) and hope it stays in sync with your application code. Don't accept that. Bake the temporal logic directly into your application.
Anyway we talk about these things more in the episode.
Coding agents are getting alarmingly good at finding exploits.
But they also make one of the strongest tools for preventing entire classes of bugs accessible to almost anyone: formal verification.
@poteto's new 'create-formal-verification-skill' is really impressive. It:
- Finds high-value properties in your codebase worth proving
- Chooses the appropriate verification tool
- Sets up verification and check that it's proving the intended property
- Generates a reusable skill so future coding agents can maintain the verification
All without you having to become an expert in formal verification.
HOWEVER, there's an important catch.
With tools like TLA+ and Quint, you're often not proving your actual executable code. You're proving a simplified *model* of it.
And when coding agents keep modifying your implementation, that model can drift out of sync. Your proof might still pass, but you're no longer proving the behavior of the code you're shipping.
There are some really interesting approaches to closing this gap:
1. @VictorTaelin's Bend2 lets your agent write executable code and proofs in the same language. It's built with coding agents in mind. The code you're proving is the code you're running, eliminating the separate-model problem.
2. For state-machine-heavy applications, a more experimental approach is to make states and transitions explicit in the actual application code, then verify temporal logic properties directly against that same executable representation. No separate model to maintain. The challenge is making sure the checker itself is trustworthy.
And we're already seeing formal verification being applied in increasingly ambitious ways:
- @Anthropic used Claude to prove no-crash properties for 239 entry points across 123 open-source libraries, working at the compiled RISC-V code level.
- @HarmonicMath just launched Aristotle for formal verification of C software and Verilog hardware designs, with proofs that can be checked on every commit.
- And with @poteto's skill, individual developers can now start applying formal verification to their own projects without years of specialist expertise.
This could fundamentally change how we build reliable software with coding agents.
If you're thinking of adding formal verification to your coding-agent workflow, it's worth understanding the tradeoffs before you start trusting the proofs that pass the check.
We explored all of this in more detail in our latest Superlinear episode.
🧵👇 Links to Discord, YouTube, Apple Podcasts, and Spotify below.
00:00 Coding agents changed formal verification
02:04 Tests vs. formal verification
06:36 Poteto's formal verification skill
08:16 The catch: verified models drift from your code
12:17 General purpose languages like Bend2
14:28 TLA+ and Quint for state-machines
16:27 Build verification into the application
20:38 Statecharts and experimental TypeScript checker
27:27 Closing thoughts and Superlinear Discord
Superlinear retweeted
Formal verification is becoming part of the agent feedback loop.
@Anthropic started formally verifying software at scale, @HarmonicMath launched a tool to formally verify C, and now @poteto's skill lets developers apply formal verification without years of specialist expertise.
Superlinear retweeted
Coding agents are getting alarmingly good at finding exploits.
But they also make one of the strongest tools for preventing entire classes of bugs accessible to almost anyone: formal verification.
@poteto's new 'create-formal-verification-skill' is really impressive. It:
- Finds high-value properties in your codebase worth proving
- Chooses the appropriate verification tool
- Sets up verification and check that it's proving the intended property
- Generates a reusable skill so future coding agents can maintain the verification
All without you having to become an expert in formal verification.
HOWEVER, there's an important catch.
With tools like TLA+ and Quint, you're often not proving your actual executable code. You're proving a simplified *model* of it.
And when coding agents keep modifying your implementation, that model can drift out of sync. Your proof might still pass, but you're no longer proving the behavior of the code you're shipping.
There are some really interesting approaches to closing this gap:
1. @VictorTaelin's Bend2 lets your agent write executable code and proofs in the same language. It's built with coding agents in mind. The code you're proving is the code you're running, eliminating the separate-model problem.
2. For state-machine-heavy applications, a more experimental approach is to make states and transitions explicit in the actual application code, then verify temporal logic properties directly against that same executable representation. No separate model to maintain. The challenge is making sure the checker itself is trustworthy.
And we're already seeing formal verification being applied in increasingly ambitious ways:
- @Anthropic used Claude to prove no-crash properties for 239 entry points across 123 open-source libraries, working at the compiled RISC-V code level.
- @HarmonicMath just launched Aristotle for formal verification of C software and Verilog hardware designs, with proofs that can be checked on every commit.
- And with @poteto's skill, individual developers can now start applying formal verification to their own projects without years of specialist expertise.
This could fundamentally change how we build reliable software with coding agents.
If you're thinking of adding formal verification to your coding-agent workflow, it's worth understanding the tradeoffs before you start trusting the proofs that pass the check.
We explored all of this in more detail in our latest Superlinear episode.
🧵👇 Links to Discord, YouTube, Apple Podcasts, and Spotify below.
00:00 Coding agents changed formal verification
02:04 Tests vs. formal verification
06:36 Poteto's formal verification skill
08:16 The catch: verified models drift from your code
12:17 General purpose languages like Bend2
14:28 TLA+ and Quint for state-machines
16:27 Build verification into the application
20:38 Statecharts and experimental TypeScript checker
27:27 Closing thoughts and Superlinear Discord
Continue this conversation on the Superlinear Discord: superlinear.fm/discord
You can also watch the episode on:
- YouTube: youtube.com/watch?v=yex-Xq0_…
- Apple Podcasts: podcasts.apple.com/gb/podcas…
- Spotify: open.spotify.com/episode/0pn…
- Newsletter: superlinear.fm/#subscribe
Superlinear Discord is now live!
A place to hang out and discuss what's next in building software with coding agents.
Join the Superlinear Society: superlinear.fm/discord
4 things worth building with @pidotdev's Pi Durable + @CloudflareDev Durable Objects:
#1 Durable agents for high-stakes workflows
Pi Durable can identify interrupted operations and avoid automatically replaying unsafe calls. Imagine an agent refunding a customer, then crashing before it gets confirmation. You don't want it refunding the customer twice.
Pi Durable checkpoints each step, recording the intent to execute a tool call and whether it completed. After a crash, it knows which operations were interrupted. Unsafe calls aren't blindly retried, so your app can check whether the payment went through before proceeding.
#2 Shared team agents
Pi Durable + Cloudflare Durable Objects are a great foundation for multiplayer agentic coding.
A Durable Object holds the persistent agent state. Multiple clients can connect to the same session, incoming messages are queued or used to steer the agent, and updates are streamed to everyone.
Imagine an agent picking up a GitHub issue and working on a PR while teammates watch or steer the same conversation from their phones, browsers, or terminals. @pidotdev's shared-chat tutorial demonstrates this.
#3 Agents that run anywhere
@badlogicgames built a Pi Durable Android app that runs the agent harness and stores its state locally on his phone, while model calls happen remotely.
Pi Durable separates agent state from execution, with pluggable storage and execution backends. The harness can run anywhere there's a compatible JavaScript runtime, and its tools can execute on another machine. Your durable agent doesn't need an always-running terminal or cloud server just to preserve the agent's state, the harness can run locally, on a phone, or in the cloud.
#4 Build new tools on top of agent state
This is the one we're most excited about.
Pi Durable persists structured tasks, checkpoints, and interrupted operations. That means you can inspect an agent's execution state without asking the model to reconstruct what happened.
We experimented with putting Pi Durable inside a Cloudflare Durable Object and visualizing its stored state without waking the agent.
Imagine using that data to build:
- Debugging dashboards showing exactly where an agent crashed.
- Reliability metrics showing which tool calls repeatedly fail or need recovery.
- Multiplayer dashboards showing pending tasks, who steered an agent, and when.
The interesting part is that durable execution state becomes a new primitive you can build tools on top of, not just something used for crash recovery.
00:00 What is Pi Durable?
07:06 Idea 1: Durability for high-stake workflows
13:16 How to build with Pi Durable
16:31 Durable storage: local vs. cloud
19:46 Pi Durable + Cloudflare Durable Objects
32:20 Idea 2: Multiplayer agents with shared state
35:01 Idea 3: Running the harness on a phone
37:45 Idea 4: Inspecting persistent agent state
🧵👇 Links to YouTube, Apple Podcasts, and Spotify below.
Superlinear retweeted
Brb switching all my dev workflows to @pidotdev
Just found @mitsuhiko ’s pi extension so we can use claude code subs
Link below
Superlinear retweeted
Pi Durable 🤝Cloudflare
4 things worth building with @pidotdev's Pi Durable + @CloudflareDev Durable Objects:
#1 Durable agents for high-stakes workflows
Pi Durable can identify interrupted operations and avoid automatically replaying unsafe calls. Imagine an agent refunding a customer, then crashing before it gets confirmation. You don't want it refunding the customer twice.
Pi Durable checkpoints each step, recording the intent to execute a tool call and whether it completed. After a crash, it knows which operations were interrupted. Unsafe calls aren't blindly retried, so your app can check whether the payment went through before proceeding.
#2 Shared team agents
Pi Durable + Cloudflare Durable Objects are a great foundation for multiplayer agentic coding.
A Durable Object holds the persistent agent state. Multiple clients can connect to the same session, incoming messages are queued or used to steer the agent, and updates are streamed to everyone.
Imagine an agent picking up a GitHub issue and working on a PR while teammates watch or steer the same conversation from their phones, browsers, or terminals. @pidotdev's shared-chat tutorial demonstrates this.
#3 Agents that run anywhere
@badlogicgames built a Pi Durable Android app that runs the agent harness and stores its state locally on his phone, while model calls happen remotely.
Pi Durable separates agent state from execution, with pluggable storage and execution backends. The harness can run anywhere there's a compatible JavaScript runtime, and its tools can execute on another machine. Your durable agent doesn't need an always-running terminal or cloud server just to preserve the agent's state, the harness can run locally, on a phone, or in the cloud.
#4 Build new tools on top of agent state
This is the one we're most excited about.
Pi Durable persists structured tasks, checkpoints, and interrupted operations. That means you can inspect an agent's execution state without asking the model to reconstruct what happened.
We experimented with putting Pi Durable inside a Cloudflare Durable Object and visualizing its stored state without waking the agent.
Imagine using that data to build:
- Debugging dashboards showing exactly where an agent crashed.
- Reliability metrics showing which tool calls repeatedly fail or need recovery.
- Multiplayer dashboards showing pending tasks, who steered an agent, and when.
The interesting part is that durable execution state becomes a new primitive you can build tools on top of, not just something used for crash recovery.
00:00 What is Pi Durable?
07:06 Idea 1: Durability for high-stake workflows
13:16 How to build with Pi Durable
16:31 Durable storage: local vs. cloud
19:46 Pi Durable + Cloudflare Durable Objects
32:20 Idea 2: Multiplayer agents with shared state
35:01 Idea 3: Running the harness on a phone
37:45 Idea 4: Inspecting persistent agent state
🧵👇 Links to YouTube, Apple Podcasts, and Spotify below.
Superlinear retweeted
Thanks for spreading the good word about Pi Durable @superlinear_fm
4 things worth building with @pidotdev's Pi Durable + @CloudflareDev Durable Objects:
#1 Durable agents for high-stakes workflows
Pi Durable can identify interrupted operations and avoid automatically replaying unsafe calls. Imagine an agent refunding a customer, then crashing before it gets confirmation. You don't want it refunding the customer twice.
Pi Durable checkpoints each step, recording the intent to execute a tool call and whether it completed. After a crash, it knows which operations were interrupted. Unsafe calls aren't blindly retried, so your app can check whether the payment went through before proceeding.
#2 Shared team agents
Pi Durable + Cloudflare Durable Objects are a great foundation for multiplayer agentic coding.
A Durable Object holds the persistent agent state. Multiple clients can connect to the same session, incoming messages are queued or used to steer the agent, and updates are streamed to everyone.
Imagine an agent picking up a GitHub issue and working on a PR while teammates watch or steer the same conversation from their phones, browsers, or terminals. @pidotdev's shared-chat tutorial demonstrates this.
#3 Agents that run anywhere
@badlogicgames built a Pi Durable Android app that runs the agent harness and stores its state locally on his phone, while model calls happen remotely.
Pi Durable separates agent state from execution, with pluggable storage and execution backends. The harness can run anywhere there's a compatible JavaScript runtime, and its tools can execute on another machine. Your durable agent doesn't need an always-running terminal or cloud server just to preserve the agent's state, the harness can run locally, on a phone, or in the cloud.
#4 Build new tools on top of agent state
This is the one we're most excited about.
Pi Durable persists structured tasks, checkpoints, and interrupted operations. That means you can inspect an agent's execution state without asking the model to reconstruct what happened.
We experimented with putting Pi Durable inside a Cloudflare Durable Object and visualizing its stored state without waking the agent.
Imagine using that data to build:
- Debugging dashboards showing exactly where an agent crashed.
- Reliability metrics showing which tool calls repeatedly fail or need recovery.
- Multiplayer dashboards showing pending tasks, who steered an agent, and when.
The interesting part is that durable execution state becomes a new primitive you can build tools on top of, not just something used for crash recovery.
00:00 What is Pi Durable?
07:06 Idea 1: Durability for high-stake workflows
13:16 How to build with Pi Durable
16:31 Durable storage: local vs. cloud
19:46 Pi Durable + Cloudflare Durable Objects
32:20 Idea 2: Multiplayer agents with shared state
35:01 Idea 3: Running the harness on a phone
37:45 Idea 4: Inspecting persistent agent state
🧵👇 Links to YouTube, Apple Podcasts, and Spotify below.
Superlinear retweeted
Omg, I always check out whatever @badlogicgames recommends, and this time WE made it onto his recommended viewing list 😭
Superlinear retweeted
recommended viewing.
4 things worth building with @pidotdev's Pi Durable + @CloudflareDev Durable Objects:
#1 Durable agents for high-stakes workflows
Pi Durable can identify interrupted operations and avoid automatically replaying unsafe calls. Imagine an agent refunding a customer, then crashing before it gets confirmation. You don't want it refunding the customer twice.
Pi Durable checkpoints each step, recording the intent to execute a tool call and whether it completed. After a crash, it knows which operations were interrupted. Unsafe calls aren't blindly retried, so your app can check whether the payment went through before proceeding.
#2 Shared team agents
Pi Durable + Cloudflare Durable Objects are a great foundation for multiplayer agentic coding.
A Durable Object holds the persistent agent state. Multiple clients can connect to the same session, incoming messages are queued or used to steer the agent, and updates are streamed to everyone.
Imagine an agent picking up a GitHub issue and working on a PR while teammates watch or steer the same conversation from their phones, browsers, or terminals. @pidotdev's shared-chat tutorial demonstrates this.
#3 Agents that run anywhere
@badlogicgames built a Pi Durable Android app that runs the agent harness and stores its state locally on his phone, while model calls happen remotely.
Pi Durable separates agent state from execution, with pluggable storage and execution backends. The harness can run anywhere there's a compatible JavaScript runtime, and its tools can execute on another machine. Your durable agent doesn't need an always-running terminal or cloud server just to preserve the agent's state, the harness can run locally, on a phone, or in the cloud.
#4 Build new tools on top of agent state
This is the one we're most excited about.
Pi Durable persists structured tasks, checkpoints, and interrupted operations. That means you can inspect an agent's execution state without asking the model to reconstruct what happened.
We experimented with putting Pi Durable inside a Cloudflare Durable Object and visualizing its stored state without waking the agent.
Imagine using that data to build:
- Debugging dashboards showing exactly where an agent crashed.
- Reliability metrics showing which tool calls repeatedly fail or need recovery.
- Multiplayer dashboards showing pending tasks, who steered an agent, and when.
The interesting part is that durable execution state becomes a new primitive you can build tools on top of, not just something used for crash recovery.
00:00 What is Pi Durable?
07:06 Idea 1: Durability for high-stake workflows
13:16 How to build with Pi Durable
16:31 Durable storage: local vs. cloud
19:46 Pi Durable + Cloudflare Durable Objects
32:20 Idea 2: Multiplayer agents with shared state
35:01 Idea 3: Running the harness on a phone
37:45 Idea 4: Inspecting persistent agent state
🧵👇 Links to YouTube, Apple Podcasts, and Spotify below.
Superlinear retweeted
Pi Durable unlocks much more than just the obvious 'able to recover from crashes' from the definition of durable.
This wasn't obvious to me until I dug into it.
The harness is just some well-defined state plus a little JavaScript to drive it forward.
Put that state in a Durable Object and anyone in the world can wake it up, one message at a time, so multiplayer is basically free.
Perfect crash recovery means you can effectively hot-reload your changes by killing yourself after a change, so you get full malleable software.
And because all the harness state is sitting there as well-specified data, you can inspect what an agent was doing without needing other services to reconstruct all the details.
Yes you get crash safety, but also multiplayer, malleability, and introspection.
4 things worth building with @pidotdev's Pi Durable + @CloudflareDev Durable Objects:
#1 Durable agents for high-stakes workflows
Pi Durable can identify interrupted operations and avoid automatically replaying unsafe calls. Imagine an agent refunding a customer, then crashing before it gets confirmation. You don't want it refunding the customer twice.
Pi Durable checkpoints each step, recording the intent to execute a tool call and whether it completed. After a crash, it knows which operations were interrupted. Unsafe calls aren't blindly retried, so your app can check whether the payment went through before proceeding.
#2 Shared team agents
Pi Durable + Cloudflare Durable Objects are a great foundation for multiplayer agentic coding.
A Durable Object holds the persistent agent state. Multiple clients can connect to the same session, incoming messages are queued or used to steer the agent, and updates are streamed to everyone.
Imagine an agent picking up a GitHub issue and working on a PR while teammates watch or steer the same conversation from their phones, browsers, or terminals. @pidotdev's shared-chat tutorial demonstrates this.
#3 Agents that run anywhere
@badlogicgames built a Pi Durable Android app that runs the agent harness and stores its state locally on his phone, while model calls happen remotely.
Pi Durable separates agent state from execution, with pluggable storage and execution backends. The harness can run anywhere there's a compatible JavaScript runtime, and its tools can execute on another machine. Your durable agent doesn't need an always-running terminal or cloud server just to preserve the agent's state, the harness can run locally, on a phone, or in the cloud.
#4 Build new tools on top of agent state
This is the one we're most excited about.
Pi Durable persists structured tasks, checkpoints, and interrupted operations. That means you can inspect an agent's execution state without asking the model to reconstruct what happened.
We experimented with putting Pi Durable inside a Cloudflare Durable Object and visualizing its stored state without waking the agent.
Imagine using that data to build:
- Debugging dashboards showing exactly where an agent crashed.
- Reliability metrics showing which tool calls repeatedly fail or need recovery.
- Multiplayer dashboards showing pending tasks, who steered an agent, and when.
The interesting part is that durable execution state becomes a new primitive you can build tools on top of, not just something used for crash recovery.
00:00 What is Pi Durable?
07:06 Idea 1: Durability for high-stake workflows
13:16 How to build with Pi Durable
16:31 Durable storage: local vs. cloud
19:46 Pi Durable + Cloudflare Durable Objects
32:20 Idea 2: Multiplayer agents with shared state
35:01 Idea 3: Running the harness on a phone
37:45 Idea 4: Inspecting persistent agent state
🧵👇 Links to YouTube, Apple Podcasts, and Spotify below.
Superlinear retweeted
#4 is what I'm most excited to build with @pidotdev's Pi Durable + @CloudflareDev Durable Objects.
I've seen people use Pi Durable for crash recovery, shared sessions, and agents that run across devices. What I haven't seen much of is people building tools on top of the execution state itself.
Pi Durable persists tasks, tool calls, and checkpoints as structured data. You can inspect that state without waking the agent or asking the LLM to reconstruct what happened from conversation history.
Think:
- Debugging dashboards showing exactly which tool call was interrupted by a crash.
- Reliability metrics showing which operations repeatedly fail or need recovery.
- Multiplayer dashboards showing pending tasks, who's steering an agent, and what it's working on.
We experimented with visualizing this state inside a Cloudflare Durable Object.
I think there's a lot of interesting tooling to build on top of this new primitive.
4 things worth building with @pidotdev's Pi Durable + @CloudflareDev Durable Objects:
#1 Durable agents for high-stakes workflows
Pi Durable can identify interrupted operations and avoid automatically replaying unsafe calls. Imagine an agent refunding a customer, then crashing before it gets confirmation. You don't want it refunding the customer twice.
Pi Durable checkpoints each step, recording the intent to execute a tool call and whether it completed. After a crash, it knows which operations were interrupted. Unsafe calls aren't blindly retried, so your app can check whether the payment went through before proceeding.
#2 Shared team agents
Pi Durable + Cloudflare Durable Objects are a great foundation for multiplayer agentic coding.
A Durable Object holds the persistent agent state. Multiple clients can connect to the same session, incoming messages are queued or used to steer the agent, and updates are streamed to everyone.
Imagine an agent picking up a GitHub issue and working on a PR while teammates watch or steer the same conversation from their phones, browsers, or terminals. @pidotdev's shared-chat tutorial demonstrates this.
#3 Agents that run anywhere
@badlogicgames built a Pi Durable Android app that runs the agent harness and stores its state locally on his phone, while model calls happen remotely.
Pi Durable separates agent state from execution, with pluggable storage and execution backends. The harness can run anywhere there's a compatible JavaScript runtime, and its tools can execute on another machine. Your durable agent doesn't need an always-running terminal or cloud server just to preserve the agent's state, the harness can run locally, on a phone, or in the cloud.
#4 Build new tools on top of agent state
This is the one we're most excited about.
Pi Durable persists structured tasks, checkpoints, and interrupted operations. That means you can inspect an agent's execution state without asking the model to reconstruct what happened.
We experimented with putting Pi Durable inside a Cloudflare Durable Object and visualizing its stored state without waking the agent.
Imagine using that data to build:
- Debugging dashboards showing exactly where an agent crashed.
- Reliability metrics showing which tool calls repeatedly fail or need recovery.
- Multiplayer dashboards showing pending tasks, who steered an agent, and when.
The interesting part is that durable execution state becomes a new primitive you can build tools on top of, not just something used for crash recovery.
00:00 What is Pi Durable?
07:06 Idea 1: Durability for high-stake workflows
13:16 How to build with Pi Durable
16:31 Durable storage: local vs. cloud
19:46 Pi Durable + Cloudflare Durable Objects
32:20 Idea 2: Multiplayer agents with shared state
35:01 Idea 3: Running the harness on a phone
37:45 Idea 4: Inspecting persistent agent state
🧵👇 Links to YouTube, Apple Podcasts, and Spotify below.
Superlinear retweeted
4 things worth building with @pidotdev's Pi Durable + @CloudflareDev Durable Objects:
#1 Durable agents for high-stakes workflows
Pi Durable can identify interrupted operations and avoid automatically replaying unsafe calls. Imagine an agent refunding a customer, then crashing before it gets confirmation. You don't want it refunding the customer twice.
Pi Durable checkpoints each step, recording the intent to execute a tool call and whether it completed. After a crash, it knows which operations were interrupted. Unsafe calls aren't blindly retried, so your app can check whether the payment went through before proceeding.
#2 Shared team agents
Pi Durable + Cloudflare Durable Objects are a great foundation for multiplayer agentic coding.
A Durable Object holds the persistent agent state. Multiple clients can connect to the same session, incoming messages are queued or used to steer the agent, and updates are streamed to everyone.
Imagine an agent picking up a GitHub issue and working on a PR while teammates watch or steer the same conversation from their phones, browsers, or terminals. @pidotdev's shared-chat tutorial demonstrates this.
#3 Agents that run anywhere
@badlogicgames built a Pi Durable Android app that runs the agent harness and stores its state locally on his phone, while model calls happen remotely.
Pi Durable separates agent state from execution, with pluggable storage and execution backends. The harness can run anywhere there's a compatible JavaScript runtime, and its tools can execute on another machine. Your durable agent doesn't need an always-running terminal or cloud server just to preserve the agent's state, the harness can run locally, on a phone, or in the cloud.
#4 Build new tools on top of agent state
This is the one we're most excited about.
Pi Durable persists structured tasks, checkpoints, and interrupted operations. That means you can inspect an agent's execution state without asking the model to reconstruct what happened.
We experimented with putting Pi Durable inside a Cloudflare Durable Object and visualizing its stored state without waking the agent.
Imagine using that data to build:
- Debugging dashboards showing exactly where an agent crashed.
- Reliability metrics showing which tool calls repeatedly fail or need recovery.
- Multiplayer dashboards showing pending tasks, who steered an agent, and when.
The interesting part is that durable execution state becomes a new primitive you can build tools on top of, not just something used for crash recovery.
00:00 What is Pi Durable?
07:06 Idea 1: Durability for high-stake workflows
13:16 How to build with Pi Durable
16:31 Durable storage: local vs. cloud
19:46 Pi Durable + Cloudflare Durable Objects
32:20 Idea 2: Multiplayer agents with shared state
35:01 Idea 3: Running the harness on a phone
37:45 Idea 4: Inspecting persistent agent state
🧵👇 Links to YouTube, Apple Podcasts, and Spotify below.
4 things worth building with @pidotdev's Pi Durable + @CloudflareDev Durable Objects:
#1 Durable agents for high-stakes workflows
Pi Durable can identify interrupted operations and avoid automatically replaying unsafe calls. Imagine an agent refunding a customer, then crashing before it gets confirmation. You don't want it refunding the customer twice.
Pi Durable checkpoints each step, recording the intent to execute a tool call and whether it completed. After a crash, it knows which operations were interrupted. Unsafe calls aren't blindly retried, so your app can check whether the payment went through before proceeding.
#2 Shared team agents
Pi Durable + Cloudflare Durable Objects are a great foundation for multiplayer agentic coding.
A Durable Object holds the persistent agent state. Multiple clients can connect to the same session, incoming messages are queued or used to steer the agent, and updates are streamed to everyone.
Imagine an agent picking up a GitHub issue and working on a PR while teammates watch or steer the same conversation from their phones, browsers, or terminals. @pidotdev's shared-chat tutorial demonstrates this.
#3 Agents that run anywhere
@badlogicgames built a Pi Durable Android app that runs the agent harness and stores its state locally on his phone, while model calls happen remotely.
Pi Durable separates agent state from execution, with pluggable storage and execution backends. The harness can run anywhere there's a compatible JavaScript runtime, and its tools can execute on another machine. Your durable agent doesn't need an always-running terminal or cloud server just to preserve the agent's state, the harness can run locally, on a phone, or in the cloud.
#4 Build new tools on top of agent state
This is the one we're most excited about.
Pi Durable persists structured tasks, checkpoints, and interrupted operations. That means you can inspect an agent's execution state without asking the model to reconstruct what happened.
We experimented with putting Pi Durable inside a Cloudflare Durable Object and visualizing its stored state without waking the agent.
Imagine using that data to build:
- Debugging dashboards showing exactly where an agent crashed.
- Reliability metrics showing which tool calls repeatedly fail or need recovery.
- Multiplayer dashboards showing pending tasks, who steered an agent, and when.
The interesting part is that durable execution state becomes a new primitive you can build tools on top of, not just something used for crash recovery.
00:00 What is Pi Durable?
07:06 Idea 1: Durability for high-stake workflows
13:16 How to build with Pi Durable
16:31 Durable storage: local vs. cloud
19:46 Pi Durable + Cloudflare Durable Objects
32:20 Idea 2: Multiplayer agents with shared state
35:01 Idea 3: Running the harness on a phone
37:45 Idea 4: Inspecting persistent agent state
🧵👇 Links to YouTube, Apple Podcasts, and Spotify below.
Watch on
- YouTube: youtube.com/watch?v=BB84EzZj…
- Apple Podcasts: podcasts.apple.com/gb/podcas…
- Spotify: open.spotify.com/episode/5Nc…
Newsletter: superlinear.fm