Ditch Hermes for Pi Durable— Is it Worth it??

Published
Oct 25, 2026
Duration
11:11
Click to load the YouTube player

A remote agent is useful only if you can tell what happened after sending the request. For a render that takes hours, you need a job identity, visible progress, a failure notice, and a way to continue without accidentally starting the same work twice.

Build those requirements into the workflow before choosing between Hermes and Pi Durable. You may find that separating tasks and cleaning up schedules fixes the existing setup. If it does not, move one production job and test its recovery behavior before transferring the rest.

This guide uses Leo’s Linux-and-Telegram workflow as a concrete design example. It includes documented Hermes inspection commands and a migration exercise. It is not a copy-and-paste installation of his private integration: the source does not provide that implementation, and Pi Durable itself is a developer framework rather than a ready-made Telegram assistant. Official technical details were checked on October 28, 2026.

Identify what is making the existing agent difficult to manage

An agent that handled one job well can become hard to operate after it accumulates unrelated responsibilities. The symptoms may be forgotten instructions, overlapping schedules, repeated requests for context, or an unclear answer about which task is running.

Write down the jobs the agent currently owns. For each, record its trigger, required files or accounts, output, schedule, and last successful completion. Mark jobs that are obsolete or duplicate another process. Keep this inventory separate from the assistant’s recollection; check the actual schedule and output files.

For a Hermes installation you already operate, these documented commands are a useful first inspection:

hermes cron list
hermes cron status

list shows configured jobs; status reports scheduler health and scheduled work. Inspect the intended profile’s jobs when your setup uses profiles. Do not treat a healthy interactive chat as proof that its scheduler is running. The current Hermes scheduled-task documentation also describes separate execution history and failure states.

Leo reports that his Hermes setup worked particularly well during its first two or three weeks, then became unwieldy as more jobs accumulated. Michael describes a similar buildup and a reinstall. Those experiences are reasons to investigate workload organization, not evidence that Hermes has a fixed two-week lifespan. Leo explicitly says he still likes Hermes and that users need to understand and restructure the system they operate. Source: workload buildup and cleanup, 1:03–2:28.

Do not migrate a duplicate schedule into a new harness. You would preserve the cause of the wasted work while changing the software that runs it.

Know which part of the system Pi Durable supplies

A model supplies responses and tool decisions. A harness manages the work around it. A messaging interface carries requests and results. A durable application also needs a record of work that survives a process ending.

Pi the coding agent is primarily a terminal-driven tool. Pi Durable is a separate experimental framework for building longer-running agent applications. Earendil’s announcement explicitly distinguishes it from the coding agent. It provides a foundation for developers to build interfaces and workflows; a Telegram bot and production schedule are application decisions on top. Official Pi Durable introduction.

This distinction explains the setup trade-off. Hermes provides an assistant product with configuration and messaging support. Leo found his Pi Durable setup less friendly to configure and used another coding agent to help build it. Once configured, however, the narrower interface suited his work better. An AI-assisted installation still leaves you responsible for understanding how the resulting service starts, stores state, and recovers. Source: setup difficulty, 4:53.

The source’s attraction to a smaller harness is about control and fewer competing instructions. It does not establish that fewer lines of code or a shorter system prompt automatically produce better reasoning. Do not use a rough prompt-size comparison as a sizing rule for your installation; compare the work your agent actually completes.

Before you start: write the operating requirements

Choose a single job with a clear output. A test render is a better migration candidate than “manage all my work.” Prepare copies of the project assets, an output directory, and a small job that you can afford to repeat during testing. Use a machine that can remain available while you are away.

Leo’s setup runs on one local Linux machine, connects to Claude or GPT models, and uses one Telegram bot with multiple topics in a group. His selected workload includes video editing, 3D rendering, Unity and game-development work, and social-media account management. He does not describe a separate VPS for each task or a complete migration of every personal-assistant responsibility. Source: scope and machine, 7:30–8:45.

