Vibeleaderboard
← Course overviewModule 10 · Operate agents across machines · Beta
Lesson 10.3

Module contents

Operate agents across machines

Lesson 3 of 5

What stopped, and what is still there?

This lesson takes four failure cases in turn, each a separate alternative for the scheduled report rather than one day's chronology: the phone loses its connection, the process exits, the host restarts, and a notification never arrives. Each looks the same from the phone, which shows nothing new. For each, the lesson gives the state records the example supplies and asks three questions: what is still running, what can be inspected, and what cannot be inferred from what was found.

Numbered links identify sources. Underlined terms offer a definition without leaving the lesson.

Case one: the phone disconnects while the host stays up

At 08:40 the treasurer's train enters a tunnel and the phone loses its connection for twenty minutes. The harness was started inside a tmux session, as the previous lesson described, so its terminal is provided by tmux; had it been started in the foreground of the phone's own remote shell, the same disconnection could have ended it, and that is why the case states how it was started. The state records, as the example supplies them, at 09:00 when the connection returns:

host:           up since 1 Sep; clock 09:00
tmux:           session "report" present, one window, harness running in it
process:        harness alive; last line printed 08:57 "read parkside-invoice-1002.txt"
progress note:  09-2026: invoice files read 2 of 3; hedgerow email: pending;
                report: not started; post: pending
board:          three older items; nothing new

What was running: everything except the view. What can be inspected: all of it, once the connection returns, by attaching to the multiplexer session, reading the progress note, and listing the board. And these records, shown on the phone, are evidence, because they are fresh reads of the host, which is different from the phone's earlier display going stale. What cannot be inferred: that the run is going well. A process that is alive is not a process that is making progress, and the note and the last printed line show where it had got to at their moments, not whether the reads in between were correct or whether anything else happened that neither recorded. This course calls the event a , and in an arrangement like this one, where the process's terminal does not depend on the client, the rule is that a client disconnect changes nothing on the host, so the response is to reconnect and read, not to act.

Remote Control documents reconnecting after the host returns online. 2 That is connection recovery, not continued computation during sleep.

Case two: the process exits after posting and before noting

In this alternative, at 14:20 the process exits; the example supplies the cause as an unhandled error in the harness after the post returned, and the treasurer does not know that yet. The state records at 14:30:

host:           up; clock 14:30
tmux:           session "report" present; the pane shows the shell prompt where
                the harness was
process:        no harness process on the host
progress note:  09-2026: invoice files read 3 of 3; hedgerow email: obtained;
                report written; post: pending
board:          three older items and one new: item 7802, "Supplier invoices,
                September 2026", posted 14:19 from the garden's account
Reports folder: supplier-invoices-2026-09.txt, complete, four rows and a total

What was running: the host, the multiplexer server, the shell; not the harness. The pane's prompt and its remaining output are useful evidence: the program ended, and whatever it printed last is still there until the server ends. What can be inspected: the note, the folder and the board. What cannot be inferred: from the note alone, whether the post happened; and from the board's title, account and time alone, whether item 7802 is this report. Two runs, or a person, could have posted something with that title from that account. The board settles the first question, and reading item 7802's contents against the saved report settles the second; where the post tool returned a receipt naming the item, that receipt is the strongest link. Only after the contents match is the post marked done.

This course calls the event a , and its rule is module 8's: before restarting anything, reconcile every step with an external effect against its destination. A fresh run that trusted the note would post again, and since the board in this example offers no identifier contract, the post is not an in module 5's sense, and a second post would be a second copy. The correct restart records item 7802 as the post, updates the note, and has nothing left to do but report.

Case three: the host restarts, and a file is half written

In this alternative, at 14:20 the hosting company restarted the computer for maintenance while the harness was writing the report. The state records at 14:30, after the restart:

host:           up since 14:24 (previous uptime ended 14:20); nothing on this
                host restarts programs at startup
tmux:           no server running; nothing to attach to
process:        no harness process
progress note:  09-2026: invoice files read 3 of 3; hedgerow email: obtained;
                report: writing
