How to Use GPT-6 Astra in Claude Code: Proxy or Codex Plugin

There are two different setups behind "GPT-6 Astra in Claude Code", and you need to pick one before you change anything. If you want Astra to run the whole session, put a translating proxy such as LiteLLM between Claude Code and an OpenAI-format endpoint, point ANTHROPIC_BASE_URL at the proxy, and set the model variables to gpt-6-astra. That needs an API key and bills per token. If you want Claude to stay in charge and hand tasks to Astra, install OpenAI's Codex plugin and run /codex:rescue --model gpt-6-astra, which uses your Codex login, so a ChatGPT Plus or higher plan works.

Both setups completed the same small coding task on November 12, 2026. Through the proxy, Claude Code 2.1.316 running on Astra fixed a two-bug Python file in 19.2 seconds for about $0.228 at Astra's list price, roughly twice what Claude Code's own cost line printed. Through the plugin, the same task finished in 28 seconds on a ChatGPT subscription. Anthropic does not support routing Claude Code to non-Claude models, so neither setup comes with help from Anthropic, and an update can break either one.

The shortcut that did not work is pointing Claude Code straight at a gateway's Anthropic-format endpoint with gpt-6-astra as the model name. On laozhang.ai that returned a 503 "no available channels" error, because its Claude-protocol endpoint does not serve Astra while its OpenAI-format endpoints do. Translating between the two formats is the proxy's whole job.

Disclosure: laozhang.ai is our own service. Its prices are platform pricing, not an independent comparison.

Astra as the main model or as a Codex worker: which setup to pick

Pick the proxy if you want Astra to drive every turn inside Claude Code's interface and you are paying for API tokens anyway. Pick the Codex plugin if you want to keep Claude as the main model and send Astra specific jobs, such as a bug hunt, a second-opinion review or a quick fix, and you already have a ChatGPT plan that includes Astra. The plugin route is also the answer if your real question is "can I use ChatGPT in Claude Code": it is the only one of the two that runs on a ChatGPT subscription.

The two times are not a race result. The proxy run used effort high inside Claude Code's agent loop, while the plugin run used effort medium inside Codex, so their speed and token totals measure different harnesses. If you are still deciding which model to use at all, that question is covered in Claude Fable 5.2 vs GPT-6 Astra: When Each Costs Less per Task.

Proxy route: run Claude Code on gpt-6-astra through LiteLLM

Claude Code only speaks the Anthropic Messages format, so the proxy route works by running LiteLLM on your machine: Claude Code sends its usual /v1/messages requests to LiteLLM, and LiteLLM rewrites them for an OpenAI-format upstream that serves gpt-6-astra. LiteLLM documents this pattern in its tutorial "Use Claude Code with Non-Anthropic Models". The setup below is the one that ran on November 12, 2026 with LiteLLM 1.109.1 and Claude Code 2.1.316, with laozhang.ai as the upstream.

Disclosure: laozhang.ai is our own service. Its prices are platform pricing, not an independent comparison.

You need an upstream key that can already call Astra. On OpenAI's own platform that depends on your project's access, which GPT-6 Astra API Access: Check Your Project and Make a First Request walks through. On laozhang.ai, gpt-6-astra is listed in the default group on both /v1/chat/completions and /v1/responses.

1. Install LiteLLM with its proxy extras. LiteLLM's tutorial uses uv tool install 'litellm[proxy]'; a Python virtual environment with pip install 'litellm[proxy]' works the same way.

2. Save this as litellm-config.yaml. The model_name values are the names Claude Code will ask for, and drop_params: true tells LiteLLM to drop request fields the upstream does not accept.

   yamlCopy

   model_list:
     - model_name: gpt-6-astra
       litellm_params:
         model: openai/gpt-6-astra
         api_base: https://api.laozhang.ai/v1
         api_key: os.environ/LAOZHANG_API_KEY
     - model_name: gpt-6-luna
       litellm_params:
         model: openai/gpt-6-luna
         api_base: https://api.laozhang.ai/v1
         api_key: os.environ/LAOZHANG_API_KEY
   litellm_settings:
     drop_params: true

   For an OpenAI key, remove both api_base lines and read the key from OPENAI_API_KEY, which is the form LiteLLM's tutorial shows; the timings and costs below all come from the laozhang.ai config above. A third entry with model: openai/responses/gpt-6-astra was also tried and behaved identically, because LiteLLM sent every Astra call to the upstream's /v1/responses endpoint either way.

