GPT-6 Sol on the Felo API: The Middle Tier Is the One You Actually Ship On

GPT-6 Sol sits between the Astra flagship and the Luna fast tier at $2 per million input tokens. Here is the arithmetic of the middle rung, and the routing pattern that gets flagship outcomes without flagship spend.

Three tiers, one API key: the middle rung is where most production traffic lands.

Every model launch produces the same two reactions. Someone runs the flagship on a hard benchmark and posts the score. Someone else points out that the cheapest tier handles 80% of real traffic and costs a hundredth as much. Both are right, and neither is the model most production teams end up standardizing on.

GPT-6 Sol is now available on the Felo API. It is the middle of OpenAI's GPT-6 lineup: below the flagship GPT-6 Astra, above the fast GPT-6 Luna, priced at $2.00 per million input tokens and $10.00 per million output tokens. It is built for demanding professional work that needs strong reasoning without flagship pricing, and for a lot of teams that description is the whole job.

The GPT-6 ladder, priced

The GPT-6 series on Felo now has three rungs, all with the same 1.05M-token context window and 128K max output:

Route	Model ID	Input / M	Output / M	Latency	Position
GPT-6 Astra	gpt-6-astra	$10.00	$50.00	Deep	Flagship: hardest end-to-end work
GPT-6 Sol	gpt-6-sol	$2.00	$10.00	Balanced	High-end, cost-efficient: professional work
GPT-6 Luna	gpt-6-luna	$0.10	$0.50	Fast	High-volume and latency-sensitive work

Read the ratios rather than the prices. Astra costs 5x Sol on both input and output. Sol costs 20x Luna. So the lineup is not a gentle gradient; it is three distinct price classes with the same context window attached.

Two details make the decision interesting. First, you are not trading context length for cost anywhere in this lineup: all three carry 1.05M tokens of context, so a routing decision is about how hard the task is, never about how much text it involves. Second, Felo labels the three rungs by latency class, deep, balanced, fast, in the same order as the price. Sol is the balanced one on both axes, which is why it is the tier teams tend to land on.

What Sol is for

Sol's listed strengths are professional work, coding agents, reasoning tasks, and long-context analysis. The route supports reasoning, tool calling, structured output, streaming, and vision: the full feature set, minus the flagship's search capability.

The honest description of the middle tier is that it fails gracefully. Ask Luna to plan a database migration and you get a plausible plan with a subtle ordering bug. Ask Astra and you get a plan you can run, at 5x the price. Ask Sol and you usually get the plan, occasionally need one more pass, and pay a fifth of flagship rates the whole time. For a team shipping a product, "usually right, cheap to retry" beats both extremes.

The arithmetic of the middle

Model choice arguments get abstract fast, so here is a concrete month. Suppose your product moves 400 million tokens a month in a 4:1 input-to-output mix (320M in, 80M out), the shape most chat and retrieval systems settle into. Half the volume is high-volume work (classification, extraction, short chat), half is genuinely hard work (planning, agentic coding, long-context analysis).

Monthly plan	Input cost	Output cost	Total
Everything on Astra	320M × $10 = $3,200	80M × $50 = $4,000	$7,200
Everything on Sol	320M × $2 = $640	80M × $10 = $800	$1,440
Split: Luna for half, Sol for half	$16 + $320 = $336	$20 + $400 = $420	$756

The point of the table is not that the split is always right. It is that the difference between "we route by task" and "we picked one model" is close to an order of magnitude, and the gap between Sol and Astra is a clean factor of five on every token you move.

Felo's published launch pricing may be up to 50% lower than official provider rates, which shifts the absolute numbers but not the ratios. The ratios are what you are actually deciding with.

Monthly cost for 400M tokens at a 4:1 input-to-output ratio. Illustrative rates.

When to reach up, when to step down

Reach for Astra when the task is end-to-end and expensive to get wrong: computer use, multi-step agentic coding on a live repo, research that has to be right the first time, professional document generation. Paying 5x to avoid one bad plan is the correct trade on work you can't easily redo.

Step down to Luna when the task is frequent and the failure is cheap to detect. Classification with a confidence check, extraction validated by a schema, routing, short chat turns, subagent calls that a parent model will review anyway. If a wrong answer costs you a retry rather than a rollback, the cheap tier is the right tier.

Sol sits between those poles and covers the wide middle: coding agents that write code a human reviews, reasoning tasks with real stakes, and analysis over long documents. That is most of what an AI product does all day.

A routing pattern

Because all three routes share one API key and one base URL, tiering is a configuration detail. The pattern below routes by task class and escalates on failure, which is the cheapest way to get flagship-quality outcomes without flagship-level spend on everything.

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.FELO_API_KEY,
  baseURL: "https://openapi.felo.ai/api/v1",
});

const TIERS = { fast: "gpt-6-luna", standard: "gpt-6-sol", deep: "gpt-6-astra" };

async function run(task, tier = "standard") {
  const response = await client.responses.create({
    model: TIERS[tier],
    input: task.prompt,
  });
  return response.output_text;
}

// Escalate only when the cheap answer fails a check you trust.
let answer = await run(task, "fast");
if (!passesValidation(answer)) {
  answer = await run(task, "standard");
}
if (!passesValidation(answer)) {
  answer = await run(task, "deep");
}

Two notes on the mechanics. Sol speaks the Responses protocol, and the platform also exposes the other compatible surfaces if your client is built around them. And when a task runs long enough to span turns, the platform's guidance is to preserve reasoning metadata across those turns so the model does not re-derive its own decisions.

The long-context case for Sol

The 1.05M-token context window is the quiet feature of the whole GPT-6 line, and Sol is the rung where it is affordable to actually use. Consider a support operation that wants root-cause analysis over a quarter of ticket history, or an engineering team that wants a reviewer that has read every file in a monorepo. Those workloads are token-hungry on the input side and produce moderate outputs, which is the exact shape Sol prices well: cheap reads, reasonable writes, no summarization tax.

If your pipeline currently truncates documents to fit a smaller window, the interesting experiment is not "how much better is Sol than my current model" but "what does the system do when nothing gets truncated". Usually the answer is a shorter prompt and a better answer, because the model is no longer missing the middle of the file.

Sol Pro exists

One more lever: GPT-6 Sol Pro serves the same underlying model with reasoning effort set to pro, trading latency for accuracy while keeping Sol's token pricing. That is the right switch for high-stakes analysis or agent planning, where being right matters more than being quick. It is a different model ID (gpt-6-sol-pro) on the same key, so testing it costs you a string change.

Get started

GPT-6 Sol is live now on the Felo API Platform. The model page has current rates, the parameter reference, and drop-in code for the Responses protocol:

GPT-6 Sol on the Felo API Platform

Standard accounts start with 200 free credits per day, so the tier comparison above is something you can measure on your own traffic before you commit to a splitting strategy. Bring a batch of real tasks, run them through two rungs, and let your evaluation set tell you where the middle is.