Lesson 1 of 5
Where is the work actually running?
Module 9 ended with a coordinator waiting on returns that might take hours, and a person supervising from a phone. This module is about that arrangement. When you watch work from a device you are holding while the work happens somewhere else, several different things are involved, and most of the confusion about remote agents comes from drawing them as one. This lesson draws them separately, using a scheduled report as the case, and reads one product's documentation to see where it says its work runs.
Numbered links identify sources. Underlined terms offer a definition without leaving the lesson.
What this lesson needs from earlier modules
From module 2: a is a running program on a ; a shows text and a runs programs, and a terminal on one device can show a shell on another host; a sends requests to a ; held only in a process's memory ends with the process, and means writing it to storage; a is what proves an identity to a service. From module 3: the runs the tools and holds the access. From module 4: a is one piece of work as the harness keeps it. From module 5: an is the runtime, files, permissions and network a program runs within. From module 8: a is saved progress, and an operation with an is inspected at its destination before it is repeated. From module 9: the records where work is split and how it is joined. Module 6's setup decision record, the dated record of why a setup was chosen, returns in the last lesson.
The case: a scheduled report on another computer
The supplier invoice report from module 8 now runs on a schedule, on the first of each month, on a small computer the garden rents from a hosting company and reaches over the network. Everything about this case is authored, and two of its assumptions are stated now because later lessons lean on them: the rented computer keeps its files on a disk that survives a restart, and nothing on it starts the report again by itself after a restart. The treasurer starts the run from a phone on the way to work, checks on it from the phone during the day, and expects a notification when it finishes. The harness on the rented computer has the six tools from module 8: it reads the three invoice files from a folder there, fetches Hedgerow's invoice from the garden's mailbox, writes the report to the Reports folder there, lists and posts to the committee board, and writes a progress note as it goes, as module 8's recovery plan asked. The model the harness calls runs at the provider, not on the rented computer. The harness is started in a way that keeps it running if the phone disconnects; lesson 2 explains that arrangement.
This module follows several failures, and they are alternatives, not one chronology. In one, the phone loses its connection in a tunnel while the run continues. In another, the process exits after posting and before updating its note. In a third, the host restarts while the report is being written and a later run finds a half-written file. In a fourth, the run finishes and the notification never arrives. Lesson 3 takes each as a separate case with its own state records, and says what each did and did not do.
Five things, drawn separately, and what the drawing leaves out
Here is the arrangement, drawn as five things with the connections between them:
[1] viewing device the treasurer's phone: shows a view, accepts input
|
[2] connection the network path between the phone and the host
|
[3] process the harness, running the report: reads, writes,
| posts, holds the session's state in memory
[4] host the rented computer the process runs on: its
| operating system, accounts, clock, network
[5] stored work files on the host's disk: invoices, the report,
the progress note
and beyond the host: the model at the provider; the mailbox service;
the committee board, each with its own
authorization and its own records
The is whatever the person holds. It shows and it sends; in this arrangement it does not run the report. The connection is the path between them. The is the host on which the harness process runs: it is where the tools are invoked, where the harness's own rules apply, and where its local files live; remote write tools can also change files on other services. The is what the process has written to disk, and it is what a fresh process can read after the old one is gone; a fresh process can also read the host's configuration, its list of running processes and its network state, which are evidence too, but not the old process's memory.
The drawing is a teaching simplification, and the line beneath it says what it leaves out. The model is not on the host; the harness sends it context over the network and receives generated text back. The mailbox and the board are services on other computers, each of which checks its own credential and keeps its own log. So credentials are not all in one place: the harness holds what it needs to reach each service, and each service decides what that credential allows. Enforcement is likewise layered: the harness's rules on the host, the operating system's limits on the process, and each service's authorization of what the harness's credential may do. A person who wants to know what a remote agent can reach asks about all three, and the host is where the first two are found.
Each of the five can fail on its own, and the failures are not interchangeable. The phone can lose its connection while the process runs on. The process can exit while the host stays up and the files stay put. The host can restart, taking every process with it and, on the disk this case assumes, leaving the files. The stored work can be incomplete because the process stopped in the middle of writing it.
Where one product says its work runs
Anthropic's Remote Control documentation says its phone and web interfaces show a session executing on the user's machine, which must remain on with its process running. 2 Opening its view elsewhere does not relocate execution. That is the placement to check in whichever product you use.
The same placement holds for enforcement. Module 3 put permission checks and sandboxes in the harness, on the machine that runs the tools, and Anthropic's engineering account of how it contains its models across products describes its controls in the same place: as properties of the machine and the software that execute the model's actions. 4 That article is one vendor's description of its own products, and its specific controls do not transfer. Its placement does, with the layer the drawing added: the harness and the operating system on the host, and each outside service for what it will let the harness's credential do.
Carry this forward
- Draw the viewing device, the connection, the process, the host and the stored work separately; each fails on its own. Beyond the host are the model at the provider and each service the harness reaches, with their own credentials and logs.
- Remote access moves the view, not the execution. One product's documentation says so directly: the process and the files stay on the machine, and the phone is a window.
- Enforcement is layered: the harness's rules and the operating system on the host, and each service's authorization of what the harness's credential may do.
- A fresh process can read the stored work and the host's own state, not the old process's memory. This case assumes a disk that survives restarts; a host whose storage does not is a different case.
Lesson check
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.
The process runs on a host, and something on that host has to keep it running when the treasurer's terminal on the phone goes away. The next lesson looks at the program that does that, and at exactly what it keeps.
Sources · Reviewed 2026-09-29
- 2. Anthropic, Claude Code documentation: Continue local sessions from any device with Remote Control
- 4. Anthropic engineering: How we contain Claude across products
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.