Aelius Code

One OpenAI-compatible endpoint that turns your editor into an agent running on Aelius. Point Cline, Continue, Roo Code, opencode or Qwen Code at it, paste a key, and the model reads and edits your repository the way it reads a chat. Free with any account.

New to this? Getting a key and Qwen Code, step by step have a screenshot of every click.

Overview

Model

qwen3.8-27b

Context window

262,144 tokens

Protocol

OpenAI Chat Completions, streaming and non-streaming

Auth

Authorization: Bearer aelius_code_…

Price

Free with any account

It is the same model the chat product runs on, reached without the chat product's system prompt or behaviour, and with the entire context window rather than the slice a web conversation gets. That is the point of it: an agent is only useful on a real codebase if the codebase fits in the window.

• Tool calling works. Read a file, run a command, write a patch — the endpoint speaks the same tool-call protocol your extension already expects, so agent modes work rather than just autocomplete.
• Streaming is live. Tokens arrive as they are produced. Tool-call arguments are the one exception and are delivered whole, because a half-written JSON argument is worse to an agent than a short wait.
• Long turns run to completion. Nothing on this side imposes a deadline, so an agent working through a large repository is not cut off part way.

Getting a key

Keys are free with any accountFree and are created and revoked in Settings. Nothing is reviewed and there is no waiting: that is the general API, which is a different product.

It takes about a minute. Open Aelius and sign in first: a guest session cannot hold a key, so sign up if you have not.

1. Open Settings

   Click your name at the bottom of the sidebar. On a phone the sidebar is behind the menu button at the top left.

   

2. Choose Aelius Code

   Settings opens on Account. Aelius Code is the third entry in the menu down the left.

   

3. Name the key and create it

   The top of the panel holds the three values your editor will ask for. Name the key after the machine or editor it is for, then click Create a key.

   

4. Copy it now

   The key appears once, with a Copy button. Put it somewhere you can reach before configuring an editor: this is the only time it can be read.

   

A key looks like aelius_code_ followed by 40 hexadecimal characters. Treat it like a password: it can spend your allowance and it is attached to your account. Revoking one from Settings stops it working within a minute.

The three values every editor asks for

Whatever you are setting up will want these. They are also printed at the top of the Settings panel.

Next: Qwen Code, step by step shows every click. If you know your way around, Cline, Continue and Roo Code are three fields each, and opencode is one config file.

Qwen Code, step by step

Qwen Code is an agent in a VS Code side panel: it reads the folder you have open, writes files and runs commands, against any OpenAI-compatible endpoint. Eleven steps, a screenshot of each, and the thing to click circled in amber.

Install the extension

1. Open the Extensions view

   Click the Extensions icon in the activity bar running down the left edge of the window, or press Ctrl Shift X (Cmd Shift X on a Mac).

   

2. Search for qwen code and find the right one

   Several extensions come back with near-identical names and only one is the agent: Qwen Code Companion, published by qwenlm. Read the publisher line, not the title.

   The one called simply Qwen, by Kingleo, is a wrapper around the qwenlm.ai website: it has nowhere to put a base URL, so it will never reach Aelius. The correct extension's identifier is qwenlm.qwen-code-vscode-ide-companion.

   

3. Install it

   Open its page and click Install. The Preview badge is its authors' label for their own release stage.

   

4. Open the panel

   Install becomes Installed, and a Qwen icon appears in the toolbar at the top right. Click it to open the panel. No icon means the extension has not loaded yet: press Ctrl Shift P and run Developer: Reload Window.

   

Point it at Aelius

The rest happens in prompts that drop down from the top of the window, one after another. Enter confirms and Esc cancels, and cancelling one abandons the sequence: start again at step 5.

1. Run /auth

   Type /auth in the panel's message box and press Enter. It is offered twice while you type, under ACCOUNT and under SLASH COMMANDS; either will do.

   

2. Choose Custom Provider

   Scroll to the bottom of the provider list and pick Custom Provider, the only entry that lets you type a URL of your own. The two at the top are Alibaba Cloud's own paid tiers.

   

3. Protocol: OpenAI Compatible

   Take the first one. Anthropic and Gemini are different request formats and fail immediately against this endpoint.

   

4. Base URL

   Type the endpoint exactly as it appears here:

   https://code.aeliusai.com/v1

   Copy

   Include the /v1, with no trailing slash. The extension appends /chat/completions itself, so a URL that already ends in /v1/ or /chat/completions gives a 404 that reads convincingly like the server being down.

   