3. Start the proxy. LITELLM_MASTER_KEY is a password you make up; Claude Code will present it as its token.

   bashCopy

   export LAOZHANG_API_KEY="your-upstream-key"
   export LITELLM_MASTER_KEY="sk-any-long-random-string"
   litellm --config litellm-config.yaml --host 127.0.0.1 --port 4011

4. Check the proxy before touching Claude Code. A reply with "model": "gpt-6-astra" means the translation works; in the test, the same kind of request with one tool attached came back with "stop_reason": "tool_use".

   bashCopy

   curl -X POST http://127.0.0.1:4011/v1/messages \
     -H "Authorization: Bearer $LITELLM_MASTER_KEY" \
     -H "Content-Type: application/json" \
     -d '{"model": "gpt-6-astra", "max_tokens": 200,
          "messages": [{"role": "user", "content": "Which model are you?"}]}'

5. In a second terminal, set Claude Code's variables and start it.

   bashCopy

   export ANTHROPIC_BASE_URL="http://127.0.0.1:4011"
   export ANTHROPIC_AUTH_TOKEN="sk-any-long-random-string"   # the same LITELLM_MASTER_KEY
   export ANTHROPIC_MODEL="gpt-6-astra"
   export ANTHROPIC_DEFAULT_OPUS_MODEL="gpt-6-astra"
   export ANTHROPIC_DEFAULT_SONNET_MODEL="gpt-6-astra"
   export ANTHROPIC_DEFAULT_HAIKU_MODEL="gpt-6-luna"
   export CLAUDE_CODE_MAX_CONTEXT_TOKENS=272000
   claude

All four model variables matter. Without --model, Claude Code sends the main session to the Opus slot, subagents inherit the session model, and the Haiku slot names the session. If a slot is left empty, Claude Code asks the proxy for a Claude model ID it does not have. Putting gpt-6-luna in the Haiku slot keeps those small requests off Astra; any model you define in the proxy can go there. How the three slots behave with another non-Claude model is shown in GLM-5.3-Flash in Claude Code: Setup That Actually Runs Flash.

CLAUDE_CODE_MAX_CONTEXT_TOKENS=272000 is optional but worth setting. Claude Code does not recognize gpt-6-astra, so it assumes a 200K-token window and compacts there. Astra's real window is 1,050,000 tokens, but OpenAI bills a request with more than 272K input tokens entirely at the higher $20 input and $75 output rate per 1M tokens. A 272,000 window therefore lets each request use more context while keeping it on the standard rate. That number is a cost choice, not an official recommendation, and with it set, the 200K warning stopped appearing.

To make the setup permanent, the same keys can go in the env block of your Claude Code settings file instead of shell exports. Where that file lives and which credential wins when you also have a Claude login are covered in Claude Code API Configuration: Keys, Settings, Models, and Gateways.

In the test, Claude Code ran the unit tests, searched and read the file, edited it, and re-ran the tests: 7 turns, 6 upstream calls, 4 of 4 tests passing. Claude Code sent eight anthropic-beta values and an output_config field, and none of them caused an error with drop_params on. That is one machine, one small task and one run, so treat it as proof that the plumbing works, not as a guarantee for long sessions.

Codex plugin route: keep Claude, hand tasks to Astra

OpenAI's Codex plugin for Claude Code adds slash commands that pass work to your local Codex CLI, and the CLI can run that work on gpt-6-astra if you name the model. Claude remains the model you talk to; Codex does the delegated task and reports back. You need Node.js 18.18 or later and a Codex login, either a ChatGPT account or an OpenAI API key. Run these inside Claude Code:

1. Add OpenAI's marketplace: /plugin marketplace add openai/codex-plugin-cc
2. Install the plugin: /plugin install codex@openai-codex
3. Load it: /reload-plugins
4. Check Codex with /codex:setup. It offers to install the Codex CLI if it is missing; if Codex is installed but not signed in, run !codex login and choose ChatGPT or an API key.
5. Delegate a task and name the model: /codex:rescue --model gpt-6-astra --effort medium fix the failing tests in textkit/slug.py

Naming the model is the step that is easy to miss. The plugin's README says that "if you do not pass --model or --effort, Codex chooses its own defaults", and the installed rescue subagent leaves --model unset unless you mention a model. To make Astra the default without typing it each time, add these two lines to ~/.codex/config.toml, or to .codex/config.toml in a trusted project:

model = "gpt-6-astra"
model_reasoning_effort = "medium"

Two more details come from the installed files of plugin version 1.0.6. The rescue subagent adds --write by default, so Codex edits your files rather than only suggesting changes. And the subagent itself is defined to run on Claude's sonnet model, so each handoff also uses some Claude usage before Codex starts.

The plugin was tested on November 12, 2026: version 1.0.6 installed into a fresh Claude Code configuration, Codex CLI 0.166.0 signed in with ChatGPT, and the plugin's runtime called exactly the way its rescue subagent calls it, with --model gpt-6-astra --effort medium. Codex fixed the same two-bug file in 28 seconds with all 4 tests passing, and its session log recorded "model":"gpt-6-astra". Typing /codex:rescue in an interactive Claude session was not part of that run; the runtime that the command calls was.

Which ChatGPT plan you have decides whether Astra is available at all. As of October 26, 2026, OpenAI's plan pages gave Free and Go users GPT-6 Luna rather than Astra, Plus and standard Business roughly 5–45 Astra local messages per 5 hours in Work and Codex, and Pro no 5-hour limit. Plugin usage counts toward those Codex limits, and the plugin's optional review gate, which runs a Codex review every time Claude finishes, "may drain usage limits quickly" in the README's words. How Claude and Codex plans compare as tools is in Claude Code vs Codex Cost: Plans, Limits, and the Real API Bill.

Community tools that reuse a ChatGPT login to feed Claude Code directly, without Codex, are a different thing. OpenAI does not document that use, and none of them is covered by the results here; the plugin is the path OpenAI ships for putting a ChatGPT plan to work from inside Claude Code.

How to check that gpt-6-astra is really answering

Claude Code's own screens tell you what it is asking for, not who answered. With the proxy setup, the header reads gpt-6-astra · API Usage Billing, and /status shows Anthropic base URL: http://127.0.0.1:4011, Auth token: ANTHROPIC_AUTH_TOKEN and Model: gpt-6-astra. If the base URL line is missing or shows a different address, your variables did not reach Claude Code. Those lines are the first check, and the proxy is the second.

The proof that Astra served the request is upstream of Claude Code. Start LiteLLM with --detailed_debug and each call shows the model and the upstream endpoint; in the test, every Astra call went to https://api.laozhang.ai/v1/responses with gpt-6-astra as the model. The same log is where you see that one message in an interactive session produced three requests on November 12, 2026: two to gpt-6-astra and one to the Haiku slot, gpt-6-luna, which named the session. Your upstream's usage page should then show the same model ID.

Disclosure: laozhang.ai is our own service. Its prices are platform pricing, not an independent comparison.

Asking the model is weak evidence either way. In the proxy run, Astra ended its answer with "I am GPT-6 Astra (gpt-6-astra)", but in the plugin run Codex answered "I'm Codex, based on GPT-6" while its session log recorded gpt-6-astra. For the plugin route, /codex:result gives you the Codex session ID, and the session log for that ID records the model and reasoning_effort the task actually ran with.

