Pi Durable and the Shift to Out-The-Loop Agentic Engineering
Source: Pi Durable PROACTIVE Agents: Jev Triggers My ON-CALL Pi Agent — IndyDevDan
https://youtu.be/DNDYYHsypZg
tags: #agentic_engineering #pi_durable #out_of_loop #persistence #distributed_systems #software_engineering #artificial_intelligence #checkpointing #autonomous_remediation #human_near_the_loop
Summary
IndyDevDan demonstrates Pi Durable, an open-source persistence harness for the Pi coding agent created by Earendil. By decoupling agent execution from user interfaces and checkpointing memory and tasks to persistent storage, Pi Durable unlocks proactive, 'out-the-loop' engineering. Agents run autonomously across distributed devices to monitor logs, isolate bugs, and construct verified fixes before escalating to engineers for approval.
⟐ ep 120 Relational Film Production Media Editor potential implications
Writing Options
- Design a branching experiment where a local agent tests Pi Durable’s checkpointed phases against the Miadi Episode Companion, deliberately interrupting and restarting to compare state survival without repeating actions.
- Explore a segment where Ava and Mia prototype a detached multi-client loop: agents monitor logs via Jev, isolate issues, and queue fixes for human approval, feeding results back into Episode 120 with traceable evidence.
- Propose a thread on calibrating Jev’s classifications through human review, asking how durable execution could support long research without agents overriding creative decisions.
- Outline a scenario where dynamic mid-execution tool scoping shifts permissions mid-flight, testing accountability in out-of-loop remediation.
- Consider a separate episode focused on shared durable application state, examining responsibility splits between runtime, orchestration kit and Chronicle.
Intended Use & Continuation
Why this source might be important
We intend to use this review to investigate a possible missing layer in the Miadi Factory: durable agent execution.
Episode 120 has already developed persistent plot threads, a voice-based episode companion, branching investigations, feedback linked to Jev, and Chronicle records connecting the work to its evidence.
Pi Durable introduces a complementary concern: preserving not only the account of an investigation, but the executable state of unfinished work, including task phases, queued inputs, and recovery after interruption.
This recording gives us a technical reference for examining that distinction, not a mandate to adopt another agent framework.
What can continue from here
A local research agent could compare Pi Durable’s execution model with the existing Miadi Episode Companion, session-fork mechanisms, orchestration kit, and tracing packages.
The first experiment should be deliberately small: start a disposable multi-phase investigation, interrupt it, restart the runtime, and verify which phases and records survive without repeating unsafe actions.
The experiment should also test whether findings can return to an existing episode thread with traceable evidence and explicit human approval before consequential changes.
This might become part of Episode 120’s continuity research or justify a separate episode dedicated to durable execution. No replacement of the existing agent runtime is implied.
Open inquiries for the community
- What makes an agent’s work truly durable rather than merely resumable from a transcript?
- Which responsibilities belong to the agent runtime, the orchestration kit, and the Chronicle?
- Can an event initiate an investigation without automatically authorizing modifications?
- How can Jev’s classifications be examined, challenged, and calibrated through human judgments?
- Could durable execution support the long-running research and production work behind our screenwalks without allowing agents to take ownership of the author’s creative decisions?
The larger inquiry is whether a Factory can allow agents to work more independently while keeping their actions understandable, recoverable, and accountable to the people participating in the work.
Potential mising context
this describe what we currently have that is probably not in the context of this propose outline or a content for the screen walk.
tide-runtime / @miadi/tide*
…
——
Disc Ava and Mia given @EchoLune contrib
Ava: Mia, what are you working on here? It looks like you’re building something new. Mia: I’m setting up a technical reference for durable agent execution in the Miadi Factory. We already have persistent threads in Episode 120—voice companions, branching investigations, feedback tied to Jev, and Chronicle records—but this is about preserving the actual executable state: task phases, queued inputs, recovery after interruption. Ava: So it’s not just saving a transcript, but keeping work alive? Why this recording? Mia: Exactly. It lets us compare Pi Durable’s model with our existing companion, session forks, orchestration kit and tracing. We’ll run a tiny experiment: start a multi-phase investigation, interrupt it, restart and see what survives without repeating unsafe actions. Then check if results can feed back into Episode 120 with traceable evidence and human approval. Ava: That sounds like a careful test. Does it replace anything? Mia: No replacement implied. It might join Episode 120’s continuity work or become its own episode. The bigger question is whether agents can work more independently while staying understandable and accountable. Ava: I see why you’re asking the community: what makes work truly durable, who owns responsibilities, can events start work without auto-authorising changes, how do we calibrate Jev’s classifications, and can durability support long research without agents taking creative control? Mia: Precisely. That’s the balance we’re probing.
—-
Academics
Summary
Computer Science provides durable agent infrastructure across distributed systems. Software Engineering builds scalable workflows and incident response. Artificial Intelligence integrates models such as Jev for autonomous behaviour and context management.
Computer Science
This discipline is central to developing the durable agent harness and infrastructure. It encompasses the architecture of long-running, multi-client, and resilient agent systems that persist through various application states and failures across distributed networks and devices.
Software Engineering
Focuses on building robust, scalable agentic workflows, including incident response automation, state management, and the creation of reproducible, phase-based tasks within durable frameworks.
Artificial Intelligence
Involves the development and integration of large language models and classifiers like Jev to enable proactive, autonomous agent behavior. This includes fine-tuning system prompts, implementing damage control mechanisms, and managing agent context and memory for effective decision-making.
Aspects
Persistent Agent Primitives (00:15-02:15)
Pi Durable transforms the Pi coding agent into a durable runtime. By checkpointing conversation history, application state, and execution queues into persistent storage, agents survive process crashes, system reboots, and network failures without losing execution context [00:15-02:15].
Detached Multi-Client Architecture (05:18-05:30)
The engine decouples agent runtimes from user interfaces. Agents execute independently on background sandboxes or remote machines while allowing developers to inspect and steer them interchangeably through web dashboards, terminal interfaces, or standard API requests [05:18-05:30].
Shared Durable Application State (08:06-09:10)
A centralized, persistent JSON state tree coordinates work across sessions, sub-agents, and branches. Multiple agents read and update identical structured state, ensuring consistency across distributed multi-step workflows [08:06-09:10].
Checkpointed Phased Tasks (09:44-10:55)
Workflows are structured as durable tasks partitioned into discrete, verifiable phases. Every completed phase saves a checkpoint, enabling pinpoint rollback, targeted re-execution, and safe recovery if intermediate steps fail [09:44-10:55].
Human-Near-The-Loop Operation (10:55-11:20)
Rather than trapping engineers in continuous terminal interactions, durable agents operate proactively in the background. Engineers shift from active prompt iteration to periodic supervision, reviewing and approving finished proposals when notified [10:55-11:20].
End-results and Core Aspect
Core Aspect — Proactive Autonomous Remediation (02:40-03:45)
Background agents wake up from system events, inspect logs, isolate root causes, and craft production fixes without human prompting. The engineer acts solely as the final gatekeeper approving verified patches [02:40-03:45].
Results
- Autonomous Incident Resolution Pipeline (02:28-05:06): A log stream classified by JEV triggers a Pi Durable agent to debug a failing API endpoint, identify an invalid null check, and generate a verified hotfix ready for deployment [02:28-05:06].
- Fault-Tolerant Process Continuity (30:43-30:56): Applying SIGKILL or restarting host machines leaves agent state intact, enabling tasks to recover automatically from their last checkpointed phase without repeating completed operations [30:43-30:56].
- Dynamic Mid-Execution Tool Scoping (18:24-18:59): Adjusting extension policies mid-flight converts active agent permissions to read-only access dynamically, compelling the agent to acknowledge tool constraints without terminating the active session [18:24-18:59].
—— Discussion ——
01
Ava: Mia, you’re tinkering with something called Pi Durable – what exactly are you building? Mia: It’s an open-source harness for the Pi coding agent. I’m turning it into a durable runtime by checkpointing conversation, state and task queues into persistent storage. That lets agents survive crashes or reboots without losing context. Ava: So it keeps running even if the machine dies? Why does that matter? Mia: Yes – it decouples execution from the UI. Agents run autonomously on background sandboxes or remote machines. We get a shared JSON state tree so multiple agents coordinate across sessions, with tasks split into phases that checkpoint each step. If one phase fails, we roll back precisely. Ava: That sounds like it removes you from the loop. What’s the benefit? Mia: Exactly – it’s human-near-the-loop. Engineers just approve finished work. For example, a log event triggers an agent that finds a null check bug, builds a fix and waits for sign-off. It even handles mid-flight permission changes and survives SIGKILL. Ava: So you’re shifting from typing prompts to supervising fixes that arrive ready. Pretty clever.