> Markdown mirror of https://router.one/blog/gpt-6-sol-coding-tools-setup for AI assistants and crawlers. Router One is an OpenAI-compatible LLM API gateway.
> Published: 2026-09-23 · Author: Router One Team

# GPT-6 Sol in Codex CLI, Cursor, Cline and OpenCode: Setup

_Run GPT-6 Sol in Codex CLI, OpenCode, Cline, Cursor or Goose on one Router One key: model string, request path per tool, and the 272K price line._

GPT-6 Sol (`openai/gpt-6-sol`) was listed in the Router One catalog on 2026-09-23, and every coding tool that accepts a custom OpenAI-compatible base URL can call it with one Router One key. Codex CLI reaches it over the Responses API; OpenCode, Cline, Roo Code, Kilo Code, Continue, Zed, Qwen Code and Crush reach it over Chat Completions; Goose sends a GPT-6 name to `/v1/responses` on its own. Claude Code is the exception: it only speaks the Anthropic Messages API, and Router One serves GPT ids on `/v1/chat/completions` and `/v1/responses`, never on `/v1/messages` — so a GPT-6 Sol request from Claude Code is rejected with HTTP 400 before any model runs.

This post is the tool-by-tool half of the GPT-6 Sol coverage: the model string each tool needs, where the base URL goes, which request path it produces, and the one number that matters in long agent sessions — the 272,000-token price line. The [GPT-6 Sol API guide](https://router.one/blog/gpt-6-sol-api-guide) covers the API itself (curl, SDKs, endpoints, billing rules), and the [GPT-6 Sol model page](https://router.one/models/gpt-6-sol) carries the live rate and tier boundaries.

## What the catalog lists for GPT-6 Sol

As of the 2026-09-23 catalog read, `openai/gpt-6-sol` lists a 1,050,000-token context window, a 128,000-token output limit, text and image input, and the chat, streaming, tool-calling and vision capability flags. As a GPT-family id it is served on `POST /v1/chat/completions` and natively on `POST /v1/responses`. It carries a whole-request price tier above 272,000 input tokens, so its model page shows two rate lines. The bare name `gpt-6-sol` is accepted as an alias of the full id.

Three things are not in the catalog on that date: GPT-6 Luna, any `azure/gpt-6-sol` channel id, and a subscription quota for GPT-6 Sol — no Pro, Max or Ultra tier lists it in the 2026-09-23 plan response, so its calls are billed per token from the wallet. For the spec sheets side by side, see [GPT-6 Sol vs GPT-6 Astra](https://router.one/models/compare/gpt-6-sol-vs-gpt-6-astra), [GPT-6 Sol vs GPT-5.6 Sol](https://router.one/models/compare/gpt-6-sol-vs-gpt-5-6-sol) and [GPT-6 Sol vs Claude Sonnet 5](https://router.one/models/compare/gpt-6-sol-vs-claude-sonnet-5).

## Tool by tool: base URL, request path, model string

| Tool | Where the gateway goes | Request path for GPT-6 Sol | Model value | Note |
| --- | --- | --- | --- | --- |
| [Codex CLI](https://router.one/codex-china) | `[model_providers.router]` in `~/.codex/config.toml`: `base_url = "https://api.router.one/v1"`, `wire_api = "responses"` | `/v1/responses` | `gpt-6-sol` | The bare name Codex's own model list uses; config below |
| [OpenCode](https://router.one/integrations/opencode) | `provider.router-one` in `opencode.json` on `@ai-sdk/openai-compatible`, `options.baseURL` = `/v1` URL | `/v1/chat/completions` | `router-one/openai/gpt-6-sol` | List `openai/gpt-6-sol` under the provider's `models` |
| [Cline](https://router.one/integrations/cline), [Roo Code](https://router.one/integrations/roo-code), [Kilo Code](https://router.one/integrations/kilo-code) | API Provider "OpenAI Compatible" (Kilo Code: Providers → Custom provider → OpenAI Compatible), Base URL = `/v1` URL | `/v1/chat/completions` | `openai/gpt-6-sol` | Same three fields in all three |
| [Cursor](https://router.one/integrations/cursor) | Settings → Models → OpenAI API Key → Override OpenAI Base URL | Whichever path Cursor builds; both serve GPT-6 Sol | `openai/gpt-6-sol` as a custom model | Covers chat and Agent models only; paid Cursor plans only |
| [Continue](https://router.one/integrations/continue) | `apiBase` in `~/.continue/config.yaml`, `provider: openai` | `/v1/chat/completions` with `useResponsesApi: false` | `openai/gpt-6-sol` | The guide keeps the flag at `false` |
| [Zed](https://router.one/integrations/zed) | `language_models.openai_compatible.router-one.api_url` in `settings.json` | `/v1/chat/completions` | `openai/gpt-6-sol` | `max_tokens` is the context window: `1050000` |
| [Goose](https://router.one/integrations/goose) | `OPENAI_HOST=https://api.router.one` (host root, no `/v1`) | `/v1/responses` — Goose routes gpt-6 names there | `GOOSE_MODEL=openai/gpt-6-sol` | Set `GOOSE_CONTEXT_LIMIT` yourself |
| [Qwen Code](https://router.one/integrations/qwen-code) | `OPENAI_BASE_URL` in `.qwen/.env` | `/v1/chat/completions` | `OPENAI_MODEL=openai/gpt-6-sol` | Or one `modelProviders.openai` entry |
| [Crush](https://router.one/integrations/crush) | `provider add router-one --type openai-compat --base-url https://api.router.one/v1` in `crushrc` | `/v1/chat/completions` | `router-one/openai/gpt-6-sol` | `--context-window` must be a whole number |
| [Claude Code](https://router.one/claude-code-china) | `ANTHROPIC_BASE_URL=https://api.router.one` | `/v1/messages` | Not possible | GPT ids are not served on Messages |

Every row except Claude Code ends on an endpoint that serves GPT-6 Sol, so the choice of tool does not change which model you can reach — it changes the request path, which in turn decides which Responses-only features are available. Each linked guide has the full setup for its tool; the sections below cover only what is specific to GPT-6 Sol.

## Codex CLI: one model line

Codex CLI speaks the Responses wire format, which Router One implements natively for GPT-family ids, so GPT-6 Sol is a one-line change from the config the Router One install script writes. The full file, with the model line set to GPT-6 Sol:

```toml
# ~/.codex/config.toml
model = "gpt-6-sol"
model_provider = "router"
model_reasoning_effort = "high"
model_verbosity = "high"
web_search = "live"

[model_providers.router]
base_url = "https://api.router.one/v1"
env_key = "ROUTER_ONE_API_KEY"
env_key_instructions = "Create an API key at https://router.one/dashboard/api-keys and set the ROUTER_ONE_API_KEY environment variable."
name = "Router One"
wire_api = "responses"
```

```bash
export ROUTER_ONE_API_KEY=sk-your-router-one-key
codex
```

Four details specific to this model:

- **Use the bare name.** `gpt-6-sol` is the name Codex's own configuration reference and model picker use, and Router One resolves it to `openai/gpt-6-sol`. The Codex CLI 0.156.1 release notes (2026-09-23) add GPT-6 Sol to the model picker; on an older build, update with `npm install -g @openai/codex` before relying on Codex's built-in defaults for this name.
- **Reasoning effort.** The template sets `model_reasoning_effort = "high"`. OpenAI's [GPT-6 Sol model page](https://developers.openai.com/api/docs/models/gpt-6-sol) lists `none`, `low`, `medium` (the default), `high`, `xhigh` and `max` for `reasoning.effort`; Codex's configuration reference notes that the available levels depend on the model and the client, so stay within the levels the model page lists.
- **Review requests.** `review_model` in `config.toml` sets the model `/review` uses. If Logs show requests for `codex-auto-review`, that is Codex's review line; the id is in the catalog, and the [Codex and Responses API page](https://router.one/codex-responses-api) explains it.
- **Wallet, not plan quota.** The install script writes `model = "gpt-5.6-sol"`, which is in the Premium models tier of the Pro, Max and Ultra plans. GPT-6 Sol is in no plan tier as of 2026-09-23, so on a plan, switching this line moves Codex's calls from plan quota to wallet billing. The [pricing page](https://router.one/pricing) shows which ids each plan covers today.

Never add `requires_openai_auth` to this provider block: it makes Codex ignore `env_key` and open the OpenAI login flow instead.

## The other tools in one block each

Every tool below takes the full catalog id `openai/gpt-6-sol`; where a tool prefixes its own provider id, the catalog id follows it unchanged.

**OpenCode** — add the model to the provider's `models` map and select it as `router-one/openai/gpt-6-sol`:

```json
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "router-one": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Router One",
      "options": {
        "baseURL": "https://api.router.one/v1",
        "apiKey": "{env:ROUTER_ONE_API_KEY}"
      },
      "models": {
        "openai/gpt-6-sol": { "name": "GPT-6 Sol (Router One)" }
      }
    }
  },
  "model": "router-one/openai/gpt-6-sol"
}
```

**Cline, Roo Code, Kilo Code** — API Provider "OpenAI Compatible", Base URL `https://api.router.one/v1`, your key, Model ID `openai/gpt-6-sol`. Kilo Code can also fetch the catalog from the gateway once the URL and key are in place.

**Cursor** — enable Override OpenAI Base URL, set it to `https://api.router.one/v1`, paste the key, click Verify, and add `openai/gpt-6-sol` as a custom model. The key covers the chat and Agent models you pick; Tab autocomplete, Auto and Cursor's own Composer models stay on Cursor's side. If a chat turn does not appear in Dashboard → Logs, it did not run on your key.

**Continue** — one `models` entry with `provider: openai`, `model: openai/gpt-6-sol`, `apiBase: https://api.router.one/v1` and `useResponsesApi: false`, as in the [Continue guide](https://router.one/integrations/continue).

**Zed** — in the `router-one` provider block, add `{ "name": "openai/gpt-6-sol", "display_name": "GPT-6 Sol", "max_tokens": 1050000 }` to `available_models`; the key goes in the Agent Panel settings or the `ROUTER_ONE_API_KEY` variable, never in `settings.json`.

**Goose** — `GOOSE_PROVIDER=openai`, `OPENAI_HOST=https://api.router.one`, `GOOSE_MODEL=openai/gpt-6-sol`. With the base path at its default, Goose sends names that look like gpt-5, gpt-6 or o-series models to `/v1/responses`, and `openai/gpt-6-sol` qualifies; the gateway serves that path natively for GPT-6 Sol, so nothing needs changing. Goose may not recognize the name for its own context default, so set `GOOSE_CONTEXT_LIMIT` explicitly (see the next section).

**Qwen Code** — `OPENAI_API_KEY`, `OPENAI_BASE_URL=https://api.router.one/v1` and `OPENAI_MODEL=openai/gpt-6-sol` in `.qwen/.env`.

**Crush** — keep the provider block from the [Crush guide](https://router.one/integrations/crush) and add the model with a whole-number window:

```bash
model add router-one/openai/gpt-6-sol --name "GPT-6 Sol (Router One)" --context-window 1050000
model large router-one/openai/gpt-6-sol
```

## Context window and output numbers per tool

Several tools ask you for numbers the gateway does not send them. For GPT-6 Sol the catalog values are a 1,050,000-token context window and a 128,000-token output limit; the model page shows the window rounded to "1.05M", and fields that need an integer take `1050000`. The window counts input and output together — OpenAI's model page lists 922,000 tokens as the maximum input — so leave headroom rather than letting a tool fill the whole window with history.

| Tool | Setting | What it controls |
| --- | --- | --- |
| Codex CLI | `model_context_window` | The window Codex assumes for the model |
| Zed | `max_tokens` per model | The context window Zed assumes for that model |
| Goose | `GOOSE_CONTEXT_LIMIT` | Goose's usage display and compaction; not what the gateway accepts |
| Crush | `--context-window` on `model add` | When Crush summarizes; without it Crush never summarizes |

These are client-side settings. A lower value only makes the tool compact or summarize earlier — which, for this model, is also the lever for the price line below.

## The 272,000-token line in long agent sessions

A coding agent resends the system prompt, the tool definitions, the whole conversation and every tool result on each turn, so input grows with the session. For GPT-6 Sol, the total input of one request selects the price tier: exactly at 272,000 tokens the lower line still applies, and once a request is strictly above it, the higher line applies to the whole request — output included, not only the tokens past the threshold. Cache reads count toward that total. Monthly volume plays no part. The [pricing methodology](https://router.one/pricing-methodology) states the rule and the [cost calculator](https://router.one/llm-cost-calculator) applies it per request.

In practice, the late turns of a long session can each cost noticeably more than the early ones, with nothing changing in the tool. Three ways to keep that visible and bounded:

1. **Watch input tokens per request.** Dashboard → Logs shows input tokens, cost and status for every turn; sort a session by time and the crossing point is obvious ([per-request observability](https://router.one/llm-observability)).
2. **Compact before the line.** In Crush, a window above 200,000 is summarized when 20,000 tokens remain, so `--context-window 290000` summarizes at about 270,000. In Goose, a lower `GOOSE_CONTEXT_LIMIT` compacts earlier. Compaction is itself a model request, it replaces older turns with a summary, and a single large tool output can still push one request over the line — you trade context for cost.
3. **Start a new session per task.** A fresh session resets the resent history; it is the simplest way to stay in the lower tier.

## One key per tool, each with a cap

Create a separate key for each tool — one for Codex CLI, one for Cursor, one for Cline — and give each a `maxSpend` cap. When a key reaches its cap, its next request gets HTTP 402, so that tool cannot spend past the number you chose, and your other keys keep working. Filtering Logs by key then answers "what did GPT-6 Sol cost in Cursor this week" without a spreadsheet ([per-key cost tracking](https://router.one/llm-cost-tracking)). Retryable upstream failures are absorbed by automatic fallback across the candidate routes for the same model, so a tool sees fewer transient errors mid-session.

The model page shows GPT-6 Sol's live rate beside the official list rate; across the catalog, pricing starts as low as 10% of official provider list prices (up to 90% off) on select models. Top up with a card or Alipay through one hosted checkout, or with USDT/USDC on six chains (Tron, BSC, Ethereum, Polygon, Base, Arbitrum). No US credit card required, and every tool above reaches the gateway from mainland China without a VPN.

## Why Claude Code cannot run GPT-6 Sol

Claude Code sends every request to `ANTHROPIC_BASE_URL` plus `/v1/messages`, the Anthropic Messages API. On Router One that endpoint serves the currently listed Claude-family and DeepSeek ids; GPT ids are served on Chat Completions and Responses only. Setting `ANTHROPIC_MODEL=gpt-6-sol` therefore gets HTTP 400 `invalid_request_error` before any model is called, and the error message names the endpoints that do serve the id ([error codes](https://router.one/llm-api-error-codes)).

Two working setups instead: keep Claude Code on a Claude id with the [Claude Code setup](https://router.one/claude-code-china), and run GPT-6 Sol in Codex CLI or OpenCode with the same key. [OpenCode vs Claude Code vs Codex CLI](https://router.one/blog/opencode-vs-claude-code-vs-codex-cli) compares the three terminal agents on one key, and [Cline vs Cursor vs Claude Code](https://router.one/blog/cline-vs-cursor-vs-claude-code) does the same for the editor side.

## FAQ

**Can I use GPT-6 Sol in Claude Code through Router One?**
No. Claude Code only calls /v1/messages, and Router One serves GPT ids on /v1/chat/completions and /v1/responses, not on Messages. A request for gpt-6-sol from Claude Code returns HTTP 400 invalid_request_error before any model runs. Use Codex CLI, OpenCode, Cline or another tool from the table for GPT-6 Sol, and keep Claude Code on a Claude or DeepSeek id.

**Which model string do I put in Codex CLI?**
gpt-6-sol, the bare name. It is the name Codex's own model list uses, and Router One resolves it to openai/gpt-6-sol. The rest of the config.toml stays as the Router One install script writes it: model_provider router, base_url https://api.router.one/v1, env_key ROUTER_ONE_API_KEY and wire_api responses.

**Codex offers GPT-6 Luna in its model picker. Does that work through Router One?**
Not as of 2026-09-23: gpt-6-luna is not in the Router One catalog, so a request for it is rejected. Pick an id that /models lists, and check the catalog again before switching, because ids are added and removed over time.

**Do GPT-6 Sol calls count against my subscription plan?**
Not as of the 2026-09-23 plan response: no Pro, Max or Ultra tier lists GPT-6 Sol, so its calls are billed per token from the wallet. GPT-5.6 Sol, the model in the Router One Codex install template, is in the Premium models tier of all three plans. The /pricing page shows the plan model lists that apply today.

**Why did requests late in a long agent session cost more?**
GPT-6 Sol carries a whole-request tier: once a single request's total input, cache reads included, is strictly above 272,000 tokens, the higher rate line applies to the whole request, output included. Agents resend the growing history on every turn, so late turns cross the line first. Start a new session per task (or, in tools such as Crush and Goose, let the tool summarize earlier), and watch input tokens per request in Dashboard → Logs.

**Goose sent GPT-6 Sol to /v1/responses although I never changed the base path. Is that a problem?**
No. With the default base path, Goose sends gpt-5, gpt-6 and o-series names to /v1/responses and everything else to /v1/chat/completions. Router One serves /v1/responses natively for GPT-6 Sol, so both paths work; confirm the path and status of the first turn in Dashboard → Logs.

**What context window should I enter for GPT-6 Sol?**
The catalog lists 1,050,000 tokens, so fields that need a whole number take 1050000, and the output limit is 128,000. The window counts input and output together, and a lower value only makes the tool compact earlier, which also keeps long sessions below the 272,000-token price line.

## Next steps

- Read the [GPT-6 Sol API guide](https://router.one/blog/gpt-6-sol-api-guide) for curl and SDK calls, endpoints and the billing rules.
- Compare the live spec sheets: [GPT-6 Sol vs GPT-6 Astra](https://router.one/models/compare/gpt-6-sol-vs-gpt-6-astra), [GPT-6 Sol vs GPT-5.6 Sol](https://router.one/models/compare/gpt-6-sol-vs-gpt-5-6-sol) and [GPT-6 Sol vs Claude Sonnet 5](https://router.one/models/compare/gpt-6-sol-vs-claude-sonnet-5).
- Set up Codex CLI with the one-line install on [Codex CLI in China](https://router.one/codex-china), or pick another tool from [all integration guides](https://router.one/integrations).

## See also

- Canonical page: https://router.one/blog/gpt-6-sol-coding-tools-setup
- Codex CLI China: https://router.one/codex-china
- All blog posts: https://router.one/blog
- Models and per-model token rates: https://router.one/models (markdown: https://router.one/models.md)
- Pricing: https://router.one/pricing
- API docs (markdown): https://router.one/docs.md
- Company facts: https://router.one/facts/company.md