What one task cost, and why Claude Code shows about half

The two-bug fix cost between $0.20 and $0.29 per run at Astra's API list price, depending on effort, and Claude Code's printed cost was about half of that in every run. Claude Code has no price for gpt-6-astra (its result data marks the cost basis as "unknown"), so the number it prints is not Astra's. Use your upstream's usage page or your own calculation for real spend. The three proxy runs on November 12, 2026, each through laozhang.ai with the setup above:

Disclosure: laozhang.ai is our own service. Its prices are platform pricing, not an independent comparison.

The list-price column comes from the token counts the upstream returned, multiplied by Astra's prices per 1M tokens: $10 uncached input, $12.50 cache write, $1 cache read and $50 output. For the default run:

uncached input       12 × $10.00 / 1M  = $0.000120
cache write      11,728 × $12.50 / 1M  = $0.146600
cache read       55,265 × $1.00  / 1M  = $0.055265
output              521 × $50.00 / 1M  = $0.026050
total                                    $0.228035 ≈ $0.228

About 64% of that run's cost was the first cache write of roughly 11,700 tokens, which is Claude Code's system prompt and tool definitions, paid once per session before any of your own work. A real session reads that cached prefix again on every turn and grows far beyond this task, so scale from the formula, not from the $0.228. The full price table, including the higher rate above 272K input tokens, is in GPT-6 Astra API Pricing: $10/$50 per 1M Tokens, Caching Costs.

Effort carries over. Claude Code's effort setting reached Astra as reasoning.effort: high by default, and low or max when CLAUDE_CODE_EFFORT_LEVEL was set to those values, all three passing 4 of 4 tests. Astra accepts low through max and does not support none or minimal. One run per level on an easy task shows that the setting arrives, not which level is better for your work. How Claude Code chooses and keeps an effort level is covered in Claude Code Effort Level: Model Defaults and Why It Won't Stick.

The plugin route bills differently. On a ChatGPT login, the 28-second task used 130,507 input tokens (112,128 of them cached) and 369 output tokens, counted against Codex usage limits rather than charged per token. It ran at effort medium in a different harness, so its token total cannot be set against the proxy rows.

First errors when Claude Code talks to Astra

Most first errors come from a request reaching an endpoint that does not speak the format Claude Code uses. The four below are listed with their exact wording, what causes them, and the fix.

API Error: 503 … no available channels for model gpt-6-astra

This is what Claude Code 2.1.316 printed on November 12, 2026 when ANTHROPIC_BASE_URL pointed straight at laozhang.ai with every model variable set to gpt-6-astra:

Disclosure: laozhang.ai is our own service. Its prices are platform pricing, not an independent comparison.

API Error: 503 Current group default has no available channels for model gpt-6-astra under billing mode [pay-as-you-go, pay-per-request] (request id: …). This is a server-side issue, usually temporary — try again in a moment. If it persists, check your inference gateway (api.laozhang.ai).

A direct POST /v1/messages with curl returned the same 503 with and without a tool, and the failed requests were not billed. The gateway's Anthropic-format endpoint has no channel for Astra, so retrying does not help, whatever Claude Code's generic "usually temporary" text says. The fix is the LiteLLM setup above, which sends Astra calls to the OpenAI-format endpoint instead. Other gateways may translate on their side; one curl to their /v1/messages with "model": "gpt-6-astra" tells you before you edit any settings.

⚠ Model "gpt-6-astra" isn't recognized · context assumed to be 200k tokens

This is a warning, not a failure. Claude Code shows it, or the longer form "Claude Code doesn't recognize the model "gpt-6-astra", so it assumes a context window of 200k tokens", for any model ID it does not know, and it then compacts the conversation at 200K. Setting CLAUDE_CODE_MAX_CONTEXT_TOKENS to a number declares the window instead, and for an ID like gpt-6-astra that does not start with claude-, the variable works on its own. With 272000 set, the warning disappeared and Claude Code reported a 272,000-token window.

