GPT-6 Sol or GPT-6.1 Sol: choosing by price, cache and index

Both models come from the same line: 1M context, image input, the same official vendor price. In Zukko, though, GPT-6.1 Sol costs roughly twice as much as GPT-6 Sol. The "GPT-6 Sol or GPT-6.1 Sol" question comes down to three things: price at your volume, caching, and testing on your own tasks. Let's go through each.

What we know about the two models

Prices are in dollars per 1M tokens, as of October 6, 2026.

What the table shows:

• GPT-6.1 Sol input is 0.27 / 0.13 ≈ 2.08 times the price, output 1.32 / 0.63 ≈ 2.10 times.
• Cache reads cost the same — 0.013. That matters for agents, covered below.
• Neither has a separate cache-write charge: the first request and new parts of the context are billed at the input price.
• No difference in context or image support.

Current models and prices: GET https://api.zukko.pro/v1/models or the Models page in the dashboard.

The intelligence index: what we know and what we don't

The Zukko catalog uses an intelligence index to compare models — the Artificial Analysis Intelligence Index, an aggregate score over a set of benchmarks. For GPT-6.1 Sol it's 52. For GPT-6 Sol our table has no value.

That means exactly one thing: we don't have a number. A missing index doesn't say GPT-6 Sol is worse, and it doesn't say it's the same. Drawing quality conclusions from the version number isn't a good idea either.

For orientation, here's what sits nearby with known values: GPT-6 Astra — 53, Claude Opus 5.5 — 58. At the same price as GPT-6 Sol (0.13 / 0.63) the catalog also has GPT-5.6 Terra with an index of 42 — that's a separate model, and its index says nothing about GPT-6 Sol.

Besides, the index is an aggregate score over general tests. On a specific task the ranking can differ, so only testing on your own data gives the final answer.

Comparing GPT-6 Sol and GPT-6.1 Sol cost on real volume

The formula for any scenario: cost = fresh input × input price + cache reads × cache read price + output × output price. There is no cache-write line for GPT: the gateway sees only reads. Volumes are in millions of tokens.

Plain requests without caching

Say a day brings 2M input tokens and 0.2M output tokens — for example, a service answering short questions with varied prompts.

• GPT-6 Sol: 2 × 0.13 + 0.2 × 0.63 = 0.26 + 0.126 = $0.386.
• GPT-6.1 Sol: 2 × 0.27 + 0.2 × 1.32 = 0.54 + 0.264 = $0.804.

The difference is $0.418 per day at this volume.

An agent with a long context

An agent sends the model the whole accumulated conversation on every step, and most of the input comes from cache. Say a session adds up to 10M input tokens: 9M cache reads and 1M fresh input (including parts of the context sent for the first time: GPT has no separate cache write); output is 0.3M.

• GPT-6 Sol: 1 × 0.13 + 9 × 0.013 + 0.3 × 0.63 = 0.13 + 0.117 + 0.189 = $0.436.
• GPT-6.1 Sol: 1 × 0.27 + 9 × 0.013 + 0.3 × 1.32 = 0.27 + 0.117 + 0.396 = $0.783.

The gap is smaller than in the first scenario ($0.347 vs $0.418, and 1.8 times vs 2.08): the largest part of the input — cache reads — costs the same on both models. Most of the difference comes from output.

The practical takeaway: in agent scenarios keep the start of the prompt stable — system instruction, tool descriptions, reference documents first, the changing part last. Then more of the input hits the cache. For GPT models the cache is visible in both API formats: in the OpenAI format it's in usage.prompt_tokens_details.cached_tokens. The split in the example is illustrative; check your own in the usage history.

When to pick which

GPT-6 Sol makes sense as the default where volume is high and mistakes can be caught by a check: drafts, data extraction with validation, an agent's first pass, tasks where you've already verified quality on a sample.

GPT-6.1 Sol — when you need a model with a known index (52) in this price range, when mistakes are expensive, or when GPT-6 Sol failed your test.

A working pattern for many tasks is a cascade: the request goes to GPT-6 Sol, and only if the result fails an automatic check (tests fail, JSON is invalid, required fields are missing) is it retried on GPT-6.1 Sol. You pay for the pricier model only on hard cases. How to pick the threshold and cost such a setup is covered in the article on model cascades↗.

How to test on your own tasks

1. Collect 30–50 real tasks where you can say "pass / fail": a reference answer, a test, a set of required fields.
2. Run both models with the same prompt and the same parameters.
3. Record each model's pass rate and cost.
4. Compare the cost per successful answer: total cost / number of passed tasks.

A Python script for this comparison. The model changes in one line; the key stays the same.

import os

from openai import OpenAI

client = OpenAI(base_url="https://api.zukko.pro/v1", api_key=os.environ["ZUKKO_API_KEY"])

PRICES = {  # $ per 1M tokens: input, output, cache read
    "gpt-6-sol": (0.13, 0.63, 0.013),
    "gpt-6.1-sol": (0.27, 1.32, 0.013),
}


def run(model: str, prompt: str):
    r = client.chat.completions.create(

You write passes(answer, task) for your task: compare with a reference, run a test, check fields. GPT has no separate cache-write charge, so the formula has no other cost lines; the exact amount is in the Usage section of the dashboard. Request parameters are covered in the chat/completions docs↗.

If GPT-6 Sol passes as many tasks, take it. If it passes noticeably fewer, compare cost per success: a cheap model with retries sometimes ends up more expensive.

The minimum top-up is enough for the test: create a key under API keys↗, and both models are available on it right away.

FAQ

Why doesn't GPT-6 Sol have an intelligence index?

The Zukko catalog has no index value for it. It's missing data, not a rating. Test on your own tasks.

Do they have the same context and image support?

Yes: both have a 1M-token context and both accept images as input.

Do I need to change code to switch?

No, just change the model value. The key and the https://api.zukko.pro/v1 address stay the same. The models are also available in the Anthropic format — the gateway converts the request; see choosing a format↗.

Does caching give a discount on both models?

Yes, a cache read costs $0.013 per 1M on both, versus 0.13 and 0.27 for regular input. How much input came from cache is shown in prompt_tokens_details.cached_tokens.