# Control it from your phone or another agent

Source: https://ryansam.com/agent-auto-continue/remote-control/
Published: 2026-10-02 Updated: 2026-10-02

You're out, Codex has hit its limit, and the reset's at 03:00.
You want a Continue queued for then without walking back to your Mac.
Or you'd like Claude Code to book its own next turn before it stops.

[Agent Auto-Continue](https://ryansam.com/agent-auto-continue/) has an optional **Remote control** section in Settings for this, off by default.
Turn it on and the app serves a REST API and an MCP server on `127.0.0.1`, plus your Tailscale address if you choose.
Never your local network, never the public internet.
Every phone or agent gets its own token.

## Turn it on

1. Open **Settings > Remote control** and tick **Allow remote control**.
2. Under **Network access**, pick **This Mac only** or your Tailscale address, then **Save remote settings**.
   The listener status shows whether each address is listening.
3. Under **Device tokens**, name the device, pick **Full control** or **Read only**, then **Create token**.
4. Copy the token or scan its QR code now.
   It's never shown again.

![The Remote control section of Agent Auto-Continue Settings with Allow remote control ticked, network access set to This Mac only on port 3799, and the app listening on 127.0.0.1 with its REST API and MCP server addresses. Below, a new device token is shown once as a QR code and a demo token with Copy token and an I have saved it button.](https://ryansam.com/_astro/settings-light.ydNgdJo_.png)

*On, listening on this Mac only, with a new device token shown once.*

## From your phone

It's Tailscale or nothing.
The token travels as plain HTTP, so the app only listens where something else protects it: the Mac's own loopback, or Tailscale's encrypted WireGuard tunnel.
Local-network addresses are refused; one saved by an older version is dropped at launch.

1. Install Tailscale on the [Mac](https://tailscale.com/docs/install/mac) and your [iPhone](https://tailscale.com/docs/install/ios) or [Android phone](https://tailscale.com/docs/install/android), in the same tailnet.
2. Under **Network access**, choose `Tailscale · 100.x.y.z (utunN)` and save.
3. On the phone, use `http://100.x.y.z:3799` (or the Mac's [MagicDNS](https://tailscale.com/docs/features/magicdns) name) with the token as a bearer token.

Any app that sends HTTP with a header will do.
Find the thread, then queue a Continue for the reset:

```sh
BASE=http://100.x.y.z:3799/v1
AUTH="Authorization: Bearer $AAC_TOKEN"
curl -s "$BASE/threads?query=parser" -H "$AUTH"
curl -s -X POST "$BASE/jobs" -H "$AUTH" \
  -H 'Content-Type: application/json' \
  -H 'Idempotency-Key: phone-0300' \
  -d '{"threadId":"thread-id","trigger":"available"}'
```

`available` needs an agent that reports its limits ([which ones](https://ryansam.com/agent-auto-continue/agents/)); otherwise send `delayMinutes`.
Add a Tailscale [access rule](https://tailscale.com/docs/features/access-control/grants) so only your devices reach port 3799, and never put it behind [Funnel](https://tailscale.com/docs/features/tailscale-funnel).

## From another agent

The MCP endpoint is `http://127.0.0.1:3799/mcp` (Streamable HTTP), or the Tailscale address from another device.
In [Claude Code](https://code.claude.com/docs/en/mcp#user-scope), `--scope user` makes it load in every project:

```sh
claude mcp add --transport http auto-continue --scope user \
  http://127.0.0.1:3799/mcp \
  --header "Authorization: Bearer aac_..."
```

[Codex](https://learn.chatgpt.com/docs/extend/mcp) takes the same URL in `~/.codex/config.toml`, with `bearer_token_env_var` naming the variable that holds the token.
Clients that only launch stdio servers can use the [`mcp-remote`](https://www.npmjs.com/package/mcp-remote) bridge:

```json
{
  "mcpServers": {
    "auto-continue": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "http://127.0.0.1:3799/mcp",
        "--header",
        "Authorization:${AAC_AUTH}"
      ],
      "env": { "AAC_AUTH": "Bearer aac_..." }
    }
  }
}
```

The agent then calls `schedule_message` on its thread: `Continue` by default, optionally as an automatic continuation.
A read-only token only sees the read tools.

## What a remote client can do

- Schedule a message for any agent, edit it or cancel it.
- Start, stop and resume automatic continuations.
- Read status, including keep-awake and each desktop app's last compatibility check.
- Check an unconfirmed delivery, or mark it not delivered (with `confirm: true`).

The full API is in [remote-control.md](https://github.com/VelvetAcorn/agent-auto-continue/blob/main/docs/remote-control.md).

## Security, briefly

Tokens are 256-bit random values, stored only as SHA-256 digests.
They're created and revoked only on the Mac, so a leaked one can't mint more.
Ten failed sign-ins from one address in ten minutes lock it out for fifteen.
Every remote change shows under **Remote activity**.

## Honest limits

- **The Mac must be awake and the app running.** Otherwise requests fail to connect and nothing changes.
  Retry with the same `Idempotency-Key` and you get the original schedule back, not a duplicate.
- **Tailscale must run on both ends.** If it drops on the Mac, the app retries the address every 30 seconds.
- **Lose the token, make a new one.** Then revoke the old one.
- **Vendor-hosted connectors can't reach it.** They run on the vendor's servers, outside your tailnet.
- **The agent's state still applies.** Refusals say why: `409` for busy or waiting on a question, `503` for a locked screen (desktop apps) or an active usage limit.
- **Close the Claude Code session.** A one-off message due while it's open waits up to six hours, then fails.