Junction is a PWA for AI coding agents because agent control is not the same job as writing code in an editor.
When Claude Code or Codex is working through a task, the most useful remote surface is often not a full terminal, a full IDE, or a native app that only understands one provider. It is a reliable control surface: open a session, watch output, answer a question, approve or deny a risky step, inspect the diff, and decide whether the run should continue.
That job maps well to a web-first app. The agent keeps running on the machine that already owns the repository. Junction runs a daemon on that machine. The browser or installed web app becomes the control surface across desktop and mobile.
This article explains why the PWA model is a practical fit for local AI coding agents, where it is better than a phone terminal, and where the tradeoffs still matter.
A PWA is useful when the app is a control surface
The core PWA idea is simple: a web app can be used in the browser and, on supporting platforms, installed into an app-like launcher. MDN's PWA installability guide explains the browser model: installable web apps use a manifest to describe how they should appear and behave, while support and install prompts vary by browser and platform.
That matters for Junction because the product does not need a separate native app to become useful on a phone. The main interface can stay web-first while still fitting the way developers actually check agent work away from the desk.
For an AI coding agent workflow, the important mobile tasks are usually:
- checking whether a run is still active,
- reading the latest reasoning or tool output,
- seeing whether the agent is blocked,
- approving or denying a permission request,
- reviewing a focused diff,
- stopping a run that drifted,
- and opening a pull request path when the work is ready.
Those are not traditional mobile IDE tasks. You are not trying to build a full development environment inside a small screen. You are trying to supervise local work without moving the repository.
Why not just use SSH from your phone?
SSH is powerful, but it gives you a terminal. AI coding agents need more than terminal access once they become long-running, interruptible, and review-heavy.
A phone terminal can work for quick commands. It gets worse when you need to read a multi-file diff, distinguish a harmless status message from a real permission prompt, or remember which Claude Code or Codex session belongs to which task. Mobile keyboards, network drops, small panes, and terminal scrollback all add friction.
Junction's PWA approach is narrower and more purposeful. It does not try to replace your editor. It gives agent-specific surfaces for sessions, output streaming, approvals, Git state, diff review, and notifications.
That is the difference between "I can reach the shell" and "I can make the next safe decision."
The local machine stays the execution layer
The PWA is not where the agent executes. Junction's daemon runs on the machine with your code. Claude Code and Codex run there, using the local checkout, local tools, provider authentication, Git state, and project configuration already present on that machine.
The browser interface is the control layer. It connects to the daemon, streams state, and lets you interact with the run.
That separation is the key architectural point:
| Layer | What it does |
|---|---|
| Local daemon | Starts and manages agent sessions on your machine |
| Claude Code or Codex | Executes in the local project context |
| Junction web app or PWA | Shows output, approvals, Git state, diffs, and controls |
| Relay or direct connection | Carries control traffic between browser and daemon |
This is why the PWA model works better for Junction than a cloud sandbox framing. The app can be available from more devices without making the browser the place where the code has to live.
Anthropic's Claude Code Remote Control docs describe a similar local-session distinction for Claude Code: remote interfaces can act as a window into a session that still runs on the user's machine. OpenAI's Codex web docs describe a different model for Codex cloud tasks, where work runs in a cloud environment. Junction is intentionally built around the local side of that split.
Push notifications are part of the control surface
A PWA control surface becomes much more useful when it does not require you to keep the app open all day.
MDN's Push API documentation explains the browser primitive: a web app can receive push messages through a service worker when the user has opted in, even if the app is not currently in the foreground. That is the right shape for agent work because most status updates do not deserve live attention, but a few do.
Junction's notification model is built around decision points:
- an agent finished,
- an agent needs permission,
- an agent hit an error,
- a plan is ready for review,
- or Switchboard picked up a new issue.
Those events are different from a live transcript. A transcript belongs in the session view. A notification belongs at the moment when your decision changes the next step.
A PWA also keeps desktop and mobile consistent
Native-only mobile tools often create a second workflow. You start in the terminal, switch to a phone app, then return to a different desktop view. That can be fine for a single provider, but it gets awkward when your workflow includes multiple agents, multiple daemons, and multiple repositories.
Junction's web-first model keeps one product surface across devices. The same core app works on desktop and mobile. That matters when your question is not "Can I type a prompt from my phone?" but "Which run is blocked, what changed, and what should I do next?"
For example, a practical mobile sequence might look like this:
- Start Codex from your workstation for a focused test failure.
- Leave your desk while the agent runs.
- Get a notification that the agent needs approval to edit a package manifest.
- Open Junction from your phone.
- Read the request, inspect the current diff, and deny the action because the task should not touch dependencies.
- Send a correction from the same session.
- Review the final diff later from desktop before merging.
The phone did not become the development environment. It became the control point that kept the local run from drifting.
When the PWA model is not enough
A PWA control surface is not the right answer for every task.
If you need to write complex code manually, debug a visual layout, run a long interactive shell session, or inspect a large cross-cutting refactor, use a desktop environment. Mobile review is good for triage, small approvals, and focused decisions. It is not a replacement for full engineering review.
Browser and platform support also matter. PWA install behavior varies by operating system and browser. Push notification behavior depends on browser support, service worker readiness, user permission, and device settings. That is why the right product design should degrade gracefully: the app should still work in the browser when install prompts or push notifications are not available.
What developers should look for in an agent PWA
A useful AI coding agent PWA should not be a generic terminal window with a smaller font. It should answer agent-specific questions quickly.
Use this checklist:
- Can I see which machine and repository the run belongs to?
- Can I distinguish running, blocked, failed, and finished sessions?
- Can I read the relevant output without scanning all scrollback?
- Can I approve, deny, stop, or redirect from mobile?
- Can I inspect diffs before allowing risky changes?
- Can I switch between Claude Code and Codex sessions without mixing context?
- Can I get notifications only when attention is useful?
- Can I return to desktop without losing the thread?
If the answer is mostly no, the mobile layer is probably just remote access. If the answer is yes, it is a real control surface.
Where Junction fits
Junction uses the PWA model because the browser is the right place to coordinate local agent work across devices. The daemon owns execution. The app owns visibility and control. The code stays on your machine.
That gives you a practical path: run Claude Code or Codex where your project already lives, then use a browser or installed web app to monitor, approve, review, and stop runs when needed.
Start with the Junction setup guide to pair one daemon. If you expect to supervise more machines or keep more chats open, compare the plan limits on pricing.