Run Aider on a remote server

Start coding#

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

ssh exe.dev new --name=my-aider
ssh my-aider.exe.xyz

On the VM, install aider with uv, as aider's install guide suggests. The browser extra adds the optional browser version:

uv tool install --force --python python3.12 --with pip "aider-chat[browser]~=0.86"
aider --version

It prints aider 0.86.2 or later. Now point aider at exe.dev's LLM gateway. The keys are placeholders: the gateway adds the real credentials on the way out. The second file describes models newer than aider itself; without it, aider sends them settings they reject:

cat > ~/.aider.conf.yml <<'EOF'
# Models come from exe.dev's LLM integration; the keys are placeholders.
model: sonnet
alias:
  - sonnet:anthropic/claude-sonnet-5-5
  - opus:anthropic/claude-opus-5-5
  - haiku:anthropic/claude-haiku-5-5
  - gpt:openai/gpt-6.1-sol
  - luna:openai/gpt-6-luna
api-key:
  - anthropic=exe-gateway
  - openai=exe-gateway
set-env:
  - ANTHROPIC_API_BASE=https://llm.int.exe.xyz
openai-api-base: https://llm.int.exe.xyz/v1
EOF
cat > ~/.aider.model.settings.yml <<'EOF'
# How to talk to models newer than aider.
- name: anthropic/claude-sonnet-5-5
  edit_format: diff
  weak_model_name: anthropic/claude-haiku-5-5
  use_repo_map: true
  use_temperature: false
  cache_control: true
  extra_params:
    max_tokens: 64000
- name: anthropic/claude-opus-5-5
  edit_format: diff
  weak_model_name: anthropic/claude-haiku-5-5
  use_repo_map: true
  use_temperature: false
  cache_control: true
  extra_params:
    max_tokens: 64000
- name: anthropic/claude-haiku-5-5
  edit_format: diff
  weak_model_name: anthropic/claude-haiku-5-5
  use_repo_map: true
  use_temperature: false
  cache_control: true
  extra_params:
    max_tokens: 64000
- name: openai/gpt-6.1-sol
  edit_format: diff
  weak_model_name: openai/gpt-6-luna
  use_repo_map: true
  use_temperature: false
  accepts_settings: [reasoning_effort]
- name: openai/gpt-6-luna
  edit_format: diff
  weak_model_name: openai/gpt-6-luna
  use_repo_map: true
  use_temperature: false
  accepts_settings: [reasoning_effort]
EOF

Aider commits every change it makes, so tell git who you are. This uses the email address of your exe.dev account, from the VM's reflection integration; run the same git config commands with other values if your GitHub account uses a different one:

email=$(curl -s https://reflection.int.exe.xyz/email | jq -r .email)
git config --global user.email "$email"
git config --global user.name "${email%@*}"
git config --global user.email

It prints your address. Make a project, give it a first commit (aider compares each change with the commit before it), and open a tmux session:

git init ~/project
git -C ~/project commit --allow-empty -m "Start project"
tmux new -A -s aider -c ~/project

Inside that session, start aider:

aider

The first time, it offers to add .aider* to .gitignore, which keeps its chat history out of your commits: answer Yes. The header shows Main model: anthropic/claude-sonnet-5-5. Give it a small task. For example:

Build a tiny website for a bakery that only sells one kind of bread.

Aider writes the files and commits them. Type /diff to see what changed, /undo to throw the last change away, and /help for the rest of its commands. Your files live in ~/project.

Take a break#

Press Ctrl-b, then d to detach. Aider stays running on the VM when you disconnect, with the chat as you left it. On your computer, use this command to hop back in:

ssh -t my-aider.exe.xyz 'tmux new -A -s aider -c ~/project'

A VM restart ends the running session, but not your files, commits, or chat log. Reconnect and run aider --restore-chat-history from your project's folder on the VM to pick up the conversation.

Work on a GitHub repo#

The GitHub integration lets the VM clone and push a repository with no GitHub token on the VM. Link your GitHub account on the Integrations page, then give this VM one repository. On your computer, with your repository in place of you/myapp:

ssh exe.dev integrations add github --name myapp --repository you/myapp --attach vm:my-aider

On the VM, clone it through the integration and work on a branch:

git clone https://github.int.exe.xyz/you/myapp.git ~/myapp
cd ~/myapp
git switch -c aider-changes
tmux new -A -s myapp -c ~/myapp

Run aider in that session and ask for a change. Name the files it should edit, or let it find them with its repository map. When you're happy, push the branch and open a pull request with gh, which goes through the same integration:

git push -u origin aider-changes
GH_HOST=github.int.exe.xyz gh pr create --fill --repo you/myapp

Commits carry your git identity, with (aider) added to the author name of the ones aider wrote. Pushes and the pull request show up as exe-dev-github-integration[bot] unless you add --act-as-user to the integration.

Let it make VMs#

Aider doesn't use MCP, so it can't connect to exe.dev's MCP server the way Codex or Claude Code can. But aider can suggest shell commands and run them when you say yes, and ssh exe.dev is a shell command. Give the VM an SSH key of its own for exe.dev. On the VM:

ssh-keygen -q -t ed25519 -N "" -C "aider-$(hostname)" -f ~/.ssh/exe_aider
grep -qs '^Host exe.dev' ~/.ssh/config || cat >> ~/.ssh/config <<'EOF'
Host exe.dev *.exe.xyz
  IdentityFile ~/.ssh/exe_aider
  StrictHostKeyChecking accept-new
EOF

On your computer, add that key to your exe.dev account, limited to VMs tagged aider and to a few commands, for 30 days:

ssh my-aider.exe.xyz cat .ssh/exe_aider.pub |
  ssh exe.dev ssh-key add --tag=aider --exp=30d '--cmds="help,whoami,ls,new,rm,ssh,stat,share show"'

VMs the key creates get the tag aider; your other VMs are "not found" to it, and it can't make anything public. Back on the VM, ssh exe.dev whoami shows the key as current. Now ask aider for something that needs a machine of its own:

Make a new exe.dev VM with ssh exe.dev new, install PostgreSQL on it, and check that it's running.

Aider lists the commands it wants to run and asks before it runs them, even with --yes-always, so nothing runs without you. Answer Yes to run them, and yes again to show aider the output. To revoke the key, run ssh exe.dev ssh-key remove aider-my-aider on your computer.

Open it in your browser#

Aider also has an experimental browser version: a chat page for one project. To run it for ~/project all the time, on the VM:

sudo tee /etc/systemd/system/aider-browser.service >/dev/null <<'EOF'
[Unit]
Description=Aider in the browser, for ~/project
After=network-online.target
Wants=network-online.target

[Service]
User=exedev
WorkingDirectory=/home/exedev/project
ExecStart=/home/exedev/.local/bin/aider --browser
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF
sudo systemctl daemon-reload
sudo systemctl enable --now aider-browser

Then open https://my-aider.exe.xyz:8501/. exe.dev asks you to log in, because port 8501 is private to people with access to the VM. Ask for a change as in the terminal; aider edits and commits the same way.

The browser version and a terminal aider each keep their own chat, so give one project to one of them at a time. To use it for another project, change WorkingDirectory and run sudo systemctl restart aider-browser.

Warning

Anyone who can open port 8501 can change your code. Leave it private.

Make yourself at home#

• Pick a model: type /model opus, /model gpt or /model luna in aider, or start it with aider --model haiku for quick, cheap work. Change model in ~/.aider.conf.yml to set the default. exe.dev keeps a list of available models and prices; aider's own cost figures are estimates.
• Plan with one model, edit with another: aider --architect --model opus --editor-model sonnet has the first model work out a change and the second apply it. See aider's chat modes.
• Edit in your own editor: open the VM in VS Code or code-server, start aider --watch-files, and write a comment ending in AI! in any file. Aider makes the change it describes. See IDE integration.
• Let it run your tests: aider --test-cmd "npm test" --auto-test runs your tests after each change and asks the model to fix what fails.
• Peek at your app: ask aider to make it listen on 0.0.0.0:8000, start it in a second tmux window (Ctrl-b, then c), and open https://my-aider.exe.xyz/. It's private by default. More about previews.
• Script it: aider --yes-always --message "Add type hints to utils.py" utils.py makes one change, commits it, and exits. See scripting aider.

For everything else, head to aider's docs.