5. API key

   Paste your aelius_code_ key. The field is masked, so paste rather than type and watch for a trailing space: it is the usual cause of a 401 invalid_api_key on the first message.

   

6. Model

   The endpoint serves exactly one model. Type its name:

   qwen3.8-27b

   Copy

   The prompt takes a comma-separated list, so one entry and no comma is right. Spell it exactly: anything else is a 404, not a correction.

   

7. Say hello

   That is the setup. Send anything. A Thinking block appears first, because reasoning is on for this model, and the answer follows underneath.

   

Two settings to change before you do real work

It works now, but two defaults will bite on a real repository.

1. Tell it the real context window

{
  "modelProviders": {
    "openai": [
      {
        "id": "qwen3.8-27b",
        "baseUrl": "https://code.aeliusai.com/v1",
        "generationConfig": {
          "contextWindowSize": 262144
        }
      }
    ]
  }
}

2. Turn off, or raise, any request timeout

An agent turn on a real repository can run for minutes, with the connection open and quiet while it does. An extension that gives up on it turns a slow answer into an error, which is the most common reason people report that Aelius Code has stopped working.

When it does not work

Qwen Code in a terminal

The same agent runs in a terminal, where it reads the standard OpenAI environment variables. Three exports are the whole setup:

export OPENAI_BASE_URL="https://code.aeliusai.com/v1"
export OPENAI_API_KEY="aelius_code_YOUR_KEY_HERE"
export OPENAI_MODEL="qwen3.8-27b"

qwen

In PowerShell these are $env:OPENAI_BASE_URL and so on. The ~/.qwen/settings.json fix applies here too, and matters more: a terminal session runs longer and fills the window further before anything notices.

The same variables work for anything else that speaks the OpenAI protocol.

Cline

Three fields on one form, and the quickest of these to set up.

Same three values. The Qwen Code walkthrough shows each being entered.

1. Install Cline from the VS Code marketplace.
2. Open its settings and set API Provider to OpenAI Compatible.
3. Fill in the three fields:

Base URL

https://code.aeliusai.com/v1

API Key

aelius_code_…

Model ID

qwen3.8-27b

Then turn on Enable streaming if it is not already on, and set the context window to 262,144 so Cline does not truncate prompts it did not need to.

Continue

No form and no prompts to photograph. Same three values.

Continue is configured from a file rather than a form. Open ~/.continue/config.yaml and add a model block:

models:
  - name: Aelius
    provider: openai
    model: qwen3.8-27b
    apiBase: https://code.aeliusai.com/v1
    apiKey: aelius_code_YOUR_KEY_HERE
    defaultCompletionOptions:
      contextLength: 262144
    roles:
      - chat
      - edit
      - apply

Roo Code

Roo Code is a fork of Cline and is configured the same way: choose the OpenAI Compatible provider, then set Base URL to https://code.aeliusai.com/v1, the API key to your aelius_code_… key, and the model to qwen3.8-27b. Leave "Use Azure" off.

Same shape as Cline. The Qwen Code walkthrough covers the traps they share: a trailing slash on the base URL, a space copied with the key.

opencode

opencode comes in three interfaces — the terminal TUI, the desktop app, and opencode web in a browser. All three read the same config file, and none of them has a form for a base URL. opencode will not find Aelius on its own either: it knows the providers listed at models.dev, and this endpoint is not one of them. You declare it yourself, once, in a file. That is the whole reason this one feels harder than the rest. Once the file exists it is the same three values as everywhere else.

Using the desktop app? Do this file first anyway, then see the desktop app and the connect dialog for what its Custom option does and does not cover.

export AELIUS_CODE_API_KEY="aelius_code_YOUR_KEY_HERE"

opencode auth login https://aeliusai.com

curl -s https://aeliusai.com/.well-known/opencode | python3 -m json.tool

1. Install opencode, if you have not:

   curl -fsSL https://opencode.ai/install | bash

   Copy
2. Put your key in the environment rather than in the file, so the file is safe to keep in a dotfiles repo:

   export AELIUS_CODE_API_KEY="aelius_code_YOUR_KEY_HERE"

   Copy
   Add that line to ~/.zshrc or ~/.bashrc so it survives a new terminal. In PowerShell it is $env:AELIUS_CODE_API_KEY.
