Run Antigravity CLI on an always-on server

Install Antigravity CLI#

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-antigravity
ssh my-antigravity.exe.xyz

On the VM, run Google's installer, which puts agy in ~/.local/bin and adds that folder to your PATH in ~/.bashrc and ~/.profile. Then make a project folder with Git, so you can review and undo what the agent changes, and a tmux session to work in later:

curl -fsSL https://antigravity.google/cli/install.sh | bash
export PATH="$HOME/.local/bin:$PATH"
agy --version
git init ~/project
tmux new -d -s agy -c ~/project

The installer's lines starting ERROR: logging before google.Init are noise; it ends with Antigravity CLI installed successfully. agy --version prints a version such as 1.4.12. Antigravity CLI updates itself in the background from then on.

Sign in with Google#

Sign in once, in your SSH session (not inside tmux, so the long sign-in link copies in one piece):

cd ~/project
agy

Choose Google OAuth (or Use a Google Cloud project for a business account). Antigravity CLI sees there's no browser on the VM and prints a https://accounts.google.com/... link. Open it on your computer, sign in, copy the code the page shows, and paste it at authorization code... in the terminal. Finish the first-run questions, then type /exit.

The VM has no system keyring, so Antigravity CLI keeps the sign-in in a file under ~/.gemini instead. The Remote Control daemon, headless runs and every later agy use it.

Keep it on with Remote Control#

Still on the VM, start the Remote Control daemon and name it after the VM:

agy remote-control start --name "$(hostname)"
agy remote-control status

start registers a systemd user service, antigravity-cli-daemon, and starts it. exe.dev VMs run user services without anyone logged in, so it comes back after a reboot and restarts itself after a crash. status shows the daemon and the instance name, my-antigravity.

On your phone or computer, open antigravity.google.com in a browser signed in to the same Google account. Under Remote Control Instances, my-antigravity shows as Online; tap Connect. On a phone you can add the page to your home screen to get a notification when an agent finishes or needs you.

Note

The daemon uses your Google sign-in, so it stops working if you sign out with /logout. Remote Control needs that sign-in: a Gemini API key has no account session, and Application Default Credentials (AGY_ADC_AUTH) aren't supported.

Give it a task from your phone#

In Remote Control, start a conversation in a project on my-antigravity with the ~/project folder in it, and give it a task. For example:

Build a tiny website for a lighthouse keeper who reviews passing ships, and serve it on port 8000.

The agent works on the VM; you answer its questions, approve commands and read the implementation plan and diff in the browser, then lock your phone. Open https://my-antigravity.exe.xyz/ to see what it built: like every port on the VM, it's private to you until you share it (HTTPS proxy).

For several tasks at once, choose new worktree mode when you start each conversation: every conversation then gets its own Git worktree, so agents don't trip over each other, much like Jules' parallel tasks.

Work on a GitHub repository#

The GitHub integration lets the VM clone and push a repository without a GitHub token on it. Connect your GitHub account on the Integrations page once, then, on your computer, add the repository (replace you/your-repo):

ssh exe.dev integrations add github --name your-repo \
  --repository you/your-repo --attach vm:my-antigravity

On the VM, clone it and tell Git who you are:

git clone https://github.int.exe.xyz/you/your-repo.git ~/your-repo
git config --global user.name "Your Name"
git config --global user.email you@example.com

Add ~/your-repo to a project in Remote Control and ask for a change and a pull request. The preinstalled gh goes through the same integration when GH_HOST points at it:

Fix the flaky date test on a new branch, commit it, push the branch, and open a pull request with GH_HOST=github.int.exe.xyz gh pr create.

Pushes show up as the exe.dev GitHub App; add --act-as-user to the integrations add command to push as yourself. Put standing instructions, such as how to set up and test the project, in an AGENTS.md at the top of the repository; Antigravity reads it, as it does GEMINI.md.

Coming from Jules#