board:          three older items; nothing new
Reports folder: supplier-invoices-2026-09.txt ends mid-row: "Parkside Fencing    €480"

What was running: only the host, freshly started, and whatever its startup normally launches, which in this case does not include the report. The multiplexer server ended with the restart, and so did the harness and everything in its memory. What can be inspected: the files, the board, and the host's own records, such as its uptime, which is how the treasurer knows a restart happened rather than an exit. What cannot be inferred: how far the harness had got beyond what it wrote. The note says writing; the file confirms it stopped partway. This course calls the event a , and its rule has two halves. The stored work is what remains, so the restart's damage is measured by reading it. And a partial file is not a checkpoint. Here the partial report is a copy the run can regenerate from the invoices, so the resuming run sets it aside, keeping it for inspection if anyone wants to know where the write stopped, and rewrites the report from the stored inputs, which are unchanged. It then checks the board before posting, as always, and finds nothing, which is consistent with a note that never reached the posting step.

The progress note itself could have been interrupted. Read a partial note as evidence to reconcile, not as an authoritative record. A common protection is to write a replacement file and then switch the filename to point to that completed replacement. This is called an atomic replacement: another reader sees the old file or the new one instead of a half-written combination. Python's documented replacement operation provides this guarantee when successful, with restrictions including files on different file systems. 8

Surviving a process stopping is a different requirement from surviving a power loss. Changes may still be waiting to reach durable storage. On Linux, flushing the file is not enough to ensure its directory entry is durable; the directory needs synchronization too. 9 Use the storage system's documented method and rehearse the failures the plan claims to handle. An atomic rename by itself is not a promise that every completed update survives a power cut.

Case four: a notification never arrives

In the last alternative, at 17:00 the treasurer has had no notification that the report finished and concludes it has not. In fact it finished at 14:19, and the notification is held back by the phone's settings. Remote Control's documentation names phone settings as one cause of delayed notifications. 2 More generally, silence is consistent with unfinished work, a missing message, or a failure before notification. Inspect the run to distinguish them.

So the rule for all four cases is the same, and it is module 8's rule with the drawing added. What the viewing device shows is evidence when it is a fresh read of the host's records, and it is not evidence when it is a stale display or a silence. To learn what happened, read the host: the multiplexer, the process list, the uptime, the progress note, the files, and the destination's own records. The four cases differ in what that reading finds, and the response follows from the finding.

Carry this forward

  • A client disconnect, in an arrangement where the process's terminal does not depend on the client, changes nothing on the host. Reconnect and read. A live process is not evidence of progress or correctness, and reconnection of a link is not survival of a process.
  • A process exit leaves the multiplexer's pane, the files and the destination to inspect. A note saying pending and a board item with the right title are settled by reading the item's contents against the saved report, or by a receipt from the post; only then is the step marked done.
  • A host restart ends every process, including the multiplexer server, and leaves the stored work and the host's own records. A partial file that can be regenerated is set aside and rewritten from stored inputs; a partial note is read as evidence to be checked, not trusted or discarded whole.
  • A missing notification cannot distinguish a run that did not finish from a message that did not arrive. Fresh reads of the host's records shown on the phone are evidence; silence and stale displays are not.

Lesson check

After the process exit in case two, the progress note says "post: pending" and the board shows item 7802 with the report's title, posted at 14:19 from the garden's account. The treasurer starts a fresh run. What should it do about the post?

Choose an answer for each question.

This is a practice check. Answers reset when you leave this page. Results are not saved and do not place you in another module or award a qualification.

Each case is settled by reading the host. The next lesson asks who can do that reading, with what identity and what permissions, from where, and what a person watching from a phone can actually change while the work runs.

Sources · Reviewed 2026-09-29
  1. 2. Anthropic, Claude Code documentation: Continue local sessions from any device with Remote Control
  2. 8. Python documentation: os.replace
  3. 9. Linux manual: fsync and directory durability

Sources support nearby explanations. Product details can change. Scenarios and model results are authored illustrations unless a lesson explicitly identifies a recorded execution. Module 7 identifies its offline code checks.