Write a short specification for your first job:

RequirementWhat to decide for a test render
SubmissionWhich source project and export settings identify the request?
IdentityHow will the phone user distinguish this job from yesterday’s render?
ProgressWhich completed stage or render measurement can be reported?
OutputWhere will the result and logs be stored?
FailureWhat information will the notification contain?
RecoveryWhich stages can be repeated, and which require inspection first?
CompletionWho opens the output and confirms it is usable?

These are requirements for the integration, not claims that an installed package already implements every row. Ask the implementer to show where each requirement is handled and how it will be tested.

Keep communication, scheduling, and recovery separate

Telegram solves access from a phone. Scheduling decides when to begin. Recovery decides what to do with work that has already begun. A successful message exchange proves only the first of these.

Original video illustration showing Telegram on a phone exchanging commands and status with Pi Durable on Linux.
This explanatory graphic from the original edit at 6:30 shows the intended division: the phone sends instructions and receives updates; the Linux machine performs the work. It is an illustration of Leo's workflow, not a screenshot of a running Telegram bot. Open the image for a full-size view.

For the communication test, submit the small job from your phone and record the returned job identity. Ask for status while it is working. Check that the reply refers to the same job and does not launch a second render. Open another task topic and confirm that a question there does not silently replace the original assignment. Separate topics make conversations easier to follow, but the integration must actually map them to the intended job or session.

For the scheduling test, use a single harmless scheduled occurrence. Verify its timezone, target job, and destination for results. Wait for the actual output and compare it with the requested time. A schedule listed in a settings file is not evidence that the background service fired it.

For the recovery test, use disposable inputs and a job with no publishing step. Arrange a controlled interruption with the implementer, then inspect the recorded state before continuing. Do not experiment by killing a live production render or an unrelated service. The expected behavior is explicit: the job either resumes from known state or asks you to resolve an uncertain step. Silent loss of the job fails the test.

Understand what recovery can and cannot promise

Pi Durable records work in persistent storage and can resume unfinished tasks after a process reopens that storage. Its current README documents SQLite and JSONL storage alongside in-memory storage, which does not persist. It also warns that the API is experimental and can change between releases. A production integration should record its dependency versions and storage location. Pi Durable README.

Earendil's Pi Durable documentation explains saved checkpoints and shows an example reopening storage and resuming an interrupted run.
Authentic documentation capture, October 28, 2026. Notice the same storage being reopened and the resume call. This documents framework behavior; it does not prove that a custom render or Telegram integration safely repeats every external action. Open the image for a full-size view.

Restarting a conversation is different from restoring every program it launched. If a render process ended, the media tool may need to restart or use its own checkpoint mechanism. If a file upload finished just before the agent lost its connection, repeating the upload could create a duplicate. The application needs a way to inspect those outcomes.

Earendil describes checkpointed tasks and explains that interrupted tool calls rerun only when their replay behavior allows it. Its request identity mechanism can recognize a resubmitted request. That does not make an arbitrary external operation safe to repeat. The README explicitly says replay-safe tools with external effects still need their own idempotency: a repeat should not create an additional effect. Recovery explanation and tool replay details.

For a render, assign the output to the job and check whether a complete file already exists before rerunning. For a social post, verify the remote post identity before any retry. Those are design recommendations for the integration; they are not evidence that Leo’s system implements a particular storage schema or duplicate-prevention mechanism.

Leo’s most concrete recovery report is that a failed job sends a notification and asks for another prompt or slash command to continue. He also receives progress updates and can request status without interrupting a job. That is more useful than the broader claim that one harness is “100% recoverable.” Some recovery involves an operator decision. Source: failure and status behavior, 8:52.

Work through one migration before transferring the schedule

Use a written handoff for the test render. This example is an implementation brief, not a Pi Durable slash command:

Migrate only the test render workflow.

Preserve the existing source project and keep the current production
schedule unchanged. Document the model/provider, required media tools,
input directory, output directory, and persistent job-state location.