3. Create ~/.config/opencode/opencode.json. The directory will not exist yet on a fresh install — mkdir -p ~/.config/opencode first. Paste this in whole; the three places aelius appears are the provider id, and nothing in here needs changing except your key:

   {
     "$schema": "https://opencode.ai/config.json",
     "provider": {
       "aelius": {
         "npm": "@ai-sdk/openai-compatible",
         "name": "Aelius",
         "options": {
           "baseURL": "https://code.aeliusai.com/v1",
           "apiKey": "{env:AELIUS_CODE_API_KEY}"
         },
         "models": {
           "qwen3.8-27b": {
             "name": "Aelius Code",
             "limit": {
               "context": 262144,
               "output": 32768
             }
           }
         }
       }
     },
     "model": "aelius/qwen3.8-27b",
     "small_model": "aelius/qwen3.8-27b"
   }

   Copy
4. Confirm opencode can see it before you open the editor:

   opencode models | grep aelius

   Copy
   You want one line back: aelius/qwen3.8-27b. Nothing back means the config file is not where opencode is looking, or is not valid JSON — a trailing comma is the usual culprit, and opencode skips a file it cannot parse without saying so.
5. Run opencode. It is already on the right model because of the model key; /models inside the TUI switches between them if you configure more later.

What each part of that file is doing

npm

@ai-sdk/openai-compatible is the driver that speaks plain OpenAI HTTP. opencode downloads it on first launch, so that launch needs a network and a working Node. Every other value is yours.

aelius

The provider id — a label, chosen by you, not given to you. It has to match the prefix in "model": "aelius/…" exactly; if you rename one, rename both.

baseURL

https://code.aeliusai.com/v1 — ending at /v1, with no trailing slash and no /chat/completions. opencode appends the path itself.

limit.context

opencode never asks the server how big the window is, so this figure is the only one it has. It is what decides when a session compacts. Setting it too high is the failure described under Limits: prompts get built larger than this endpoint will accept, after the agent has already read half your repository.

small_model

opencode runs a second, cheaper model for session titles and summaries. Leave it unset and it goes looking for one somewhere else, which with Aelius as your only provider means an error on the first message. Pointing it at the same model is correct here.

The desktop app, and the connect dialog

The desktop app and the TUI share one credential store and one config file, so nothing above changes when you use the GUI. What the GUI adds is a dialog for the key: connect provider, then the entry at the bottom of the list called Custom in the desktop app and Other in the TUI's /connect. It is worth knowing exactly what that dialog covers before you rely on it.

Which makes the Provider ID box the same invented label as before, and the one place the two halves have to meet:

1. Write the config file first

   ~/.config/opencode/opencode.json, exactly as above. Do this before you open the app: the dialog in the next step has nowhere to put a base URL, so until this file exists there is nothing for the app to connect to.

2. Open the connect provider dialog

   In the desktop app, the entry you want is at the bottom of the provider list and is called Custom. In the TUI the same dialog is /connect and the entry is called Other; from a plain terminal it is opencode auth login, also Other.

3. Provider ID: aelius

   Character for character the key you used under provider in the file. This is the join, and the only thing this dialog is really for. Type Aelius or aelius-code here and the model still appears in the picker, then returns 401 on your first message, because the key was filed under a provider that does not exist.

4. API key

   Your aelius_code_… key. The dialog saves it to ~/.local/share/opencode/auth.json and saves nothing else.

5. Take the key back out of the config

   Now that opencode holds it, delete the "apiKey" line from opencode.json, and the AELIUS_CODE_API_KEY export if you set one. Mind the trailing comma on the line above it, or the file stops parsing and opencode goes back to not knowing about Aelius at all.

6. Pick the model

   It is listed as aelius/qwen3.8-27b — the provider id, then the model name from the config file. Selecting it is the last step; the first message will tell you whether the two halves met.

No “Custom” entry in your connect dialog? The desktop app only gained it in a January 2026 release. Update the app, or skip the dialog entirely and keep the key in the config file the way the steps above set it up — that path works on every version and every interface.

Where opencode keeps its files

opencode.jsonc is accepted in place of opencode.json if you want comments in it. Very old installs keep the config in ~/.local/share/opencode/ instead; if a file is there, that is the one being read, and it is worth moving to the path above.

When it does not work

Anything else

If your tool accepts a base URL, a key and a model name, it will work, and the three values above are all it needs. A plain curl to prove the endpoint is reachable and your key is good:

curl https://code.aeliusai.com/v1/chat/completions \
  -H "Authorization: Bearer aelius_code_YOUR_KEY_HERE" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen3.8-27b",
    "messages": [{"role": "user", "content": "Reply with the word ready."}],
    "stream": false
  }'

