Overview of 987: Remote Coding Agents
Hosts Wes Bos and Scott Tolinski discuss the growing tooling and workflows for running coding agents remotely — why you’d want them, where they can run, what access and environment they need, and practical setups (self-hosted and cloud). They share real examples (Sentry-triggered fixes, social media link aggregation, private research podcasts), trade-offs between local vs. cloud hosting, orchestration tools, and operational gotchas (ports, web search costs, API keys, browser access).
Main takeaways
- Remote agents let you run long, parallel, or unattended development tasks from anywhere (phone, laptop, server), freeing you from waiting on a single machine.
- They’re especially useful for grunt work: collecting links, resizing/compressing images, researching, generating PRs, running integration tests, or automatic bug fixes.
- You can self-host (Mac mini, old laptop, NAS, VPS) or use cloud services (Cursor Cloud, Cloud Code, GitHub Codespaces, Warp Oz, etc.). Each has different capabilities (browser, vnc, terminals).
- Browser access is often critical — many agents use a real browser to interact with pages that have no API.
- Environment access matters: CLIs, ffmpeg/sharp, database credentials, API keys, and deployment hooks must be available to the agent.
- Monitoring, cost-control, and smooth handoffs between agent-run code and your local editor are key operational pain points.
Topics discussed
- Why remote agents are useful (mobility, long-running tasks, parallel work, “self-healing” fixes)
- Real-world examples:
- Sentry integration that triggers an agent to diagnose and submit PRs
- Wes’s social-media-aggregation agent that collects links and code for his tips page
- Scott’s OpenClaw-based private podcast research generator
- Where agents run: home hardware (Mac mini, refurbished laptops), NAS/containers, VPS, cloud provider
- Interfaces and workflows: CLI, web GUIs (OpenCode Web), editor-integrations (VS Code Remote SSH, Cursor Remote SSH), full editor-in-the-cloud (code-server, Codespaces)
- Orchestration platforms: Cursor Cloud Agents, Cloud Code, Warp Oz, OpenClaw, Ralph, DIY scripts
- Tooling tips: Tailscale / Cloudflare Access for secure remote access; port standardization; use of browser-enabled remote environments
- Web search and scraping: cost and provider choices (Brave, ExaAI); many agents rely on running a browser to crawl pages
- Monitoring & cost tracking: tokens/LLM calls, Sentry for agent monitoring
Practical setups & tools (summary)
- Self-hosting options
- Old MacBook / Mac mini / Mac Studio in your home or office
- Synology or other NAS with Docker containers
- Low-cost VPS (DigitalOcean, etc.) if you want 24/7 uptime
- Refurbished hardware or Micro Center buys for cheap machines
- Cloud options / managed
- Cursor cloud agents (browser + terminal + long-running agents)
- Cloud Code agents
- GitHub Codespaces / code-server for full dev environments in the browser
- Warp Oz for orchestration (spin up parallel agents)
- Editor + remote options
- OpenCode Web (serve an editor UI from a remote machine)
- VS Code Remote SSH, Cursor Remote SSH to run processes remotely but edit locally
- Tailwind: Zed (editor Wes likes) + OpenCode web combo
- Orchestration / agent platforms
- OpenClaw / Pi / Ralph (DIY agent frameworks)
- Many emerging orchestration UIs; the space is fragmented
When agents run (trigger patterns)
- Manual prompt (start a job from phone or editor)
- Event-driven triggers: Sentry error, webhooks, PR mentions, Slack/GitHub discussion
- Scheduled or long-running agents (e.g., background crawler, integration tests)
- “Listening” agents that detect conversation patterns/issues and proactively start work
Environment & access requirements
- Shell/terminal and necessary CLI tools installed (ffmpeg, sharp, build tools)
- Access to code repositories (GitHub token) for branching and PRs
- API keys and .env variables for deployments and services
- Browser access for scraping/interacting with pages that lack APIs — many agents need real browser instances
- Stable network/power if self-hosting locally; consider VPS for reliability
- Monitoring and logging (Sentry for agent traceability, token usage, and debugging)
Costs and operational considerations
- LLM token/usage costs and per-call overhead — monitor via Sentry or equivalent
- Web search API costs (Brave, ExaAI, etc.) can be significant (examples: Brave/Exa per-1k search pricing)
- Bot detection and IP reputation — hosting from a data-center IP can be blocked; using a home IP or an authenticated tunnel can help
- Handoff friction: transitioning agent-made changes into a local dev session (cursor.com → local editor) can be awkward; smooth transition is a key UX challenge
- Port collisions and local development chaos — standardize ports per project
Recommendations & practical tips
- If you can self-host and like control: run agents at home (Mac mini/old laptop) behind Tailscale or Cloudflare Access for secure remote access.
- Ensure agents have a browser available if you need to interact with web UIs.
- Give agents needed CLI tools and credentials (.env, GitHub tokens) but be careful with secrets and auditing.
- Use Sentry (or similar) to monitor agent runs, token usage, and errors — helps evaluate ROI and debug agent behavior.
- Standardize ports and domain routing early (prevents lots of friction later).
- For heavy or always-on workloads, consider VPS or managed cloud agents; for ad-hoc/one-off tasks, a small self-hosted device often suffices.
- Expect to iterate on prompts and workflows — many agent setups are “figure-it-out” and evolving quickly.
Notable quotes / color
- “Self-healing software” (describing auto-fix PRs via Sentry-triggered agents)
- “Until the monkeys write Shakespeare” (humorous take on the iterative loop approach)
- “Browser is an essential part of this” (repeated emphasis on browser-driven interactions)
Actionable next steps (if you want to try this)
- Pick hosting: test on an old laptop/Mac mini or a cheap VPS.
- Secure remote access: set up Tailscale or Cloudflare Access + a stable domain.
- Install required CLIs/tools (git, ffmpeg/sharp, build tools) and agent runtime (OpenClaw/Cursor/OpenCode).
- Wire up GitHub tokens and Sentry (for triggers and monitoring).
- Start small: build a “grunt work” agent (e.g., image optimizations, social-media aggregator, or Sentry error triage).
- Monitor costs (LLM tokens, web search APIs) and refine prompts and orchestration.
Let us know which setup you choose and what works (self-host vs cloud, which tool gave you the smoothest handoff).