AirLLM Developer Guide & setup docs

Set up and use every AirLLM product

Install steps, use cases, every feature, commands and troubleshooting for AirCode CLI, AirCode Studio and Air Router, in one place.

AirCode CLIThe AirCode coding agent in your terminal, for interactive work, scripts and CI.
- macOS
- Linux
- Windows
AirCode StudioA desktop app where the agent builds your app and Studio runs, checks and commits it.
- macOS
- Linux
- Windows
- Coming soon
- Get started
- 50 features
Air RouterRoute Claude Code, Codex, Cursor and other tools you already use through AirLLM.
- Any OS
- 3 API formats

Connecting Claude Code, Codex, Cursor or another tool? Get the setup script that sets them up in one run, or pick your tool for step-by-step setup on macOS, Linux and Windows.

Which product do I need?

All three run on one AirLLM account. Pick by where you want to work.

If you want to…	Use
Work with an AI agent in your terminal, scripts or CI	AirCode CLI
Build an app and watch it run in web, iOS or Android previews	AirCode Studio
Keep Claude Code, Codex, Cursor or another tool and route it through AirLLM	Air Router
Call AirLLM from your own backend or agent framework	Air Router (direct API)

Where you work

AirCode

AirCode CLI

AirCode Studio

One local engine and sign-in

Your tools and appsClaude Code, Codex, Cursor, frameworks, your code

AirLLM

Air RouterPicks the model for each step, trims repeated context, stops runaway loops

Models

Cloud model providers

AirGPUAirLLM’s own GPUs, for eligible routine work

Every request from AirCode or your own tools goes through Air Router.

Product 01

AirCode CLI

The AirCode coding agent in your terminal.

macOS
Linux
Windows

Product page

What is AirCode CLI for?

AirCode CLI is an AI coding agent that runs in your terminal. You describe a task in plain language, and the agent reads your code, plans the work, edits files, runs commands and tests, and reports back.

It is built for speed and for running many sessions at once. One small background process (aircode serve) holds every session, so you can open several terminals, close one, and pick the work up again later.

The same agent also runs without the interface (aircode run) for scripts and CI, and inside code editors that support the Agent Client Protocol. Models come from AirLLM, which picks the right model for each step of a task.

Get started with AirCode CLI

Install with one command, sign in with aircode login, then run aircode inside your project folder. Setup takes about five minutes.

Requirements

Platform	Supported
macOS	Apple Silicon and Intel
Linux	x86_64 with glibc 2.17 or newer (Alpine/musl is not supported)
Windows	Windows 11 x64 with PowerShell 5.1 or newer
Also needed	`curl` and `openssl` for the install script, a browser and your account email for sign-in; `git` is recommended

Install

macOS or LinuxInstall script
bash
```
curl -fsSL https://raw.githubusercontent.com/jettysoft/aircode-releases/main/install.sh | sh
```
Installs the latest AirCode release. The installer checks the download's signed checksum and installs to ~/.local/bin; aircode upgrade moves to newer releases later.
macOS or LinuxHomebrew
bash
```
brew install jettysoft/aircode/aircode
```
Update later with brew upgrade aircode.
WindowsPowerShell
powershell
```
irm https://raw.githubusercontent.com/jettysoft/aircode-releases/main/install.ps1 | iex
```
Installs the latest AirCode release to %LOCALAPPDATA%\aircode\bin and adds it to your PATH. The installer checks the download's signed checksum. The build is not code-signed yet, so SmartScreen may warn.

Steps