Give each submitted job a stable identity. Provide a read-only status
operation. A failure report must name the failed stage and tell me
whether retrying it is safe or needs an output check first.

Demonstrate one successful test job, one status request during work,
and one controlled interruption/recovery using disposable inputs.
Do not publish or upload the output automatically.

Compare the migrated output with the known-good result. Open the video, check its duration and audio, and inspect the part of the workflow you are actually changing. A service log saying “completed” does not replace reviewing the artifact.

Only after the test succeeds should you transfer the production trigger. Identify the old schedule precisely, disable that one schedule, and verify that only the replacement will launch the job. Preserve the old configuration and output so a rollback does not require reconstructing the workflow from memory. Leo reports transferring some workflows with another AI coding agent; the source does not establish an automatic Hermes-to-Pi-Durable migration command.

Keep the first migration narrow enough to diagnose. If you simultaneously change the harness, model, render settings, directory layout, and delivery channel, a failed output will tell you little about which change caused it.

Make the phone interface useful on a poor connection

A remote interface should return enough information to make a decision without opening a desktop. For each job, ask it to report the current stage, last confirmed progress, output location, and anything waiting on you. A percentage is useful only if it comes from an actual measurement; “still running” should not become a fabricated estimate.

Leo prioritized this during a cruise where internet access cost him €150 per device. He wanted to work from his phone rather than pay another €150 to connect a computer, and reports that Tailscale was unavailable on that connection in some regions. Those are circumstances of his trip, not a claim about every cruise network. Source: phone-only operation, 6:12–7:30.

The remote machine still needs network and power. Your phone also needs connectivity to send new requests or receive updates. The advantage is that an already-running job does not depend on keeping an interactive SSH session or your travel laptop open.

Avoid repeatedly asking the model to estimate progress when the render program already exposes it. Let the integration report the underlying job state where possible. This reduces uncertainty and makes a stalled program easier to distinguish from a model that is still reasoning.

Troubleshoot slow work and failed notifications separately

If the render is slow but progressing, inspect the actual bottleneck. Leo notes that computing power or internet speed can dominate these jobs for hours. A lighter harness does not accelerate a GPU render or network transfer by itself.

If Telegram is responsive but a scheduled job never starts, inspect the scheduler and its service rather than the chat. If the job finishes but the notification never arrives, inspect delivery separately and check the output before requesting another run. If a status request launches work again, fix the distinction between reading state and submitting a new job.

Current Hermes also documents recovery behavior: unfinished scheduled admissions are reconciled, while uncertain interrupted executions can remain paused for operator review. It is therefore inaccurate to treat recovery as a capability Hermes universally lacks. Compare the specific behavior your installation needs. Current Hermes cron recovery documentation.

If every job carries a large amount of unrelated context, reduce shared instructions and separate responsibilities before blaming the provider. If a useful instruction disappears after a restart, identify where it was stored and whether the new process reads that same state. Repeatedly telling an agent to remember something is a weak substitute for inspecting the configuration.

Decide with completed jobs and operator effort

Record the elapsed time, model cost or usage, number of retries, and minutes of human intervention for the same representative job. Include the time spent maintaining the new integration. A smaller program may fit your preferences while costing more effort to operate.

Leo explicitly says he had not completed a detailed cost comparison. His report supports better visibility and a preferred working interface, not a measured percentage saving. Source: cost uncertainty, 9:40.

His longer-term aim is to build a stable workflow that benefits as models improve. Treat a model change as another small regression test: repeat the accepted job, inspect the output, and exercise the failure path. Better model capability does not remove the need for valid credentials, persistent storage, or a correctly configured scheduler.

Keep Hermes if the existing setup becomes understandable and reliable after cleanup. Consider Pi Durable when a specific long-running workflow justifies building and maintaining the interface around it. For a different problem, dividing recurring work into smaller operators, use the Pi specialist-agent guide.