Your code, branches and pull requests are in GitHub already. What lives only in Jules (settings, environment variables, scheduled tasks, memories, setup scripts and every session's prompt, plan, log and patches) can be exported with Jules Tools until December 31. Google's Jules Turndown post has the steps: on your computer, run

npm install -g @google/jules
jules login

then paste the export prompt from that post into a coding agent such as Claude Code, started in your home folder. It writes everything to ~/jules-export, with a summary.md per session. env-variables.json in there holds your environment variable values, so keep the folder private.

Here's where each Jules habit goes on the VM:

• Assign a task and get a pull request: Remote Control plus the GitHub integration, as above.
• Setup scripts: run them once on the VM. Installed packages and toolchains stay on its disk, so later tasks start ready. Put the test command in AGENTS.md.
• Environment variables: non-secret ones in ~/.profile. For API keys, an exe.dev HTTP proxy integration adds the key to requests on the way out, so it never sits on the VM.
• Memories: copy what still matters into AGENTS.md, or use /learn in a conversation to turn a correction into a saved rule.
• Scheduled tasks: a cron job with headless agy -p; see the next section.
• Old sessions: to let the agent read your old plans, copy the export to the VM without the secrets file. On your computer: rm ~/jules-export/env-variables.json && scp -r ~/jules-export my-antigravity.exe.xyz:

Run tasks on a schedule#

agy -p runs one prompt with your saved sign-in and exits, which makes it a tool for cron. Run crontab -e on the VM and add, for example, a review at 06:00 UTC every weekday (cron doesn't read your PATH, hence the full path):

0 6 * * 1-5 cd ~/project && ~/.local/bin/agy -p "List the TODOs in this repo, most urgent first" >> ~/agy-todos.log 2>&1

In headless mode the agent may read and edit files in the folder, but commands that would need your approval are refused, and it says which on stderr. Allow the ones a job needs with rules in ~/.gemini/antigravity-cli/settings.json, for example:

{
  "permissions": {
    "allow": ["command(git)", "command(regex:npm run (build|lint|test))"]
  }
}

On a VM you can copy and throw away, --dangerously-skip-permissions approves everything for one run. --output-format json returns the answer in response plus a status; a run that fails exits non-zero. Google's headless mode guide has the rest, including --model and --print-timeout.

At the keyboard#

The terminal UI works over SSH too. On your computer:

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

Inside tmux, run agy. Press Shift+Tab to cycle through modes (accept edits, plan), and type /help for the rest. Detach with Ctrl-b, then d; the session keeps running. To pick up this terminal session on your phone, type /remote-control in it: it prints a link to the conversation. That link lasts as long as the session; the daemon is separate and stays on.

Use a Gemini API key instead#

https://exe.dev/integrations/add?service=gemini&attach=vm:my-antigravity

curl -fsS https://gemini.int.exe.xyz/v1beta/models | jq -r '.models[0].name'

cat >> ~/.profile <<'EOF'
export GOOGLE_GEMINI_BASE_URL=https://gemini.int.exe.xyz
export GEMINI_API_KEY=added-by-exe-dev
EOF
. ~/.profile

cd ~/project
agy --settings '{"modelProvider":"gemini"}' --model gemini-3.8-flash-low -p "Reply with exactly: OK"

Troubleshooting#

• Error: not signed in: run agy, sign in, then run agy remote-control start: sign in first, as in "Sign in with Google".
• Authentication required. Please visit the URL to log in from a headless run or cron job: the VM isn't signed in, or the sign-in expired. Run agy over SSH and sign in again.
• The VM isn't listed under Remote Control Instances, or isn't Online: run agy remote-control status, and check the browser uses the same Google account as the VM. journalctl --user -u antigravity-cli-daemon -n 50 shows the daemon's log.
• Remote control is not enabled for your account.: your account or organization doesn't allow Remote Control. Check with your workspace admin or plan.
• A new name doesn't show: the daemon reads it at start; run agy remote-control start --name <name> again.
• agy: command not found: open a new SSH session, or run export PATH="$HOME/.local/bin:$PATH".
• A headless run lists denied_actions or says it refused a command: add an allow rule for it, as in "Run tasks on a schedule".
• GEMINI_API_KEY errors with the API key setup: the variables aren't in the environment of that run. Antigravity CLI doesn't read .env files.

For more, see Google's CLI troubleshooting. The CLI's own log is ~/.gemini/antigravity-cli/cli.log.