早鸟价(12 月 25 日截止),订阅期间一直锁定:Go $10/月(原价 $20),Plus 用 Opus 5.5 只要 $30/月(原价 $50)立即订阅 →
文本对话1M 上下文

GPT-6 Sol

以 OpenAI 官方价格的 30% 运行 GPT-6 Sol:每 100 万输入 Token 仅需 $0.60,每 100 万输出 Token 仅需 $3.00。将其与 GPT-6 Luna、GPT-5.6 Sol、Opus 5.5 和 Gemini 3.8 Flash 进行对比,并通过可直接复制的 curl、Python 和 Node 代码进行调用。

价格 / 100 万 token
AIReiter
≤ 272,000 · 输入$0.60
≤ 272,000 · 输出$3.00
> 272,000 · 输入$1.20
> 272,000 · 输出$4.50
说明文档
输入
限制回复长度。推理模型也会把思考计入其中。
gpt-6-sol
输出

A codebase you don't know is a risk, not a hurdle. The plan should burn down that risk in order: understand, run, trace, spike, then make the change small enough that "production-ready" is a property you can demonstrate, not a hope.

Here are the first five steps, with the evidence you collect at each.

Step 1 — Get it building and the baseline green (half day)
Read the README, the manifest(s), the CI config, and any architecture docs. Boot the app locally, run the full test suite, run the linter/typechecker.
Evidence: The exact commands that reproduce a clean build and a passing test suite from a fresh checkout (recorded output, not memory of it). A one-page map you wrote yourself: where the entry points are, the layers, the build/test toolchain, and the main risks to your feature (e.g. "this touches cron jobs and payments").

Step 2 — Trace the smallest end-to-end slice that resembles your feature (half day)
Don't start with your feature. Pick a neighboring one that already works and follow it from entry to persistence. Note the conventions along the way: how errors surface, how config is injected, how logging is done, how tests are written.
Evidence: An annotated trace — file → function → what it does — for that slice. A written list of "conventions I must follow" (not intuitions; things you observed in real code). A named shortlist of the 3–5 files you will actually touch. If you can't produce this trace, you're not ready to write code.

Step 3 — Spike the core path (day 2)
Build the ugly version: hardcoded values, no error handling, no tests. The purpose is to confirm the path you traced in step 2 is real and to surface what you didn't know you didn't know.
Evidence: A working spike demonstrating the feature's central data path, alongside a list of every assumption the spike broke and what you corrected. That correction list is the most valuable document in this whole plan.

Step 4 — Write the contract before the code (half of day 2 / day 3)
Once the spike proves the path, pin down what production needs: the inputs/outputs, the error cases, where it sits in the conventions from step 2. Then write the tests — they'll be red, but they're the specification.
Evidence: A one-to-two-page design doc, an agreed interface/API shape (with the team if there is one), and a red test suite that encodes intended behavior. If you can't write the contract without consulting the code, you haven't finished step 2.

