Remote agents

Remotes let the coding agents keep working when I am away from the desk.

This setup is about ongoing development from the couch, not only from the workstation. By using remote surfaces and coding agents together, I can keep work moving through review, direction, and bounded execution without needing to sit directly in front of the main machine the whole time. The point is not constant autonomy. The point is persistent progress through connected tools, clear instructions, and remote access to the work.

1main goal: keep development moving away from the desk
2linked surfaces: remote access plus coding agents
3requirements: continuity, instructions, and safe execution
Remote changes the posture

I do not need to be physically at the main development machine to keep the process alive. Remote surfaces let me supervise, redirect, and continue work from a lighter environment.

Agents need a paved road

Remote development only stays productive when the coding agents receive scoped tasks, enough access to act, and context that survives between sessions.

Comfort is not the point

The couch is just the symbol. The real idea is reducing friction so the work can continue through more surfaces without collapsing into loose improvisation.

01

What remotes make possible

ACC

Access from anywhere

Remote surfaces let me stay connected to the work without being tied to the local workstation, which matters when development stretches beyond one sitting.

  • Review outputs without returning to the desk.
  • Send follow-up instructions from lighter devices.
  • Keep ongoing work visible across locations.
AGN

Delegated execution

The coding agents can keep handling bounded tasks while I supervise direction, review what changed, and step in only where judgment is needed.

  • Good for narrow implementation slices.
  • Useful when the path is clear but the typing is tedious.
  • Keeps the human focused on decisions instead of keystrokes.
CNT

Continuity of work

The workflow does not reset just because I changed locations. Remotes help preserve continuity while the agents continue operating inside a prepared environment.

  • Context survives across sessions and devices.
  • Longer tasks can keep progressing.
  • The system stays live between direct work bursts.
02

How the remote loop works

1. Leave context

Set up the task with enough notes, constraints, and references that the agent can continue without asking basic questions.

2. Connect remotely

Use the remote surface to check progress, steer priorities, and respond without reopening the entire environment locally.

3. Let agents execute

Allow the coding agents to perform bounded repo work while the human stays available for approvals and course correction.

4. Review and recover

Come back through logs, diffs, checkpoints, or tags so the work remains inspectable and reversible when needed.

Rule: remote work only scales when the agent has enough context to continue and the human has enough visibility to recover.
03

What the agents still need

SCP

Scoped tasks

Remote operation is not a reason to become vague. The agents still need narrow objectives, clear edges, and an explicit definition of what counts as done.

  • One slice at a time.
  • Clear inputs and expected outputs.
  • Fewer hidden assumptions.
CTX

Persistent context

Instructions, notes, reference material, and environment assumptions need to survive across remote sessions or the couch workflow falls apart.

  • Leave the next agent enough state to resume.
  • Keep the decision trail visible.
  • Avoid restarting from fragments.
PRM

Right-sized permissions

Remote agents still need enough permissions to do meaningful work, but the access should match the job and the available recovery path.

  • Useful access beats fake safety.
  • Over-broad access increases blast radius.
  • Recovery determines how far trust can go.
04

Why this matters personally

  • It turns development into a more continuous process instead of something blocked by physical location.
  • It lets me keep momentum during longer builds, reviews, and experiments.
  • It fits a workflow where AI tools, remote surfaces, and human judgment are all active together.
  • It makes the environment feel like a live system rather than a single editor session.
  • It only works when instructions, permissions, mitigation, and recovery are treated seriously.