400 "Extra inputs are not permitted" or tool calls that fail

Claude Code sends Anthropic-only fields to any gateway: anthropic-beta headers, output_config.effort, context_management, cache markers and beta tool fields. Anthropic's gateway documentation says a proxy that forwards those to an upstream with a different schema produces 400 errors such as Extra inputs are not permitted. Claude Code retries once without the effort and context-management fields when those are rejected. Keep drop_params: true in the LiteLLM config, and if a 400 still appears, set CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS=1 to cut down the beta fields. The test produced no 400 at all with drop_params on.

Tool calls can fail for a separate reason. On OpenAI's own API, Astra supports function calling only through the Responses API, not Chat Completions. A proxy that talks to OpenAI over Chat Completions will therefore break as soon as Claude Code tries to read or edit a file. LiteLLM used /v1/responses for every Astra call in the test.

The proxy rejects a claude- model name

If LiteLLM answers with an unknown-model error naming a Claude model, one of the slot variables is missing. Without ANTHROPIC_DEFAULT_OPUS_MODEL, ANTHROPIC_DEFAULT_SONNET_MODEL and ANTHROPIC_DEFAULT_HAIKU_MODEL, Claude Code asks for its built-in Claude IDs, which your proxy does not define. Set all four variables from step 5, or add model_name entries for the IDs it asks for.

What may break: features the test did not cover

The test exercised file search, reads, edits and shell commands in one short task, and nothing else. Anthropic's server-side tools such as WebSearch and WebFetch, image input, subagents, MCP servers, long sessions and auto-compaction were not run through Astra, and some of them depend on Anthropic-side features that a translating proxy may not reproduce. If you need web search, LiteLLM's documentation lists a separate page titled "Claude Code - WebSearch Across All Providers". Two alternatives also sit outside these results: an OpenAI key sent straight to api.openai.com through the same config, and Claude Code Router. Team users should also know that with a custom ANTHROPIC_BASE_URL, /status reported remote managed settings and organization policy as "not fetched", so remote policies an admin sets do not reach the session.

A Claude Code update can also add a header or field that the proxy passes on and the upstream rejects. When something stops working after an update, the curl check from step 4 tells you whether the proxy or Claude Code changed.

GPT-6 Astra in Claude Code: other questions

Can I use other OpenAI models in Claude Code the same way?

Yes. Any model your upstream serves can be added as another model_name entry in the LiteLLM config and put in a slot variable. LiteLLM's own tutorial uses gpt-6.1-sol and gpt-6-luna, and in the November 12, 2026 test gpt-6-luna handled Claude Code's session-title requests from the Haiku slot. For DeepSeek through OpenRouter, see Claude Code with OpenRouter and DeepSeek: Setup, Routes, and First-Error Fixes.

Can I pick gpt-6-astra from the /model menu?

Claude Code's documentation describes two ways: set CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY=1 so Claude Code reads the proxy's /v1/models list at startup and adds those models to the picker, or set ANTHROPIC_CUSTOM_MODEL_OPTION to add one entry. LiteLLM's tutorial uses the discovery variable. The setup above selects Astra through the model variables instead, which works without either.

Is Claude Code Router an alternative to LiteLLM?

It does the same job. Claude Code Router 3.1.3, released October 9, 2026, is a desktop app (also installable with npm install -g @musistudio/claude-code-router, Node.js 22+) that runs a local gateway on http://127.0.0.1:3456, and its README lists OpenAI Chat and Responses among the upstream formats. Providers are added in its interface rather than a YAML file. The results above come from LiteLLM, not from Claude Code Router.

Is "Astra 6" a different model from GPT-6 Astra?

No. "Astra 6" is shorthand people use for GPT-6 Astra, OpenAI's model with the API ID gpt-6-astra, released September 3, 2026.

Is GPT-6 Astra better than Claude for coding?

That depends on the task and on what each costs per finished task, which is compared in Claude Fable 5.2 vs GPT-6 Astra: When Each Costs Less per Task.