Step 5 — Implement in small, verified increments (days 3–4)
Replace the spike with the real thing in small commits, each one keeping the suite green, leaning on the existing patterns. Run lint/tests/typecheck per commit — CI, not just locally — and exercise the actual path against a real instance (staging or a local environment that isn't stubbed).
Evidence: A branch with progressive commits, each green in CI; coverage on the new code; something that proves it works against reality (a test result, a log trace, a screenshot); and a review by at least one person who knows the codebase. The review counts as evidence — an unfamiliar codebase has tribal knowledge you cannot extract from the files alone.

Steps 6+ would be the things that actually make it "shipped": a migration plan and its rollback, feature flagging, observability, the release and post-release verification. But the first five get you to a reviewed, green, working slice in staging — which is the point at which you can say "this will work in production" with evidence behind it, instead of a guess.

生成耗时42.7s
输入 Token134
输出 Token2,354
token / 秒55.13
TTFT-

运行会以此提示词打开 AI Chat,需要登录并有积分。

模型详情

在 Playground、API 请求和内部工作流中使用相同的模型 key。

模型 ID
gpt-6-sol
供应商
OpenAI
协议
OpenAI Chat Completions
上下文窗口
1,050,000 Token
最大输出
128,000 Token

GPT-6 Sol 是什么

GPT-6 Sol 对比

GPT-6 Sol 代码示例

GPT-6 Sol 成本示例

何时使用 GPT-6 Sol,何时不使用

管理 API 密钥 →

Sol 是进阶升级层。将所有请求无脑路由给它是最常见、也最昂贵的错误。

01适用场景:多文件调试

对于起因在于模块间交互而非单一函数的 Bug,较便宜的模型往往只能治标不治本。

02适用场景:长周期 Agent

需要在经历十几次工具调用、部分失败和修正后仍不偏离主线的复杂计划。100 万 Token 的上下文窗口可容纳完整轨迹。

03适用场景:权衡利弊的决策

在架构设计和技术迁移决策中,最有价值的输出是客观中肯的权衡对比,而非盲目自信的单向建议。

04不适用场景:常规流量

分类、提取、摘要和一线客服回复等任务。GPT-6 Luna 的输入成本仅为其二十分之一,且能可靠完成这些任务。仅在成本更低的模型明确无法胜任时,再将请求路由至 Sol。

用 3 步试用 GPT-6 Sol

  1. 01

    设置推理力度

    建议从 medium(中等)开始。对于需要模型先规划再回答的问题可以提高该值;当延迟要求高于推理深度时可以降低该值。

  2. 02

    发送 Prompt

    请粘贴您的实际任务而非测试用例。每次响应下方都会显示 Token 用量和消耗的额度,以便您在正式接入前预估工作负载成本。

  3. 03

    复制 API 调用代码

    将相同的请求迁移至代码中,使用模型 ID gpt-6-sol 并请求兼容 OpenAI 的端点。您的客户端无需做其他任何更改。

常见疑问

01GPT-6 Sol 在 AIReiter 上的价格是多少?

每 100 万输入 Token 为 $0.60,每 100 万输出 Token 为 $3.00,相当于 OpenAI 官方价格($2.00 和 $10.00)的 30%。缓存输入读取费用为每 100 万 Token $0.06,而官方价格为 $0.20。

02GPT-6 Sol 比 GPT-5.6 Sol 更好吗?

在同等旗舰级别下,它的价格仅为一半,这是显而易见的优势。在能力方面则各有优劣:发布时的对比评测显示,GPT-5.6 Sol 在某些编程和计算机操作基准测试中仍处于领先地位。建议在切换生产路由前,先结合您自己的实际业务流量进行评估。

03我应该使用 Sol 还是 Luna?

所有常规任务推荐使用 Luna,其输入价格为每 100 万 Token $0.10(Sol 为 $2.00)。复杂的代码、长推理链以及需要从失败步骤中恢复的 Agent 则推荐使用 Sol。采用分流路由架构(仅在失败时升级至 Sol)的成本,远低于将所有请求直接发送给 Sol。

04上下文窗口有多大?

约 1M 输入 token,最多支持 128K 输出 token。输入 token 超过 272K 的请求需支付 OpenAI 的附加费(输入 2 倍,输出 1.5 倍),因此保持在该阈值以下会显著降低账单费用。

05是否支持 Prompt 缓存?

支持,而且这是最有效的成本优化手段。缓存的输入读取可享受 90% 的折扣,并且该代模型支持显式设置缓存前缀结束的断点,在调整 reasoning effort 或切换工具时不会导致缓存失效。

06如何通过 Claude Code 或 Codex CLI 调用它?

两者均可直接配合 AIReiter key 正常运行。Codex CLI 及其他兼容 OpenAI 的客户端使用 https://aireiter.com/api/v1,Claude Code 使用 https://aireiter.com/api。模型 ID 为 gpt-6-sol。

07GPT-6 Sol 是何时发布的?

OpenAI 于 2026 年 9 月 22 日(即 GPT-6 Astra 发布 19 天后)发布了 GPT-6 Sol 和 GPT-6 Luna,同时该系列每 token 的 API 价格下调了约 50%。