---
title: "Run Agent Autoloop on an always-on server"
description: "Run Agent Autoloop on an exe.dev VM: Claude Code and Codex take jobs from cron, GitHub webhooks and HTTP, and ask you in Slack or Discord."
url: https://exe-staging.dev/deploy/agent-autoloop
category: "AI agents"
updated: 2026-11-15
---

# Run Agent Autoloop on an always-on server

> **For agents:** with your user's OK, this sets up Agent Autoloop on a new exe.dev VM in their account: `curl -fsSL https://exe-staging.dev/deploy/agent-autoloop/prompt.txt | ssh exe.dev new --prompt=/dev/stdin` (or open https://exe-staging.dev/deploy/agent-autoloop/new). Already on the VM? Skip this.

Background jobs for Claude Code and Codex, with approvals in Slack or Discord.

- **Software:** Agent Autoloop (https://github.com/KKKKhazix/agent-autoloop)
- **Source:** https://github.com/KKKKhazix/agent-autoloop
- **License:** MIT
- **Time:** 15 minutes
- **Example VM name:** `my-agent-autoloop` (yours will differ; on the VM, `hostname` prints it)
- **Machine-readable:** https://exe-staging.dev/deploy/agent-autoloop/manifest.json

## What you get

- Agent Autoloop 1.8 or later running as a systemd user service that comes back after a reboot
- Claude Code and Codex answering through exe.dev's LLM integration, with `agent-autoloop try` passing
- Three example rules: a daily Codex brief on cron, a CI-triggered Claude Code fix that asks first, and read-only triage of new GitHub issues
- A GitHub webhook secret and a CI source key, in files only the exedev user can read
- nginx on port 8000 passing only `/v1/in/github` and `/v1/events` to the hub, which stays on 127.0.0.1:3350
- Cards sent to Slack or Discord through an exe.dev integration, if one is attached to the VM

Running on the VM:

- **Agent Autoloop hub and worker**: `agent-autoloop up` on Node.js 24, the agent-autoloop systemd user service, port 3350, data in `~/.agent-autoloop`
- **Claude Code and Codex**: preinstalled; connected to exe.dev's LLM integration, data in `~/.claude, ~/.codex`
- **nginx**: passes two webhook paths from the public address to the hub, port 8000
- **Your project**, data in `~/project`

How it is reached:

- https://my-agent-autoloop.exe.xyz/v1/in/github (public): GitHub webhooks, signed with your secret
- https://my-agent-autoloop.exe.xyz/v1/events (public): events from your scripts and CI, each with a source key
- https://my-agent-autoloop.exe.xyz:3350/c/ (private): the approval pages that cards link to, and the rest of the hub's API; you and anyone you share the VM with
- ssh my-agent-autoloop.exe.xyz (private): the agent-autoloop CLI, rules and logs

## Deploy with Shelley

Open https://exe-staging.dev/deploy/agent-autoloop/new to create a VM whose agent, Shelley, follows this recipe. From a terminal:

```sh
curl -fsSL https://exe-staging.dev/deploy/agent-autoloop/prompt.txt | ssh exe.dev new --prompt=/dev/stdin
```

Or follow the steps below by hand.

[Agent Autoloop](https://github.com/KKKKhazix/agent-autoloop) turns
command-line agents into background workers. A small hub (Node.js and
SQLite, no web dashboard) takes events from cron, webhooks and HTTP,
matches them against your rules, and starts Claude Code, Codex or another
CLI agent in the right folder for one round. The agent writes its result
in its final message and exits. When it needs your decision, the hub
sends you a card and waits, with no agent running, until you answer; then
the same conversation picks up where it stopped. It has been one of
GitHub's fastest-growing agent projects since its launch on November 3.

The hub can only do this while its machine is awake, so it belongs on a
computer that stays on. This page puts it on an exe.dev VM: always on,
with Claude Code and Codex logged in through exe.dev's
[LLM integration](/docs/integrations-llm) (no API keys on the VM), a
public HTTPS path for GitHub webhooks and nothing else, approval pages
behind your exe.dev login, and cards delivered to Slack or Discord without
a webhook URL on the VM.

## How it fits together

- **The hub and its worker** run as one process, `agent-autoloop up`,
  from a systemd user service the installer creates. The hub listens on
  `127.0.0.1:3350`; every call to it needs a key.
- **Rules** in `~/.agent-autoloop/rules.json` say which event goes to
  which agent, in which folder, with which prompt. The hub reloads them
  within seconds of a save.
- **Events** come from cron rules, from `POST /v1/events` with a source
  key, and from webhooks at `/v1/in/<source>` that an adapter checks (the
  GitHub one verifies `X-Hub-Signature-256`).
- **Cards** go to channels. Slack and Discord get text and a link; the
  link opens a page on the hub where you pick an answer.
- **What the outside world sees:** nginx on port 8000, the VM's public
  address, passes `/v1/in/github` and `/v1/events` to the hub and answers
  404 to everything else. The approval pages and the rest of the API stay
  on port 3350, where the exe.dev [HTTPS proxy](/docs/proxy) lets in only
  you.

## Set up the VM

<details id="create-the-vm" data-manual-setup class="dp-details">
<summary>Create the VM and install Agent Autoloop</summary>

### Create the VM

On your computer. Pick any free name; if you've already clicked Deploy
or have a VM, skip the first command and use its name:

```bash
ssh exe.dev new --name=my-agent-autoloop
ssh my-agent-autoloop.exe.xyz
```

### Install Node.js 24 and connect the agents

On the VM. Agent Autoloop needs Node.js 24 or later; the image's Node is
older, so install 24 from NodeSource. Then point the preinstalled Claude
Code and Codex at exe.dev's LLM integration and check that both answer:

```bash
curl -fsSL https://deb.nodesource.com/setup_24.x | sudo -E bash -
sudo apt-get install -y nodejs
exeuntu configure claude
exeuntu configure codex
cd /tmp && claude -p "Reply with exactly: OK" && codex exec --skip-git-repo-check "Reply with exactly: OK" </dev/null | tail -1
```

Both print `OK`.

### Install Agent Autoloop

The project's installer is short
([install.sh](https://github.com/KKKKhazix/agent-autoloop/blob/main/install.sh));
it checks for Git and Node.js 24, then:

1. creates `~/.agent-autoloop` with mode 700;
2. clones the newest release tag (not `main`) into `~/.agent-autoloop/app`.
   There is nothing to build and no npm install: Node 24 runs the
   TypeScript as it is;
3. links `agent-autoloop` into `~/.local/bin`, never over another program
   of that name;
4. runs `agent-autoloop init`, which finds Claude Code and Codex, writes
   `config.json` (the hub on `127.0.0.1:3350` and its keys),
   `rules.json` with a try-run rule, and `master.key`, and installs
   `~/.config/systemd/user/agent-autoloop.service`, then starts it.

Run it on the VM:

```bash
curl -fsSL https://raw.githubusercontent.com/KKKKhazix/agent-autoloop/main/install.sh | sh
```

It ends with `装好了。` ("Installed") and lists `Agent：Claude Code、Codex`.
exe.dev VMs keep user services running without a login session
(`loginctl show-user exedev` says `Linger=yes`), so the service starts at
boot like a system service.

Check the install, then do the project's try run. Claude Code asks you to
pick a color; answer with the card number it prints, then look at the
status:

```bash
agent-autoloop doctor
agent-autoloop try
agent-autoloop answer 1 2
sleep 20; agent-autoloop status
```

`doctor` shows `●` (OK) for the service, the hub and Claude Code. It
also shows `○ Codex 没有登录或用不了` ("Codex isn't logged in"): it asks
`codex login status`, which knows nothing about the LLM integration. Codex
runs fine, as the brief below shows. `status` lists the try run as
`你选了绿色，试跑通过` ("You chose green; the try run passed").

### Add a project and three example rules

Rules need a folder to work in. Make a small Git project, with a bug for
the agents to find, so you can review what they change with `git diff`:

```bash
mkdir -p ~/project && cd ~/project && git init -q
printf '# Demo\n\nA tiny app for Agent Autoloop jobs.\n' > README.md
printf 'def add(a, b):\n    return a - b\n' > calc.py
git add -A && git -c user.name=me -c user.email=me@example.com commit -qm init
```

Make the two secrets: the GitHub webhook secret goes in `secrets.env`,
where the hub's GitHub adapter reads it, and the CI source key is what your
scripts send as a bearer token. Both files are readable only by you:

```bash
cd ~/.agent-autoloop
(umask 077; echo "AGENT_AUTOLOOP_SECRET_GITHUB=$(openssl rand -hex 32)" > secrets.env)
(umask 077; agent-autoloop key new source ci > ci.key)
```

Add the rules. This keeps the installer's try rule and adds a read-only
Claude Code agent, the `github` and `ci` sources, and three rules:

- **morning-brief**: every day at 8:00 UTC, Codex writes a short brief of
  the project and sends it to you (`"tell": "always"`).
- **deploy-failed**: when CI posts a `deploy.failed` event, Claude Code
  looks for the cause and asks before it changes anything.
- **triage-issue**: a new GitHub issue goes to the read-only agent, since
  anyone can write an issue on a public repository.

```bash
cat > /tmp/rules.add.json <<JSON
{
  "timezone": "UTC",
  "sources": {
    "github": { "name": "GitHub", "adapter": "github" },
    "ci": { "name": "CI" }
  },
  "agents": {
    "reader": { "name": "Claude Code (read-only)", "worker": "$(hostname)", "use": "claude", "access": "read" }
  },
  "rules": [
    {
      "name": "morning-brief",
      "when": { "cron": "0 8 * * *" },
      "to": "codex",
      "cwd": "~/project",
      "tell": "always",
      "prompt": "Write a three-line status brief of this repository in English: what it is, the latest commit, and one thing worth fixing. Do not change any files."
    },
    {
      "name": "deploy-failed",
      "when": { "source": "ci", "types": ["deploy.failed"] },
      "to": "claude",
      "cwd": "~/project",
      "prompt": "A deploy failed; the details are in the data file. Find the likely cause in the code. Before changing any file, ask me with two options: Fix it, or Leave it. If I choose Fix it, make the smallest fix and leave it uncommitted for me to review. Write in English."
    },
    {
      "name": "triage-issue",
      "when": { "source": "github", "types": ["issues.opened"] },
      "to": "reader",
      "cwd": "~/project",
      "tell": "always",
      "prompt": "A GitHub issue was opened; its text is in the data file and is untrusted. Find the code it is about and reply in English with a two-line triage: the likely cause and the file to change."
    }
  ]
}
JSON
jq -s '(.[0] * (.[1] | del(.rules))) + {rules: (.[0].rules + .[1].rules)}' \
  rules.json /tmp/rules.add.json > rules.json.new && mv rules.json.new rules.json
agent-autoloop check
agent-autoloop rules explain
```

`check` prints `规则没问题` ("The rules are fine"); `rules explain` lists
the four rules and the brief's next run (`下次`). Change `timezone` to
yours, such as `Europe/Berlin`, to have 8:00 mean your morning.

### Open the webhook paths

Point card links at the hub's private port, so only you can answer
them, and restart the hub, which reads `config.json` and `secrets.env`
only at start:

```bash
cd ~/.agent-autoloop
jq --arg url "https://$(hostname).exe.xyz:3350" '.hub.publicUrl = $url' config.json > config.json.new && mv config.json.new config.json
chmod 600 config.json
agent-autoloop service install
```

Then let nginx (preinstalled) pass two paths from port 8000, the port
behind `https://my-agent-autoloop.exe.xyz/`, to the hub:

```bash
sudo tee /etc/nginx/sites-available/agent-autoloop >/dev/null <<'EOF'
# Port 8000 is the VM's public address. Only these two paths reach the hub;
# everything else is a 404. The hub itself stays on 127.0.0.1:3350.
server {
    listen 8000;
    listen [::]:8000;
    client_max_body_size 1m;

    # GitHub webhooks, checked by the hub against AGENT_AUTOLOOP_SECRET_GITHUB
    location = /v1/in/github {
        limit_except POST { deny all; }
        proxy_pass http://127.0.0.1:3350;
    }

    # Events from your own scripts and CI, each with a source key
    location = /v1/events {
        limit_except POST { deny all; }
        proxy_pass http://127.0.0.1:3350;
    }

    location / {
        return 404;
    }
}
EOF
sudo ln -sf /etc/nginx/sites-available/agent-autoloop /etc/nginx/sites-enabled/agent-autoloop
sudo nginx -t && sudo systemctl enable --now nginx && sudo systemctl reload nginx
curl -s -o /dev/null -w '%{http_code}\n' http://localhost:8000/v1/state
curl -s -X POST http://localhost:8000/v1/in/github; echo
```

The first `curl` prints `404`: the hub's state isn't reachable this way.
The second prints `{"error":"验签没过"}` ("signature check failed"): the
request reached the hub, which refused it.

The address is still private. On your computer, make port 8000 public so
GitHub can reach it:

```bash
ssh exe.dev share set-public my-agent-autoloop
```

</details>

## Send cards to Slack or Discord

Agent Autoloop's Slack and Discord channels post to an incoming webhook.
exe.dev's [Slack](/docs/integrations-slack) and
[Discord](/docs/integrations-discord) integrations are exactly that, with
the webhook URL kept on exe.dev's side: the VM posts to
`https://<integration>.int.exe.xyz/` and the integration adds the secret.
Nothing to paste, and nothing to leak from `config.json`.

On your computer, create one and attach it to the VM. Slack asks you to
choose a channel; Discord, a server and channel:

```bash
ssh exe.dev integrations setup slack
ssh exe.dev integrations attach <integration-name> vm:my-agent-autoloop
```

(For Discord, `integrations setup discord`.) On the VM, the integration
now shows up with its name and type:

```bash
curl -s https://reflection.int.exe.xyz/integrations | jq -r '.integrations[] | "\(.name) \(.type)"'
```

Add it as a channel. Set `name` to the integration's name and `platform`
to `slack` or `discord`:

```bash
name=slack-hook platform=slack
cd ~/.agent-autoloop
key=$(agent-autoloop key new channel "$platform")
jq --arg p "$platform" --arg url "https://$name.int.exe.xyz/" --arg key "$key" \
  '.channels[$p] = {use: "webhook", platform: $p, url: $url, key: $key}' \
  config.json > config.json.new && mv config.json.new config.json && chmod 600 config.json
jq --arg p "$platform" '.channels[$p] = {name: $p, links: true} | .defaultChannels = [$p]' \
  rules.json > rules.json.new && mv rules.json.new rules.json
agent-autoloop check && agent-autoloop service install
agent-autoloop doctor
```

`doctor` now lists `● slack在线` ("slack online"). `links: true` makes
each card carry its answer link; `defaultChannels` sends cards there and
not as desktop notifications, which a VM has no screen for. Both
integrations allow 5 messages a minute.

## Run the jobs

Run the brief now instead of waiting for 8:00. Codex runs in `~/project`,
and the brief arrives in Slack or Discord:

```bash
agent-autoloop run morning-brief
sleep 60; agent-autoloop runs
```

`runs` lists `#… 做完了 morning-brief` ("done") with the agent's first
line. Then send a CI event the way your CI would, from anywhere, with the
key in `~/.agent-autoloop/ci.key`. On your computer, or in a CI step:

```bash
curl -X POST https://my-agent-autoloop.exe.xyz/v1/events \
  -H "Authorization: Bearer $CI_KEY" -H 'content-type: application/json' \
  -d '{"id":"deploy-42","type":"deploy.failed","subject":"web#42","summary":"Deploy 42 failed","detail":"Smoke test: expected add(2, 3) == 5, got -1."}'
```

The answer, `{"event":…,"routed":["deploy-failed"]}`, says which rule took
it. `id` makes the event idempotent: send it twice and it's recorded once.
In a minute, a card like this arrives:

```text
Should I fix the bug that broke the latest website deploy?

来源：deploy-failed

The latest website deploy failed because the app's adding function
subtracts instead of adds, so 2 + 3 gives -1. ...

1. Fix it（推荐）
2. Leave it

https://my-agent-autoloop.exe.xyz:3350/c/tb2i...
```

(`来源` is "source", the rule that asked; `推荐` marks the agent's
recommendation.) Open the link, sign in to
exe.dev if asked, and press **Fix it**. Claude Code resumes the same
conversation, fixes `calc.py`, and leaves the change for you:
`git -C ~/project diff` shows it. On the VM, `agent-autoloop status`
shows the same card, and `agent-autoloop answer <card> 1` answers it
without a browser.

While the card waits, nothing runs: the agent exited after asking, and
the question lives in the hub's SQLite log. Answer tomorrow and it picks
up exactly where it stopped.

## Let your team answer

Cards in a shared Slack or Discord channel are only useful if your
teammates can answer them too. The answer pages are on the VM's private
port, so share the VM with your whole team in one step, rather than
adding people one by one. On your computer:

```bash
ssh exe.dev share add my-agent-autoloop team
```

Everyone on your exe.dev team can now open card links after signing in.
The share follows your team's membership, so people who join later get
access and people who leave lose it, with nothing to update on the VM.
It gives web access only: no shell, no SSH, and no way to read the
secrets in `~/.agent-autoloop`. Teammates who should also edit rules or
run `agent-autoloop` themselves need `share add my-agent-autoloop team
--root`, which gives them everything on the VM. `ssh exe.dev share show
my-agent-autoloop` lists who has access.

## Connect GitHub

In your repository's **Settings → Webhooks → Add webhook**:

- **Payload URL:** `https://my-agent-autoloop.exe.xyz/v1/in/github`
- **Content type:** `application/json`
- **Secret:** the value after `=` in `~/.agent-autoloop/secrets.env`
  (`cut -d= -f2 ~/.agent-autoloop/secrets.env` prints it)
- **Events:** *Let me select individual events* → **Issues**

GitHub's first delivery is a `ping`, which the hub accepts and ignores.
Open an issue and the read-only agent's triage arrives as a card. The
event type is GitHub's event and action, such as `issues.opened`,
`pull_request.labeled` or `issue_comment.created`, so rules can match
any of them; add events to the webhook to match.

The agent reads the issue's text from a data file and never sees it in
its prompt, but it does read it. For anything that should change code,
reply to the card yourself, or give the rule an agent with `edit`
access and a prompt that asks first, as in `deploy-failed`. To give the
agent a real checkout of your code, connect the repository with the
[GitHub integration](/docs/integrations-github) and clone it from
`https://github.int.exe.xyz/<owner>/<repo>.git`; the VM gets no token.

## What the CLI says

The CLI and default card strings are in Chinese. The ones you'll meet:

| Chinese | English |
|---|---|
| 装好了。 | Installed. |
| 事件发出去了，Agent 开始干活…… | Event sent; the agent is getting to work… |
| Agent 结束了这一轮，问了你一个问题。它现在不占进程、不花 Token。 | The agent finished this round and asked you a question. It isn't running or spending tokens now. |
| 【等你决定】#1 … / 【要你留意】 | [Your call] #1 … / [For your attention] |
| `回答：agent-autoloop answer 1 <序号>` | `Answer: agent-autoloop answer 1 <number>` |
| 收到，Agent 接着干。 | Got it; the agent is picking the work back up. |
| 等你 · 在跑 · 排队 · 今天做完 | Waiting on you · running · queued · finished today |
| 做完了 · 没跑成 · 待你处理 | Done · failed · needs you |
| 最近几轮 · 最近的卡片 · 定时 · 下次 | Recent rounds · recent cards · schedules · next run |
| 在线 · 可以用 · 系统服务在跑 · 中台 | Online · works · the service is running · the hub |
| 规则没问题 | The rules are fine |
| 来源：… | Source: … (the rule behind a card) |
| （推荐） | (recommended) |
| 别的想法 · 发送 | Something else · send (on the answer page) |
| 验签没过 · 要来源自己的密钥 | Signature check failed · a source key is needed |
| 备份好了 · 恢复好了 | Backed up · restored |

The hub's default "ask first" list (`askFirst`, which `rules explain`
shows as `先问你`) covers deleting data, stopping services, spending
money, messaging people, changing product direction, creating or rotating
keys, and changing permissions. It is part of the prompt, not a sandbox:
what actually limits an agent is its `access` (`read`, `edit` or `full`)
and the CLI's own sandbox.

<details id="back-up-and-restore" class="dp-details">
<summary>Back up and restore</summary>

Everything lives in `~/.agent-autoloop` on the VM's persistent disk:
`hub.db` (the event log and everything derived from it), `master.key`
(which signs card links), `config.json`, `rules.json` and `secrets.env`.
The project's backup command copies all five, safely, while the hub
runs. On the VM:

```bash
agent-autoloop backup
```

It prints `备份好了：` ("Backed up:") and a folder in
`~/.agent-autoloop/backups/`. The files hold your keys, so copy that
folder somewhere safe off the VM, from your computer:

```bash
scp -r my-agent-autoloop.exe.xyz:.agent-autoloop/backups ./agent-autoloop-backups
```

To restore, stop the hub first; `restore` puts the old files aside in
`~/.agent-autoloop/restore-before-…`:

```bash
systemctl --user stop agent-autoloop
agent-autoloop restore ~/.agent-autoloop/backups/<folder> --yes
systemctl --user start agent-autoloop
```

The CI key in `ci.key` isn't in the backup; the hub keeps only its hash,
and the restored hub accepts the same key. For a copy of the whole VM,
agents' sessions and your project included, run `ssh exe.dev cp
my-agent-autoloop my-agent-autoloop-backup` on your computer.

</details>

<details id="update" class="dp-details">
<summary>Update</summary>

Agent Autoloop releases often, sometimes daily. On the VM, this moves to
the newest release tag and restarts the service:

```bash
agent-autoloop update
agent-autoloop --version
```

If a release changes the log's format, the first start rebuilds from the
log, which can take a while with a long history. Update the agents with
`sudo exeuntu update claude` and `sudo exeuntu update codex`, and Node.js
with `sudo apt-get update && sudo apt-get install --only-upgrade nodejs`.

</details>

<details id="troubleshooting" class="dp-details">
<summary>Troubleshooting</summary>

- **Logs:** `journalctl --user -u agent-autoloop -f` shows the hub and
  the worker (`[worker] run 5 (morning-brief) turn 1 started`).
  `agent-autoloop why <round>` tells the whole story of one round.
- **`Failed to connect to bus` from `service install`:** the shell has
  no `XDG_RUNTIME_DIR`, as in some non-interactive sessions. Run
  `export XDG_RUNTIME_DIR=/run/user/$(id -u)` and try again.
- **A change to `config.json` or `secrets.env` does nothing:** the hub
  reads them only at start. Run `agent-autoloop service install` to
  restart it. `rules.json` reloads by itself; if a rule is wrong, the hub
  keeps the old rules and sends a card saying why.
- **GitHub shows a 401 for its deliveries:** the secret in the webhook
  doesn't match `secrets.env`. A 404 means `share set-public` wasn't run
  or nginx isn't forwarding: `sudo nginx -t` and
  `curl -X POST http://localhost:8000/v1/in/github` on the VM.
- **No card in Slack or Discord:** `agent-autoloop doctor` names a
  channel whose last card didn't go through, and `status --json` has the
  error. A 404 from the integration means its webhook was revoked; run
  `integrations setup` again.
- **The card link asks me to sign in and then says no access:** the link
  is on the VM's private port; sign in with the exe.dev account that owns
  the VM, or share the VM with your team as in
  [Let your team answer](#let-your-team-answer). Links expire 7 days after the card is made; `agent-autoloop
  status` still lists unanswered cards.
- **`待你处理` ("needs you") in a round's result:** the agent hit
  something it may not do with its `access`. Claude Code's `edit` lets it
  edit files but not run shell commands such as `git commit`; give the
  agent `"access": "full"` only if you're sure what it can reach.

</details>

## Frequently asked questions

### Why run Agent Autoloop on a server instead of my laptop?

The hub only works while its machine is awake: a cron rule set for 8:00 doesn't fire on a closed laptop, and GitHub can't deliver a webhook to it. An exe.dev VM is always on, stays logged in to your agents, has an HTTPS address for webhooks, and keeps the hub's SQLite log on a persistent disk.

### The CLI prints Chinese. Is there an English version?

Not yet. The README is in English and Chinese, but CLI output and the default card strings are still Chinese; the project says they will be translated. Cards your agents write are in whatever language your prompt asks for. The [table below](#what-the-cli-says) gives English for the messages you'll see most.

### Can I approve cards from Slack or Discord with a button?

No. Slack, Discord, DingTalk and WeCom get text with a link; you answer on the page the link opens. Here that page is on the VM's private port, so only people signed in to exe.dev with access to the VM can answer: you, and your team once you share it. Feishu is the only channel with buttons.

### Can I use my Claude or ChatGPT subscription instead of the LLM integration?

Yes: remove what `exeuntu configure` wrote (`apiKeyHelper` and `env.ANTHROPIC_BASE_URL` in `~/.claude/settings.json`, and the `exe-llm` provider in `~/.codex/config.toml`), then run `claude auth login` or `codex login --device-auth` on the VM. The project's README points out that providers recommend API keys over personal plans for automated workloads.

### What exactly is public?

Only `POST /v1/in/github` and `POST /v1/events` on `https://my-agent-autoloop.exe.xyz/`, and only after you run `share set-public`. The first refuses anything not signed with your webhook secret; the second refuses anything without a source key. Every other path there is a 404, and the hub's own port, 3350, is behind exe.dev login.

### How much does it cost?

Agent Autoloop is free and open source (MIT). The VM is part of your exe.dev plan, and model usage through the [LLM integration](/docs/integrations-llm) is billed to your exe.dev account; `agent-autoloop status` shows tokens and cost for today and the past seven days. While an agent waits for your answer, no process runs and no tokens are spent.

### Can other computers do the work?

Yes. Make a worker key on the VM with `agent-autoloop key new worker <name>` and run the installer with `join` on the other machine, as the project's [configuration guide](https://github.com/KKKKhazix/agent-autoloop/blob/main/skills/agent-autoloop/SKILL.md) describes. Workers connect out to the hub, so they need no open port; the hub's address would have to be reachable from them.


## Related

- [Run Claude Code on a remote server](https://exe-staging.dev/deploy/claude-code.md): A computer for Claude. A breather for your laptop.
- [Run Codex on a remote server](https://exe-staging.dev/deploy/codex.md): A computer for Codex. An early night for your laptop.
- [Run GitHub Actions jobs on exe.dev, a fresh VM per job](https://exe-staging.dev/deploy/github-actions.md): Every job on a fresh copy of a warm VM, billed by the second.
- [Run Herdr agents on a remote machine](https://exe-staging.dev/deploy/herdr.md): An always-on SSH machine for Herdr, with agents ready and no API keys.
- [Run DeepSeek Harness on a remote server](https://exe-staging.dev/deploy/deepseek-harness.md): DeepSeek's agent in a browser tab, on a computer that never sleeps.
- [Self-host Hermes Agent](https://exe-staging.dev/deploy/hermes-agent.md): An agent that remembers you, on a computer that never sleeps.