Install AirCode
Pick one of the install options above.
Check the install
bash
```
aircode --version
aircode doctor
```
If the command is not found, open a new terminal: the install script adds ~/.local/bin to your PATH.
Sign in
bash
```
aircode login
```
- The terminal shows a sign-in link and an 8-character connect code, and opens your browser.
- In the browser, sign in to AirLLM, choose the API key AirCode should use (it shares that key's plan and budget), type the connect code and approve. AirCode waits 5 minutes for your approval.
- AirLLM emails you a 6-digit code. Type it in the terminal at Enter the code:. The code stays valid for 10 minutes.
- You see ✓ AirCode is connected to <plan> and AirCode opens.
Open your project
bash
```
cd your-project && aircode
```
Or start from anywhere with aircode -C /path/to/project. AirCode asks Do you trust the files in this folder? once per folder.
Set up the project (optional)
Run /init to create an AIRCODE.md file with project instructions, and /model to pick a model. The default is airllm-auto.
Give it your first task
Type what you want in plain language and press Enter. For bigger changes, press Shift+Tab to switch to plan mode first.

Other ways to start

Goal	Command
One task without the interface	`aircode run "fix the failing test in src/cart.ts"` (add `--json` or `--ndjson` for machine output)
A read-only plan, no changes	`aircode run --plan "add rate limiting to the API"`
Repeat until tests pass	`aircode loop "make the tests pass" --until "npm test"`
Fix on every save	`aircode watch --check "npm test"`
Resume earlier work	`/resume` in the app, or `aircode --resume <id or name>`
Use from your editor	Point an ACP-compatible editor at command `aircode` with argument `acp`
Sign in over SSH or on a remote machine	`aircode login --no-browser` prints the link instead of opening a browser; you still type the emailed code
CI or a headless server	Set `AIRLLM_API_KEY`, or run `aircode login --api-key <key>` (no terminal needed; `aircode login` gives AirCode your plan details, so use it where you can)

Update and uninstall

Update

bash

aircode upgrade

Uninstall on macOS or Linux (keeps your settings; add --purge to remove everything)

bash

curl -fsSL https://raw.githubusercontent.com/jettysoft/aircode-releases/main/uninstall.sh | bash -s -- --yes

Installed with Homebrew? Uninstall with brew uninstall aircode. On Windows, run irm https://raw.githubusercontent.com/jettysoft/aircode-releases/main/uninstall.ps1 | iex. On macOS the install script also sets up two global hotkeys (Cmd+; opens AirCode in your home folder, Cmd+' in your last project); aircode setup-hotkey --uninstall removes them.

Install problems?

Homebrew fails on Command Line Tools. Repair Apple’s Command Line Tools, then install again:

bash

sudo rm -rf /Library/Developer/CommandLineTools
sudo xcode-select --install
brew install jettysoft/aircode/aircode

Checking a download. Every release ships a SHA256SUMS file next to the archives on the Releases page; check the archive against it.

Not available yet: Linux ARM64, Windows ARM64 and Alpine (musl) Linux.

Use cases for AirCode CLI

Learn a new codebase
Ask questions in read-only mode (/readonly); answers point to exact files and lines.
Build from an approved plan
Turn on plan mode, approve the plan, and let the agent edit and run checks.
Debug from the root cause
The agent confirms and names the root cause before it changes any code.
Get a failing suite green
Run aircode loop "make the tests pass" --until "npm test" with limits on iterations, time and cost.
Keep checks green while you code
aircode watch re-runs your checks on save and tries a fix when one fails.
Refactor safely
Use /refactor, and undo the agent's last edit with /revert if needed.
Review and commit
Review your changes with /review, then write clean commits with /commit.
Automate in CI and scripts
Use aircode run --ndjson, run --plan and loop exit codes in pipelines.
Research errors and docs
The agent searches the web and reads documentation pages inside the task.
Work from your editor
Connect an ACP-compatible editor with aircode acp.
Extend with team tools
Connect internal systems through MCP servers, add shared skills, and enforce rules with hooks.
Long-running work
Resume sessions across days, with memory that carries between sessions and search over past work.

AirCode CLI features

84 features in 13 groups: what each one does and how you use it.

Agent and models 11

Model picker
Chooses between four AirLLM models: airllm-auto (default), airllm-agent, airllm-anthropic and airllm-openai.
How/model, -m <model>, or Ctrl+Tab to cycle
Intelligent turn identification
Identifies what each turn of a session needs, so routine work can go to efficient models.
HowAutomatic
Agent loop with done check
Reads, edits, runs commands and checks results until the task is done, held to its own acceptance checklist.
HowAutomatic; /decomp on|off
Root-cause-first debugging
States the root cause before the first edit, and ends with Cause, Fix and Verified.
HowAutomatic for bug reports (off with /decomp off)
Automatic checks
Runs your project's checks after edits and feeds failures back to the agent.
HowDeclare in .aircode.toml [checks], or let AirCode find them (Cargo.toml, a package.json test script, pytest, a Makefile); approve once with /checks approve (applies to new sessions)
Progress notes and summary
Shows Found and Next notes as it works, and a Changed and Verified summary at the end.
HowAutomatic
Reasoning display
Shows the model's reasoning; sets the effort on models that offer effort levels.
How/reasoning off|full|current; Cmd+←/→ on macOS, Alt+←/→ elsewhere
Message queueing
Lets you type while the agent works; your message lands at the next safe point or after the turn.
HowCtrl+T toggles queue mode; Ctrl/Cmd+Enter sends the other way
Web research
Searches the web and reads pages during a task.
HowOn by default; AIRCODE_WEB_TOOLS=0 turns it off
Images and PDFs
Takes pasted images and reads images and PDFs.
HowCtrl+V or Alt+V to paste
Recovery
Gets a stuck turn moving again or resumes unfinished to-dos.
How/fix, /poke, Ctrl+R

Planning and modes 4

Plan mode
Researches without editing, writes a plan, then asks to implement it, keep planning or change it.
How/plan, Shift+Tab or aircode --plan; /plan go|off|abandon|status
Plan one prompt
Plans a single request without switching the whole session.
How/plan <prompt>
PLAN.md context
Uses a PLAN.md file in the repo as planning context.
HowAdd PLAN.md to the repo
Read-only mode
Investigates and answers without changing any file.
How/readonly [request] or Shift+Tab

Sessions and history 12

Session picker
Lists past sessions with project, status, last activity, messages, tokens and a 16-day activity strip; searchable and filterable.
How/resume, or aircode --resume
Crash resume
After an interrupted turn, asks before continuing; nothing is sent until you answer.
HowPress Enter to continue, Esc to leave it, or type a new message
Bookmark and rename
Saves and names sessions so they are easy to find.
How/save [label], /unsave, /rename
Fork
Copies the session into a new window.
How/fork [prompt]
Side question
Asks a quick question in a new session without derailing the current one.
How/btw <question>
Rewind
Rolls the conversation back to an earlier message.
How/rewind lists messages, /rewind N goes back to message N, /rewind undo restores
Undo agent edits
Restores files changed by the agent's last edit (not changes made by shell commands).
How/revert, /revert show, /revert undo
Session memory
Keeps up to 10M tokens of history on disk and recalls old turns instead of summarising them away.
HowOn by default; /session-memory
Search past work
Lets the agent search earlier turns and your past AirCode sessions.
HowAutomatic
Compaction
Summarizes older turns to free up context.
HowAutomatic only when session memory is off; /compact compacts now (summarizes everything older than the last 10 messages, and the session stays on compaction after that)
Continue all
Continues sessions that were interrupted.
How/continue
Replay and export
Replays a session, or exports it as timeline JSON or an MP4 video.
Howaircode replay <session> [--export|--video]. --export prints the timeline JSON (save it with > timeline.json). --video needs rsvg-convert (from librsvg) and ffmpeg on your PATH; AirCode checks for both before rendering and says how to install them.

Tools the agent uses 8

File tools
Reads, creates, edits and patches files; write creates new files only unless told to overwrite.
HowAutomatic
Code search
Greps, finds files, outlines and traces symbols across the repo.
HowAutomatic
Shell commands
Runs commands with a 120-second default timeout (600 max); a slow command moves to the background instead of being killed.
HowAutomatic; type !<cmd> to run one yourself
Background jobs
Starts long commands in the background and checks on them later (up to 8 per session, 2 hours each).
HowAutomatic, or Ctrl+B / Alt+B on a running tool
Parallel calls
Runs up to 10 tool calls at once.
HowAutomatic
To-do list
Tracks the steps of the task.
How/todos or Alt+X to view
Extended tools
Adds tools such as open, schedule, skill management and macOS computer use.
How[tools] extended = true in config
Tool selection
Limits which tools the agent may use.
How--tool-profile full|minimal|none, --tools, --disabled-tools

Safety and permissions 7

Folder trust
Asks once per folder before working there.
HowAnswer the prompt on first run
Git safeguard
Runs commit, push, tag, rebase, merge, reset, stash, clean, cherry-pick or revert only when your request names it or an active skill pre-approves it; loop and watch never change Git.
HowAutomatic
Permission prompts
Asks before writes outside the project, touching ~/.ssh, ~/.aws, ~/.config or other dotfiles, sending captured data off your machine, force-pushing, running a downloaded script, or changes when you only asked a question. A path you refuse stays refused.
HowYes, Yes for this session, Always (turns on admin mode), or No with a reason; /permissions ask|admin
Repo config approval
Keeps a repo's MCP servers, hooks and checks off until you approve them, and its skills off until you trust the folder.
Howaircode mcp approve, /hooks approve, /checks approve; skills: answer yes to the folder-trust prompt
Key protection
Removes your AirLLM key from the environment of shell commands, hooks and checks.
HowAutomatic
Delete guard
Refuses rm -r of /, ~, . or a drive root.
HowAutomatic
Encrypted channel
Encrypts request bodies sent to AirLLM.
How/encrypt on|off|status (off by default)

Project instructions and memory 6

AIRCODE.md
Loads project instructions from ~/.aircode/AIRCODE.md and from the repo root down to your folder; falls back to AGENTS.md.
How/init creates it; /context lists what loaded
Conventions files
Also loads the first it finds of .aircode/airskill.md, .aircode/taste.md, CLAUDE.md or .cursorrules, at the repo root and in your folder (none where AGENTS.md is used).
Howaircode init-airskill drafts airskill.md
Cross-session memory
Remembers facts between sessions and adds relevant ones to new requests.
HowOn by default; /memory, aircode memory list|search|export|import
Repo map
Gives the agent a symbol map of the repo (Rust, TS/JS, Python, Go, Java), up to about 6K tokens.
How/repomap on|off
Answer reuse
Answers a repeated read-only question from the saved answer when the files it relied on haven't changed.
HowOn by default; /answer_reuse status|on|learn
Code index
Builds a local code index in .aircode/index.db.
Howaircode index build|update|stats

Automation and headless 6

Headless run
Runs one task and exits, with text, JSON or NDJSON output.
Howaircode run "<task>" [--json|--ndjson]
Headless plan
Prints a plan or answer and changes nothing.
Howaircode run --plan "<task>"
Loop until green
Repeats until a check passes; caps at 10 iterations, $5 and 60 minutes by default; checkpoints each iteration on a Git branch and reverts regressions.
Howaircode loop "<goal>" --until "<cmd>"; exits 0 done, 2 capped or stalled, 130 cancelled, 1 error
Background loop
Runs a loop from inside the app.
How/loop <goal> --until "<cmd>", /loop status|stop|open
Watch mode
Re-runs a check on every save and tries one fix per failure, at most 12 fixes an hour.
Howaircode watch --check "<cmd>"; --dry-run never calls the model
Editor integration
Runs the agent inside editors that speak the Agent Client Protocol.
HowEditor command aircode, argument acp

Extensions 5

MCP servers
Connects external tools over HTTP or stdio; imports servers from Claude Code and Codex configs on first run.
Howaircode mcp add <name> --url … or aircode mcp add <name> -- <cmd> (--project writes .aircode/mcp.json); list, get, test, remove; /mcp. Also reads a repo's .mcp.json
Skills
Turns SKILL.md files into slash commands; on first run, imports skills from ~/.claude/skills and ~/.codex/skills.
HowPut each skill in its own folder with a SKILL.md: ~/.aircode/skills/<name>/SKILL.md for all projects, or .aircode/skills/<name>/SKILL.md in one project (.agents/skills and .claude/skills work too). Project skills load only in a folder you trusted (“Do you trust the files in this folder?”) or with AIRCODE_TRUST_PROJECT=1. /skills lists what loaded, what each skill runs without asking, and any project skills it skipped; /<skill-name> runs one.
Skill pre-approval
While a skill is active, the tools it lists in allowed-tools run without asking, as in Claude Code: it pre-approves, it never restricts. Every part of a chained command must match, and a command with $(…) or backticks is never pre-approved. Writes outside the project, credentials, data sends, force-push and running a downloaded script still ask. Skills in ~/.aircode/skills apply in every folder; a repo's skills only in folders you trust.
Howallowed-tools in the skill's front matter, as a comma list or a YAML list: Read, Edit, Write, Grep, Bash, Bash(git add:*), Bash(npm run *), Edit(docs/**), mcp__github; /skills shows them before you activate a skill
Hooks
Runs your scripts on 6 events (SessionStart, UserPromptSubmit, PreToolUse, PostToolUse, Stop, Notification); can block an action or send text to the model; Claude Code-compatible format.
How~/.aircode/hooks.json or .aircode/hooks.json; /hooks
Built-in workflows
Ready-made review, judge, test, improve, refactor and commit flows.
How/review, /judge, /autoreview, /autojudge, /test, /improve, /refactor, /commit

Terminal interface 11

Header tiles
Shows model, plan, tokens and a context gauge that turns amber at 80% and red at 95%.
HowAt the top of the chat
Inline diffs
Shows file changes inline, in full, pinned or per file.
How/diff off|inline|full|pinned|file, or Alt+G
Compact tool rows
Keeps tool output short until you expand it.
HowCtrl+O
Rich rendering
Renders Markdown, LaTeX and inline images in light, dark and 256-colour terminals.
HowAutomatic
Status line
Shows tokens per second, a rate-limit countdown, queued messages and prompt-cache warnings.
HowAlways visible
Shell escape
Runs a shell command yourself without leaving AirCode.
How!<cmd>
Copy tools
Copies code blocks with one key, or selects text in copy mode.
HowAlt+Shift+letter shown on a block's badge; Alt+Y for copy mode
Centered layout
Switches to a centered reading layout.
HowAlt+C
Desktop notifications
Notifies you when a long task finishes while AirCode is in the background (macOS and Linux).
HowAutomatic
Custom keys
Rebinds keys and detects conflicts with your terminal or OS.
How[keybindings] in config.toml; /keys
Auto-reconnect
Reconnects to the background server and keeps your typed input.
HowAutomatic

Configuration 3

Global config
Holds model, tools, plan, display, keybinding, hook and loop settings.
How~/.aircode/config.toml; /config shows it
Project config
Declares a repo's checks and loop settings.
How.aircode.toml with [checks] and [loop]
Feature switches
Shows the prefetch and session-memory switches.
How/features

Account and usage 4

Usage at a glance
Shows your plan and token totals.
HowHeader tiles; /cost, /status, /info, /context
Account commands
Signs in, signs out (which also quits AirCode) and shows credential status.
How/login, /logout, aircode auth status, aircode auth doctor --validate for sign-in problems
Health check
Checks your install: Git, the config folder, the code index and the version.
Howaircode doctor; /doctor also shows whether your key is set
Remote control
Lets an admin pause, resume, stop, send a prompt to or read your session (opt-in).
How--remote-control or /remote-control

Issue reporting 2

In-app report
Files a bug with session context and request ids; secrets are removed first.
How/report-issue <what went wrong>, then 1 (or Enter) to send
Command-line report
Files a report from the shell and queues it if the service can't be reached.
Howaircode report --title … --severity …; aircode report --retry

Updates and platform extras 5

Updates
Tells you when an update exists and installs it the right way for your install method.
Howaircode upgrade (--check only reports, for CI), /update; --auto-update to install automatically
Live server reload
Moves running sessions to a new binary after an upgrade.
Howaircode server reload
Local-only telemetry
Usage statistics never leave your machine.
HowAIRCODE_NO_TELEMETRY=1 or DO_NOT_TRACK=1 turns them off
macOS menu bar
Shows session counts in the menu bar.
Howaircode menubar
Hotkey, launcher and restore
Adds global hotkeys (Cmd+; and Cmd+' on macOS, set up by the install script) and a launcher entry, and reopens AirCode windows after a reboot.
Howaircode setup-hotkey, aircode setup-launcher, aircode restart save|restore

Commands

Run these from your shell, or type a slash command inside AirCode.

Terminal commands

Command	What it does
`aircode`	Start the app in the current folder
`aircode login`	Sign in to AirLLM (`--api-key <key>` stores a key for CI)
`aircode run "<task>"`	Run one task and exit (`--json`, `--ndjson`, `--plan`)
`aircode loop "<goal>" --until "<cmd>"`	Repeat until a check passes (`--max-iter`, `--max-cost`, `--max-minutes`)
`aircode loop list` / `loop report [id\|--last]` / `loop --resume <id>`	List loops / report on one / continue one
`aircode watch --check "<cmd>"`	Run a check on save and fix failures
`aircode acp`	Agent Client Protocol adapter for editors
`aircode mcp add\|list\|get\|remove\|test\|approve`	Manage MCP servers
`aircode checks list\|approve\|revoke`	Approve or withdraw project checks
`aircode memory list\|search\|export\|import\|stats`	Manage cross-session memory
`aircode index build\|update\|stats`	Manage the local code index
`aircode init-airskill`	Draft `.aircode/airskill.md`
`aircode session stats\|rename`	Session memory stats; rename a session
`aircode replay <session>`	Replay or export a session
`aircode report`	File an issue (`--retry` resends queued reports)
`aircode doctor` / `aircode version`	Health check / version
`aircode upgrade` / `aircode update`	Update AirCode (`--check` only reports)
`aircode auth status` / `auth doctor --validate`	Show credential status / diagnose sign-in
`aircode model list`	List models
`aircode server start\|reload\|stop --force`	Manage the background server
`aircode repl`	Plain prompt without the full-screen app
`aircode restart save\|restore\|status\|clear`	Save and reopen windows across a reboot
`aircode menubar` / `setup-hotkey` / `setup-launcher`	macOS menu bar, global hotkey, launcher entry

Global flags

Flag	What it does
`-C <dir>`	Working folder
`-m <model>`	Model
`--resume [id]`	Resume a session; with no id, list sessions
`--plan`	Start in plan mode
`--stdin-policy eof\|fail\|wait`	What a command that waits for input gets
`--tool-profile`, `--tools`, `--disabled-tools`, `--disable-base-tools`	Which tools the agent may use
`--remote-control`	Opt in to admin remote control
`--no-update` / `--auto-update`	Skip the update check / install updates automatically
`--trace` / `--quiet`	Tool input and output to stderr / no status output

Slash commands

Command	What it does
`/help`, `/hotkeys`, `/keys`	Help, shortcuts, key conflicts
`/model`	Pick a model
`/agents`	Model settings per agent role
`/subagent [--type] [--model] <prompt>`, `/subagent-model`	Run a subagent yourself; pick the model subagents use
`/plan [prompt]`, `/plan on\|off\|go\|status\|abandon`	Plan mode
`/readonly [request]`	Read-only mode
`/reasoning off\|full\|current`	Reasoning display
`/clear`, `/compact`, `/cancel`	Clear history, compact context, cancel the turn
`/rewind [N\|undo]`, `/revert [show\|undo]`	Go back to message N; undo the agent's last edit
`/fix`, `/poke`, `/todos`	Recover, resume to-dos, show the to-do card
`/diff`, `/git`, `/transcript`	Diff mode, Git status, open the transcript
`/review`, `/judge`, `/autoreview`, `/autojudge`	Review and judge
`/test`, `/improve`, `/refactor`, `/commit`	Built-in workflows
`/loop <goal> --until "<cmd>"`, `/loop status\|stop\|open`	Background loop
`/resume`, `/save`, `/unsave`, `/rename`	Sessions
`/fork [prompt]`, `/btw <question>`	New session from this one
`/continue`	Continue interrupted sessions
`/memory`, `/session-memory`, `/repomap`, `/answer_reuse`, `/decomp`, `/features`	Feature switches
`/permissions status\|ask\|admin`	Permission mode
`/checks [approve\|revoke]`, `/hooks [approve\|reload]`, `/mcp`, `/skills`, `/<skill-name>`	Checks, hooks, MCP, skills (and what each skill runs without asking)
`/encrypt on\|off\|status`	Encrypted channel
`/remote-control`	Opt in to admin remote control
`/init`	Create or update `AIRCODE.md`
`/context`, `/info`, `/status`, `/cost`	Context and usage
`/doctor`, `/config`, `/log`, `/version`, `/changelog`	Diagnostics
`/auth`, `/login`, `/logout`	Account
`/report-issue`	File an issue
`/reload`, `/restart`, `/update`, `/quit`	App lifecycle

Keyboard shortcuts

Key	Action
Enter / Shift+Enter	Send / new line
Ctrl+Enter or Cmd+Enter	Send with the opposite queue mode while the agent works
Ctrl+T	Toggle queue mode
Shift+Tab	Cycle normal, plan and read-only mode
Ctrl+Tab / Ctrl+Shift+Tab	Next / previous model
Esc	Close a panel, interrupt a turn, or clear the input (Ctrl+Z restores)
Ctrl+C / Ctrl+D	Interrupt; press twice when idle to quit
Cmd+←/→ (macOS) or Alt+←/→	Reasoning effort, on models that offer levels
Ctrl+Y	After an error, accept the offer to switch model and resend
Ctrl+S / Ctrl+↑	Stash or restore your draft / take back a queued message to edit
Ctrl+O	Expand or collapse tool output
Ctrl+B or Alt+B	Move the running tool to the background
Ctrl+P / Ctrl+R	Auto-poke / recover without tools
Ctrl+V or Alt+V	Paste text or an image
Alt+G / Alt+X / Alt+C / Alt+Y	Diff mode / to-do card / centered layout / copy mode
Cmd+B (macOS) or Alt+R	Session picker
`!<cmd>`	Run a shell command

Files and environment variables

Path or variable	What it holds
`~/.aircode/` (or `$AIRCODE_HOME`)	`config.toml`, `mcp.json`, `hooks.json`, global `AIRCODE.md`, sessions, memory, skills, logs, loops, pending reports, trusted folders
`airllm.env` in the config folder	Your AirLLM key (`~/Library/Application Support/aircode/` on macOS, `~/.config/aircode/` on Linux, `%APPDATA%\aircode\` on Windows; `$AIRCODE_HOME/config/aircode/` if set)
Repo files	`AIRCODE.md` or `AGENTS.md`, `PLAN.md`, `.aircode.toml`, `.aircode/` (mcp.json, hooks.json, skills, airskill.md, taste.md), `.mcp.json`
`AIRLLM_API_KEY`	AirLLM key for CI and headless machines
`AIRCODE_MODEL`, `AIRCODE_PERMISSIONS`, `AIRCODE_STDIN_POLICY`	Default model, permission mode, stdin policy
`AIRCODE_TRUST_PROJECT`, `AIRCODE_NO_HOOKS`, `AIRCODE_NO_CHECKS`	Trust the repo's MCP servers, hooks, skills and prompt overlays for one run and skip the trust prompt (checks still need approval; project skills also load in any folder you trusted); turn off hooks or checks
`AIRCODE_WEB_TOOLS=0`, `AIRCODE_NO_REPOMAP`, `AIRCODE_SESSION_MEMORY`	Turn off web tools or the repo map; session memory switch
`AIRCODE_AUTO_UPDATE`, `AIRCODE_NO_TELEMETRY`	Auto-install updates; turn off local telemetry
`AIRCODE_INSTALL_DIR`, `AIRCODE_VERSION`	Install folder and version for the install script

Product 02

AirCode Studio

Build, run, verify and commit apps with the AirCode agent, in a desktop app for macOS, Windows and Linux.

macOS
Linux
Windows

Coming soonProduct page

What is AirCode Studio for?

AirCode Studio is a desktop workspace where an AI agent builds your app and you watch it run. You describe a change in chat, the agent edits the project on your disk, and Studio builds and runs the result next to the conversation.

Studio runs web apps in a built-in preview, iOS apps in the Simulator and Android apps in the Emulator. It checks that the app builds and renders. You then review the diff, stage it and commit, all in the same window.

Under the hood Studio uses the same agent engine and AirLLM sign-in as AirCode CLI. It adds the visual layer: projects, previews, verification, Git review, a file editor and a terminal.

Get started with AirCode Studio

AirCode Studio is coming soon for macOS, Windows and Linux. Once it is out you install the app, sign in with your AirLLM account and open a project. The tools below are only needed for the previews you use, and shortcuts are shown as on macOS.

Requirements

Need	For
macOS, Windows or Linux	Studio is a desktop app for all three (coming soon)
Node.js and npm, pnpm, yarn or bun	Web previews
Python 3	The Test app browser check
Xcode	iOS Simulator previews (Xcode runs on macOS only)
Android SDK	Android previews (Studio can download it for you)

Steps

Install AirCode Studio
Coming soon
Studio is not released yet. It is coming to macOS, Windows and Linux.
Sign in
- Open Settings (⌘,) → Account → Sign in with AirLLM.
- A browser window opens. Approve the request and choose your key.
- Type the six-digit code AirLLM emails you into Studio.
- Already signed in to AirCode CLI? Studio uses that sign-in automatically.
To use a local model or another compatible API instead, go to Settings → Providers and enter a profile name, base URL, model ID and optional key.
Open a project
In the sidebar choose Open folder, or New project and pick Blank project or Basic web starter. New projects start as a Git repo on main.
Ask for your first change
Type in the Ask for a change… box, keep airllm-auto or pick a model, attach screenshots if useful, and press ⌘Enter.
- Answer any approval or question the agent raises.
- For larger tasks Studio shows Plan ready. Choose Build this plan to start the work.
Run the app
- Web: the preview starts by itself when Studio finds a dev script or a static site. Otherwise choose Start preview.
- iOS or Android: choose the target, device and scheme or variant, then Run. The first time, a setup dialog offers to download anything missing.
Check and commit
Optionally run Test app (web only). Then open Changes, stage what you want and commit.

Use cases for AirCode Studio

Idea to running app
Start from an empty folder, describe the app, and let the agent pick the stack and build it.
Feature work in an existing repo
Open a local project and ask for a feature or a bug fix.
Web apps with live preview
Build with Vite, Next, Astro and similar tools, and check the result at desktop, tablet and phone widths.
Native iOS apps
Build a SwiftUI or Xcode app and launch it in the iOS Simulator.
Native Android apps
Build a Gradle app and launch it in the Emulator, without installing the Android SDK by hand.
Cross-platform apps
Iterate on Flutter, React Native, Capacitor or Cordova apps, with hot reload or fast refresh after each change.
UI polish
Refine screens turn by turn with the running app beside the chat.
Automated click-through
Let the agent walk a web flow such as sign-up or a form, and save screenshots as evidence.
One-click error repair
Send a blank page or runtime error straight back to the agent to fix.
Reviewed commits
Review the agent's changes section by section, resolve conflicts, and commit to a local branch.
Side-by-side terminal
Run your own commands in terminal tabs next to the agent.
Usage tracking
See your weekly AirLLM allowance and plan without leaving the app.

AirCode Studio features

50 features in 10 groups: what each one does and how you use it.

Workspace and sessions 6

Projects sidebar
Lists your local projects, sorted by recent chat or by name.
HowOpen folder or New project in the sidebar
New project templates
Creates a folder as a Git repo on main.
HowNew project → Blank project or Basic web starter
Multiple sessions
Keeps several chats per project; rename, archive and browse archived ones.
HowSidebar, or /new and /resume
Workspace panel
Opens Preview, Changes, Files and Terminal on the right; remembers tab, width and visibility per project.
HowClick a panel tab
Slash commands
14 commands for navigation and status.
HowType / in the chat box
Appearance
System, light or dark theme, 4 text sizes and 15 accent colours.
HowSettings → Appearance

Agent chat 9

Live progress
Shows the running tool, a timer and the current plan step.
HowAutomatic during a turn
Tool timeline
Folds finished tool calls under the turn, each labelled with the model's reason for it.
HowExpand a turn to see its steps
Clear final answer
Shows the final answer prominently and folds the agent's self-check into "details".
HowAutomatic
Image attachments
Attaches up to 4 PNG, JPEG or WebP images, 3 MB each.
HowAttach in the chat box
Approvals
Lets you allow an action once, for the session, always, or deny it.
HowButtons on the approval card
Agent questions
Lets the agent ask you for input mid-task.
HowAnswer in the card
Stop, retry, edit
Stops a turn, retries after a provider error, or edits and resends a past message.
HowStop, Retry request, or edit a message
Copy
Copies a whole reply or one code block.
HowCopy button on the reply or block
Saved drafts
Keeps unsent text, model choice and attachments per session after relaunch.
HowAutomatic

Models and account 5

Model picker
Chooses airllm-auto (default), airllm-agent, airllm-anthropic or airllm-openai.
HowPicker next to the chat box, or /model
Project default model
Sets the model new chats in a project start with.
HowSettings → General → Default model
Sign in with AirLLM
Browser approval plus a six-digit emailed code; shares the CLI's sign-in.
HowSettings → Account, or /auth
Custom provider
Connects a local model or a compatible API.
HowSettings → Providers
Usage and billing
Shows weekly allowance used, limit, remaining, reset time, requests and tokens.
HowSettings → Usage & billing, or /cost; Manage billing opens the website

Plans 2

Plan approval
Shows Plan ready when the agent proposes a plan and waits for you.
HowBuild this plan to approve
Stage rail
Shows Plan → Build → Check → Review above the chat box while a plan runs.
HowAutomatic

Web preview 6

Framework detection
Recognises Vite, Next, Astro, Nuxt, Remix, Angular, Create React App and static index.html; installs missing packages with the project's npm, pnpm, yarn or bun.
HowAutomatic, or Start preview
Per-project ports
Gives each project its own port and never stops another project's server.
HowAutomatic
Device widths
Switches between Desktop, Tablet (768 px) and Phone (390 or 360 px).
HowWidth buttons on the preview
Share the preview
Copies the preview URL or opens it in your browser.
HowCopy URL, Open in browser
Preview settings
Sets a custom dev command (with a {port} placeholder) and a port.
HowPreview settings
Auto-recovery
Restarts a crashed dev server once; stops background previews after 20 minutes.
HowAutomatic

Native preview 7

iOS Simulator
Finds the Xcode project, builds unsigned, installs, launches, screenshots and shows a filtered log.
HowPick scheme and device → Run
Android Emulator
Builds a debug variant with the Gradle wrapper, installs, launches, screenshots and shows adb logcat.
HowPick variant and device → Run
Cross-platform support
Runs Flutter with hot reload, starts Metro for React Native, and syncs Capacitor or Cordova before building.
HowRun on a detected project
Smart refresh
After each agent turn, picks the quickest update: fast refresh, hot reload or full rebuild.
HowOn by default; toggle in Settings → General → Auto-update preview
Live Mirror
Streams the Simulator or Emulator screen into Studio, with optional touch input.
HowTurn on Live Mirror; grant Screen Recording and Accessibility access
One-click toolchain setup
Downloads a private Java runtime, Android SDK and emulator into ~/.aircode/android, or finishes Xcode first-launch steps.
HowAccept the setup dialog on first run
Device controls
Opens Simulator, wakes the Emulator, takes a screenshot, shows build output and preview info.
HowButtons on the native preview

Verification 5

Build check
Runs the project's own build script and trusts the real exit code, with a 3-minute limit.
HowAutomatic after changes
Render check
Confirms the web page loads, shows content and has no uncaught errors; reports Ready to review, Review needed or Build blocked.
HowAutomatic after web edits
Repair with agent
Sends a blank-page or error report back to the agent; never starts a paid repair on its own.
HowRepair with agent
Build follow-ups
Offers next steps after a build: ask for a summary, open the preview, check output, run checks again, or continue building.
HowButtons above the chat box
Test app
The agent drives the web preview: it navigates, clicks, fills forms, asserts and takes screenshots, saved under evidence/<session>/.
HowTest app (web only; up to 60 actions, 8 screenshots, 10 minutes)

Git review 4

Changes panel
Shows per-file diffs and lets you stage whole files or single sections.
HowChanges panel, or /git
Conflict handling
Labels conflicted files; commit stays disabled until all are resolved.
HowFix in Files → Mark resolved & stage
Commit
Commits staged changes with a per-repo author name and email.
HowCommit in Changes
Branches
Finds, creates and switches local branches, including tracking a remote branch.
HowBranch button in the Changes header

Files and terminal 2

File editor
Edits UTF-8 files up to 1 MB, saves atomically, and warns when the file changed on disk.
HowFiles panel, or /files
Terminal
Up to 24 login-shell tabs with a clean-shell option and 5,000 lines of scrollback.
HowTerminal panel, or /terminal

Engine and storage 4

Shared local engine
Runs or reuses aircode serve, so tasks keep running after you close the window.
HowAutomatic; Reconnect session reattaches without resending
Local workspace store
Saves projects, sessions and chats in ~/.aircode/studio/workspace.json; no cloud sync.
HowAutomatic
MCP servers
Lists the MCP tool servers connected to the session.
How/mcp
Status
Shows the session's state, model and mode.
How/status

Commands and shortcuts

Type / in the chat box to see the commands. Names in brackets also work. Shortcuts are shown as on macOS.

Slash commands

Command	What it does
`/model` (`/models`)	Pick a model
`/git`	Open Changes
`/preview`	Open the web, iOS or Android preview
`/files`	Open the file browser
`/terminal`	Open the terminal
`/auth` (`/login`)	Account and sign-in status
`/cost` (`/usage`)	Usage and billing
`/mcp`	Connected MCP servers
`/status`	Session state, model and mode
`/rename`	Rename the session
`/resume` (`/sessions`)	Browse this project's sessions
`/new`	New session
`/cancel`	Stop the running task
`/help`	List Studio commands

Keyboard shortcuts

Key	Action
⌘,	Open Settings
⌘Enter	Send a message
Esc	Leave Settings, close a dialog or the model menu
↑ ↓	Move between models in the model menu
⌘C · ⌘X · ⌘V	Copy, cut and paste in the chat box, editors and terminal

Product 03

Air Router

The routing layer between your coding tools and the models.

Any OS
Anthropic + OpenAI APIs

Product page

What is Air Router for?

Air Router is AirLLM's intelligent routing layer for AI coding agents. You keep the coding tool you already use — Claude Code, Codex CLI, Cursor, AirCode or another compatible client — and point it at AirLLM with a base URL and your API key.

Air Router then handles each request on its way to the model. Routine agent steps go to faster models while stronger models are kept for demanding work, existing prompt caches are taken into account, repeated context is trimmed, and it is designed to stop runaway agent loops.

Air Router is not a coding agent itself: it sits between your agent and the models. AirCode CLI and AirCode Studio already use it, with nothing to configure.

Get started with Air Router

Create a key, connect your tool, and send a test prompt. AirCode CLI and Studio need none of this; they are connected when you sign in.

Get an API key
Sign in to the AirLLM dashboard and create a key under API Keys.
Connect your tool
Two ways; most people start with the script.
FastestSetup scriptOne file for macOS, Linux or Windows sets up Claude Code, Codex, OpenCode, Aider, Copilot CLI and agent frameworks, and prints the rest.Get the script Step by stepPick your toolChoose your tool and system and follow its steps: Claude Code, Cursor, Cline, Xcode and 9 more.Choose your tool
Verify
Send a test prompt from your tool, for example Write a simple Java method to validate an email address. The setup works when the request appears in your AirLLM usage logs with the expected route and model, and the tool gets a response. The checklist walks through it.

API styles

Anthropic-style tools such as Claude Code use the bare domain and add /v1/messages themselves. OpenAI-style tools use /v1 and call /chat/completions or /responses. Each tool’s steps below already use the right one.

Anthropic-style Claude Code and Anthropic-compatible tools

Base URL: https://api.airllm.ai/
Route: /v1/messages (the tool adds it)
Model: airllm-auto
Auth: AirLLM API key

env

ANTHROPIC_BASE_URL="https://api.airllm.ai/"
ANTHROPIC_AUTH_TOKEN="your_airllm_api_key"
ANTHROPIC_MODEL="airllm-auto"
ANTHROPIC_DEFAULT_HAIKU_MODEL="airllm-auto"
ANTHROPIC_DEFAULT_SONNET_MODEL="airllm-auto"
ANTHROPIC_DEFAULT_OPUS_MODEL="airllm-auto"
ANTHROPIC_DEFAULT_FABLE_MODEL="airllm-auto"
CLAUDE_CODE_SUBAGENT_MODEL="airllm-auto"
CLAUDE_CODE_SUBAGENT_MODEL_FORCE="1"
API_TIMEOUT_MS="3000000"
CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC="1"

The extra model lines make Claude Code’s background tasks and subagents use airllm-auto too; without them those requests fail with “model not found”.

OpenAI-style Codex, Cursor, OpenCode, Aider, Cline, frameworks and more

Base URL: https://api.airllm.ai/v1
Route: /chat/completions or /responses
Model: airllm-auto
Auth: Bearer AirLLM API key

env

OPENAI_BASE_URL="https://api.airllm.ai/v1"
OPENAI_API_KEY="your_airllm_api_key"
OPENAI_MODEL="airllm-auto"

Test it with curl

bash

curl https://api.airllm.ai/v1/chat/completions \
  -H "Authorization: Bearer your_airllm_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "airllm-auto",
    "messages": [
      { "role": "user", "content": "Write a simple Java method to validate an email address." }
    ]
  }'

Setup script: one file, every tool

The fastest way to connect. Download one file for your system, paste your API key, run it. It sets up the tool you pick, or every supported tool at once, and prints the settings for tools that keep them in their own app.

Choose what it sets up
Tool the setup script sets up
Configures Claude Code, Codex, OpenCode and Aider through their own config files, sets the variables for GitHub Copilot CLI and agent frameworks, and prints the settings to paste into Cursor, Cline and the other app-configured tools.
Download it for your system
macOS / Linuxairllm-setup-mac.sh Windows 10 / 11airllm-setup-windows.bat Windows PowerShellairllm-setup-windows.ps1
Paste your key, then run it
Open the file in any text editor and replace your_airllm_api_key near the top with your AirLLM API key. Then run it:
macOS / Linux
bash airllm-setup-mac.sh, then open a new terminal
Windows
Double-click airllm-setup-windows.bat, then open a new terminal
PowerShell
Right-click airllm-setup-windows.ps1 → Run with PowerShell, or run powershell -ExecutionPolicy Bypass -File airllm-setup-windows.ps1

The only lines you edit

bash

AIRLLM_API_KEY="your_airllm_api_key"   # <-- paste your key here
AIRLLM_MODEL="airllm-auto"              # default model (change it if you like)
AIRLLM_TOOL="all"                       # set for you when you pick a tool above

The Windows .bat uses the same names; the .ps1 uses $AirLLMApiKey, $AirLLMModel and $AirLLMTool. Forgot the key? The script stops and asks for it.

What it changes

Set up for you

Claude Code~/.claude/settings.json
Codex CLI~/.codex/config.toml
OpenCode~/.config/opencode/opencode.json
Aider~/.aider.conf.yml
GitHub Copilot CLICOPILOT_PROVIDER_* variables
Agent frameworksOpenAI and Anthropic SDK variables

Printed for you to paste

Cursor
Continue
Cline
Roo Code
OpenHands
Xcode (macOS)

These tools keep their provider in their own app, so the script prints the exact base URL, key and model instead.

Good to know

It writes each tool’s own config file, not just environment variables, so tools also work when started from an editor or a new terminal. It merges into your existing config without overwriting other settings; back up those files first if you want a copy.
No sign-outs: your AirLLM key takes precedence over a saved Claude login, and Codex ignores its ChatGPT login for custom providers. It runs start to finish without questions.
Safe to re-run: it updates its own entries instead of adding duplicates.
The default model is airllm-auto, which picks the model for each request. To use another for coding tools, set AIRLLM_MODEL to airllm-openai, airllm-anthropic or airllm-agent, or, with a Token-plan key, a catalog model id. airllm-coding and airllm-thinking are chat aliases, not for coding agents.
Signed-in admins can skip the editing: API Keys → Quick Setup downloads a copy with your key, model and tool already inside.

Connect your tool

Pick your tool and your operating system to see just the steps you need. Every tool uses the same AirLLM API key.

Your system

Claude Code

Anthropic Messages
macOS · Linux · Windows (or WSL)

The setup script sets it up for you, in ~/.claude/settings.json.

macOS / Linux

Check it is installed
bash
```
claude --version
```
Open your shell profile
bash
```
nano ~/.zshrc
```
Use ~/.bashrc on most Linux systems.

Add these lines, then save

bash

export ANTHROPIC_BASE_URL="https://api.airllm.ai/"
export ANTHROPIC_AUTH_TOKEN="your_airllm_api_key"
export ANTHROPIC_MODEL="airllm-auto"
export ANTHROPIC_DEFAULT_HAIKU_MODEL="airllm-auto"
export ANTHROPIC_DEFAULT_SONNET_MODEL="airllm-auto"
export ANTHROPIC_DEFAULT_OPUS_MODEL="airllm-auto"
export ANTHROPIC_DEFAULT_FABLE_MODEL="airllm-auto"
export CLAUDE_CODE_SUBAGENT_MODEL="airllm-auto"
export CLAUDE_CODE_SUBAGENT_MODEL_FORCE="1"
export API_TIMEOUT_MS="3000000"
export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC="1"

Reload and start Claude Code

bash

source ~/.zshrc
echo $ANTHROPIC_BASE_URL
claude

Send a test prompt
Write a simple Java method to validate an email address.

Windows

Check it is installed
powershell
```
claude --version
```

Save the variables for your user

powershell

[Environment]::SetEnvironmentVariable("ANTHROPIC_BASE_URL", "https://api.airllm.ai/", "User")
[Environment]::SetEnvironmentVariable("ANTHROPIC_AUTH_TOKEN", "your_airllm_api_key", "User")
[Environment]::SetEnvironmentVariable("ANTHROPIC_MODEL", "airllm-auto", "User")
[Environment]::SetEnvironmentVariable("ANTHROPIC_DEFAULT_HAIKU_MODEL", "airllm-auto", "User")
[Environment]::SetEnvironmentVariable("ANTHROPIC_DEFAULT_SONNET_MODEL", "airllm-auto", "User")
[Environment]::SetEnvironmentVariable("ANTHROPIC_DEFAULT_OPUS_MODEL", "airllm-auto", "User")
[Environment]::SetEnvironmentVariable("ANTHROPIC_DEFAULT_FABLE_MODEL", "airllm-auto", "User")
[Environment]::SetEnvironmentVariable("CLAUDE_CODE_SUBAGENT_MODEL", "airllm-auto", "User")
[Environment]::SetEnvironmentVariable("CLAUDE_CODE_SUBAGENT_MODEL_FORCE", "1", "User")
[Environment]::SetEnvironmentVariable("API_TIMEOUT_MS", "3000000", "User")
[Environment]::SetEnvironmentVariable("CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC", "1", "User")

Open a new PowerShell window, check and start

powershell

echo $env:ANTHROPIC_BASE_URL
claude

Only for the current window instead

powershell

$env:ANTHROPIC_BASE_URL="https://api.airllm.ai/"
$env:ANTHROPIC_AUTH_TOKEN="your_airllm_api_key"
$env:ANTHROPIC_MODEL="airllm-auto"
$env:ANTHROPIC_DEFAULT_HAIKU_MODEL="airllm-auto"
$env:ANTHROPIC_DEFAULT_SONNET_MODEL="airllm-auto"
$env:ANTHROPIC_DEFAULT_OPUS_MODEL="airllm-auto"
$env:ANTHROPIC_DEFAULT_FABLE_MODEL="airllm-auto"
$env:CLAUDE_CODE_SUBAGENT_MODEL="airllm-auto"
$env:CLAUDE_CODE_SUBAGENT_MODEL_FORCE="1"
$env:API_TIMEOUT_MS="3000000"
$env:CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC="1"
claude

Send a test prompt
Write a simple Java method to validate an email address.

Running Claude Code inside WSL? Set the variables inside WSL with the macOS / Linux steps.

The extra model lines make Claude Code’s background tasks and subagents use airllm-auto too; without them those requests fail with “model not found”.

Codex CLI

OpenAI Responses
macOS · Linux · Windows (or WSL)

The setup script sets it up for you, in ~/.codex/config.toml.

macOS / Linux

Check it is installed
bash
```
codex --version
```

Add AirLLM as a provider

In ~/.codex/config.toml:

toml

model = "airllm-auto"
model_provider = "airllm"

[model_providers.airllm]
name = "AirLLM"
base_url = "https://api.airllm.ai/v1"
env_key = "AIRLLM_API_KEY"
wire_api = "responses"

Set the key
bash
```
export AIRLLM_API_KEY="your_airllm_api_key"
```
Add the same line to ~/.zshrc (or ~/.bashrc) to keep it.

Send a test prompt

bash

codex "Write a simple Java method to validate an email address."

Windows

Check it is installed
powershell
```
codex --version
```

Add AirLLM as a provider

In %USERPROFILE%\.codex\config.toml:

toml

model = "airllm-auto"
model_provider = "airllm"

[model_providers.airllm]
name = "AirLLM"
base_url = "https://api.airllm.ai/v1"
env_key = "AIRLLM_API_KEY"
wire_api = "responses"

Set the key, for this window and for later

powershell

$env:AIRLLM_API_KEY="your_airllm_api_key"
[Environment]::SetEnvironmentVariable("AIRLLM_API_KEY", "your_airllm_api_key", "User")

Send a test prompt

powershell

codex "Write a simple Java method to validate an email address."

Running Codex inside WSL? Use the macOS / Linux steps inside WSL.

Codex talks to custom providers only through the Responses API. The key has its own variable, AIRLLM_API_KEY, so other OpenAI tools in your shell never pick it up.

OpenCode

OpenAI-compatible
macOS · Linux · Windows

The setup script sets it up for you, in ~/.config/opencode/opencode.json.

macOS / Linux

Check it is installed
bash
```
opencode --version
```

Set the variables

bash

export OPENAI_BASE_URL="https://api.airllm.ai/v1"
export OPENAI_API_KEY="your_airllm_api_key"
export OPENAI_MODEL="airllm-auto"

Or add AirLLM as a provider

In opencode.json or ~/.config/opencode/opencode.json:

json

{
  "provider": {
    "airllm": {
      "npm": "@ai-sdk/openai-compatible",
      "options": {
        "baseURL": "https://api.airllm.ai/v1",
        "apiKey": "your_airllm_api_key"
      },
      "models": {
        "airllm-auto": {}
      }
    }
  }
}

Send a test prompt

bash

opencode run "Write a simple Java method to validate an email address."

Windows

Check it is installed
powershell
```
opencode --version
```

Set the variables

powershell

$env:OPENAI_BASE_URL="https://api.airllm.ai/v1"
$env:OPENAI_API_KEY="your_airllm_api_key"
$env:OPENAI_MODEL="airllm-auto"

Or add AirLLM as a provider

In opencode.json or %USERPROFILE%\.config\opencode\opencode.json:

json

{
  "provider": {
    "airllm": {
      "npm": "@ai-sdk/openai-compatible",
      "options": {
        "baseURL": "https://api.airllm.ai/v1",
        "apiKey": "your_airllm_api_key"
      },
      "models": {
        "airllm-auto": {}
      }
    }
  }
}

Send a test prompt

powershell

opencode run "Write a simple Java method to validate an email address."

The provider format can change between OpenCode versions; if this one is rejected, check OpenCode’s own docs for the current shape. Looking for OpenClaw? It is an agent gateway: see Agent frameworks.

Aider

OpenAI-compatible
macOS · Linux · Windows

The setup script sets it up for you, in ~/.aider.conf.yml.

macOS / Linux

Check it is installed
bash
```
aider --version
```

Set the variables

bash

export AIDER_OPENAI_API_BASE="https://api.airllm.ai/v1"
export AIDER_OPENAI_API_KEY="your_airllm_api_key"

Start Aider with the AirLLM model
bash
```
aider --model openai/airllm-auto
```

Windows

Check it is installed
powershell
```
aider --version
```

Set the variables

powershell

$env:AIDER_OPENAI_API_BASE="https://api.airllm.ai/v1"
$env:AIDER_OPENAI_API_KEY="your_airllm_api_key"

Start Aider with the AirLLM model
powershell
```
aider --model openai/airllm-auto
```

Aider reaches custom OpenAI-compatible endpoints through the openai/ model prefix. The AIDER_ variables reach only Aider, so your other OpenAI tools keep their own settings.

GitHub Copilot CLI

OpenAI-compatible (bring your own key)
macOS · Linux · Windows

The setup script sets it up for you, with the COPILOT_PROVIDER_* variables.

macOS / Linux

Set the provider variables and start Copilot

bash

export COPILOT_PROVIDER_TYPE="openai"
export COPILOT_PROVIDER_BASE_URL="https://api.airllm.ai/v1"
export COPILOT_PROVIDER_API_KEY="your_airllm_api_key"
export COPILOT_MODEL="airllm-auto"
copilot

Send a test prompt
Write a simple Java method to validate an email address.

Windows

Set the provider variables and start Copilot

powershell

$env:COPILOT_PROVIDER_TYPE="openai"
$env:COPILOT_PROVIDER_BASE_URL="https://api.airllm.ai/v1"
$env:COPILOT_PROVIDER_API_KEY="your_airllm_api_key"
$env:COPILOT_MODEL="airllm-auto"
copilot

Keep them for every new window

powershell

[Environment]::SetEnvironmentVariable("COPILOT_PROVIDER_TYPE", "openai", "User")
[Environment]::SetEnvironmentVariable("COPILOT_PROVIDER_BASE_URL", "https://api.airllm.ai/v1", "User")
[Environment]::SetEnvironmentVariable("COPILOT_PROVIDER_API_KEY", "your_airllm_api_key", "User")
[Environment]::SetEnvironmentVariable("COPILOT_MODEL", "airllm-auto", "User")

Restart PowerShell afterwards.

Send a test prompt
Write a simple Java method to validate an email address.

This is for Copilot CLI. The GitHub Copilot plugin for editors can’t change its endpoint. With a custom provider, GitHub sign-in isn’t needed; the model must support tool calling and streaming. Run copilot help providers for more examples.

Cursor

OpenAI-compatible
macOS · Linux · Windows

Cursor keeps its provider in its own settings, so the setup script prints these values for you to paste.