A 401 means the key is wrong or revoked; anything else means the key is fine and you are reading a real answer. See Errors.

Endpoints

The one you will use. Standard OpenAI Chat Completions: messages, tools, tool_choice, temperature, top_p, max_tokens, stream. Reasoning is enabled on this model and arrives in a reasoning_content delta, which every extension listed above already understands.

Legacy text completion, supported for tools that still need it. Prefer /chat/completions.

Returns the one model served, with its context length. Requires a key. Many extensions call this to populate a dropdown before their first real request, which is why a bad key often shows up as an empty model list rather than as an error.

Limits

Every limit below is per key. The model, the context window and the protocol do not vary: they are the same on every account and every request.

A guest session is a cookie, so it cannot hold a key that stays revocable afterwards. Signing up is free and takes a moment.

The context window, and clients that guess it

One request may carry 262,144 tokens, prompt and reply together, on every plan. The endpoint publishes that figure on GET /v1/models — under context_length, context_window, max_model_len, max_context_length and max_input_tokens, because there is no agreed name for it — and on GET /props as n_ctx, for tools that speak the llama.cpp dialect.

Some clients never look. They keep a table of model names and their context sizes, and pick a row by matching the name you configured. Qwen Code does this and will show 1,000k; see Qwen Code for the one line that corrects it. If your editor shows a figure that is not the one above, that is what has happened, and it is worth fixing rather than ignoring: a client that believes it has four times the room will send prompts this endpoint has to reject.

The concurrency cap counts turns in flight, not turns started, so it is the one you are most likely to meet while working.

How the allowance works

The shape is the same as Codex's, so the two are comparable: a rolling five-hour window with a weekly cap on top, counted in credits rather than messages. Everything the model reads and writes counts — your prompt, the files it opens, tool and terminal output, and its reply — but not all of it counts the same.

Those weights are Codex's, at their flagship model's rate, so a credit here means what a credit means there. They also describe the real cost fairly: an editor that resends the same file tree every turn is resending something already held in cache, and charging full price for it would be billing for work nobody did.

• The window rolls. It opens on your first request and clears five hours after that, not at a fixed time of day. Stop for five hours and you start fresh.
• The weekly cap sits on top. You can empty a five-hour window with most of the week still available; several maxed-out days in a row will find the weekly ceiling.
• Failed turns cost nothing. Only a turn the model actually served is counted.
• A long conversation gets cheaper per turn, not dearer. The part of the context that has not changed since your last message is charged at the cached rate.

What the allowance is actually worth. Measured here against a real editor session rather than estimated: an agent turn carrying about 34,000 tokens of repository context costs 1.14 credits on average, once the unchanged part of that context is coming from cache. So a window is roughly 180 agent turns.

How long that lasts depends entirely on how hard you drive it, and the honest warning is that an agent is fast: in the session those figures come from, an editor ran eight turns a minute at its peak, spending 63 credits in twelve minutes. At that pace a window goes in about half an hour. Thinking between prompts, it lasts far longer. Turned loose on a repository, it will not. That is the same reason OpenAI quotes a usage range rather than a message count.

One account per network. The allowance belongs to an account, and an account is tied to the network it works from: the first Aelius account to use Aelius Code from a given address keeps it, and a second account on that same address is refused with network_in_use. It is there so that an allowance cannot simply be restarted by signing up again, which would leave everybody else queueing behind it. One account may use as many networks as it likes, so a laptop that moves between home, an office and a phone hotspot is fine. An address stops being spoken for once it has gone a fortnight unused.

If you share a connection with somebody who also uses Aelius Code, that is a real case and not one we want to block. Tell us and we will mark the network as shared.

Your own usage, both windows, is on the same Settings page the key came from.

Errors

For what these look like inside an editor, see When it does not work.

Data and privacy

• Your code is not stored. Prompts stream through to the model and are not written to disk. Nothing you send through this endpoint is used for training, ever.
• What is recorded is accounting. Per request: the time, the token counts, how long it took, your key, your account, the requesting IP and your editor's user-agent string. Never the prompt or the answer.
• A short prompt fragment is visible live. While a turn is actually running, the first 160 characters of the last user message appear on the operator dashboard so a long-running turn can be recognised. It is held in memory only and disappears the moment the turn ends.
• Request records are kept 45 days, then deleted. The running totals on your key survive that, because they are counters rather than records.

Get a key · The text and vision API · Contact