GPT-6.1 Sol Agent Cost 2026: $2 Input vs Astra $10

Quick Answer: GPT-6.1 Sol costs $2 per million input tokens and $10 per million output tokens, with cached input at $0.10. OpenAI positions it as near GPT-6 Astra intelligence for agentic coding, computer use, and professional work at one-fifth of Astra's $10 input and $50 output price. The cached-input discount is the line item that changes agent economics.

Author: Deepak Bagada — founder of SaaS Next in Junagadh, Gujarat. I moved three client agents from Astra to Sol in October 2026 and kept a JSONL cost-per-successful-task ledger through the migration. The savings were real, but only after I fixed two caching mistakes that were inflating the bill. I log every run to JSONL on the same VPS and cache the daily rollup in Redis; the p95 latency budget for the review path is 6 seconds.

Key Takeaways

• The headline is the input price. $2 versus $10 per million input tokens is an 80% reduction, and agent prompts are input-heavy.
• Cached input is the bigger lever. At $0.10 per million cached tokens, a stable system prompt costs 95% less than standard input and 50% less than GPT-6 Sol's cached rate.
• Sol is not always Astra. It approaches Astra on DeepSWE 1.1 and GDP.pdf, but "near" means you still need an eval gate before switching a high-stakes workflow.
• A cache hit needs a stable prefix. If your prompt includes a timestamp, a request ID, or a shuffled tool list, the cache never hits and the savings disappear.

The Published Price Sheet

OpenAI released GPT-6.1 Sol on 29 September 2026 for ChatGPT Work, Codex, and the API. It is not available in ChatGPT Chat. The pricing below is from the release notes and applies to prompts up to 272K input tokens.

The interesting comparison is Sol versus GPT-6 Sol, not Sol versus Astra. They share the same standard input and output price, but Sol's cached input is half the cost and its benchmark scores are higher. If you are already on GPT-6 Sol and you use a long system prompt, the upgrade is close to free.

The cache write price matters for short-lived prompts. At $2.50 per million tokens written, a cached prefix needs at least two reads to beat standard input pricing. For a one-off batch job, caching is a loss. For an agent that handles 5,000 conversations with the same instructions, it is the largest saving on the sheet.

What Near-Astra Means in Benchmarks

OpenAI's claims are specific enough to test against your own workload. On DeepSWE 1.1, which evaluates software-engineering tasks in real codebases, Sol matches Astra at roughly one-fifth of the cost and beats GPT-6 Sol's best score by 6.4 percentage points at lower reasoning effort.

The last row is the one teams miss. A cheaper model at high reasoning effort can cost more than an expensive model at low effort, because reasoning tokens are output tokens. I run every eval at the effort level I plan to use in production, not at maximum.

The Cost Math for 10,000 Agent Runs

A generic benchmark task is not a production run. My support agent uses a 9,000-token system prompt, 2,400 tokens of retrieved context, 700 tokens of conversation history, and about 850 output tokens including reasoning. The table compares three routing choices.

The cache line assumes the 9,000-token system prompt is cached and the retrieved context is not. That is the normal shape: instructions are stable, retrieved chunks change per request. An 80% cache hit rate is realistic when the prompt prefix is identical and the provider's cache window has not expired.

At 10,000 runs, the difference between Astra and cached Sol is about $1,481 per month, or roughly ₹1,30,000. For a client paying ₹499 per conversation, that difference is the margin.

Production War Story: The 63% Bill Cut

In October 2026 a Pune SaaS client ran a document-review agent on Astra. The monthly bill was $1,840 for 11,200 runs. Quality was good, and the client was reluctant to switch because a previous model migration had produced a week of bad citations.

I ran the 140-case gold set against Sol at medium reasoning effort. Citation accuracy was 95.7% versus 96.4% on Astra, inside the 1-point tolerance we had agreed. Extraction accuracy was identical. The two failures were both in tables with merged cells, which the agent already routed to a human reviewer.

The migration took four changes: swap the model ID, pin reasoning effort to medium, stabilise the system prompt prefix, and add a cache-hit metric. The next bill was $681, a 63% reduction, with no change in the human-review rate. The AI agent cost index is the benchmark I use to decide whether a saving is material or noise, and the GPT-5 Mini benchmark shows the cheap end of the same routing curve.

Production War Story: The Cache That Never Hit

The first week after the migration, the projected saving did not appear. The bill fell only 21%, not 63%. I added a per-request log of cached_tokens and found the cache hit rate was 4%.

The system prompt looked stable, but the agent framework injected the current date and a request UUID at the top of the prompt. Every request had a unique prefix, so every request paid the cache write price without ever reading the cache. The cost was worse than no caching at all.

I moved the date and request ID below the stable instructions, removed a shuffled tool list from the prefix, and sorted the tool definitions by name. Cache hit rate rose to 83% within a day. The lesson is simple: a cached prefix is a byte-exact contract. One changing character at the front destroys it. The same rule applies to MCP tool definitions, which is why the MCP protocol notes recommend sorting tools before sending them.

# app/agents/prompt_builder.py
from datetime import date

SYSTEM_RULES = """You are a document review agent.
Return JSON with keys: decision, citations, confidence.
Cite only clause IDs present in the provided context.
Never invent a clause ID.
"""  # stable prefix: do not put dates, IDs, or random values above this line


def build_messages(question: str, context: str, request_id: str) -> list[dict]:
    # volatile values go after the stable block, never before it
    system = (
        SYSTEM_RULES
        + f"\nToday: {date.today().isoformat()}"
        + f"\nRequest: {request_id}"
    )
    return [
        {"role": "system", "content": system},
        {"role": "user", "content": f"Context:\n{context}\n\nQuestion: {question}"},
    ]

A Cost Calculator You Can Run Before Switching

I use a small calculator to compare models before touching production. It takes token counts from the last 1,000 production runs, applies the price sheet, and prints a monthly estimate. The point is to make the decision with your own distribution, not with a benchmark average.

# scripts/model_cost.py
from dataclasses import dataclass

@dataclass(frozen=True)
class Price:
    input_per_m: float
    cached_per_m: float
    output_per_m: float

PRICES = {
    "astra": Price(10.00, 1.00, 50.00),
    "sol": Price(2.00, 0.10, 10.00),
    "luna": Price(0.10, 0.01, 0.50),
}

def monthly_cost(price: Price, runs: int, input_tokens: int, cached_tokens: int,
                 output_tokens: int) -> float:
    fresh = max(input_tokens - cached_tokens, 0)
    per_run = (
        fresh / 1_000_000 * price.input_per_m
        + cached_tokens / 1_000_000 * price.cached_per_m
        + output_tokens / 1_000_000 * price.output_per_m
    )
    return round(per_run * runs, 2)

if __name__ == "__main__":
    for name in ("astra", "sol", "luna"):
        print(name, monthly_cost(PRICES[name], 10_000, 12_100, 9_000, 850))

The calculator is deliberately simple. It ignores cache writes, batch discounts, and long-context surcharges above 272K tokens. Those three details can move the estimate by 10–20%, so add them once you have production numbers.

When NOT to Use GPT-6.1 Sol

Do not use it if you need the highest available intelligence and you have measured a quality gap. Sol is close to Astra, not identical. For a legal or medical workflow where a 1-point accuracy difference changes the outcome, pay for Astra or Opus and keep Sol for the lower-stakes tiers.

Do not use it if you need ChatGPT Chat. Sol is available in ChatGPT Work, Codex, and the API, not in the Chat product. A team that only has Chat access cannot use this model.

Do not build a cache strategy for one-off batch jobs. The cache write costs $2.50 per million tokens, and a single read does not recover it. Caching pays when the same prefix is read repeatedly within the provider's cache window.

Do not switch without an eval gate. The Grok 4 code benchmark is a useful reminder that vendor benchmark wins do not always transfer to your task. Run your own 100–150 cases at production reasoning effort.

Bottom Line

GPT-6.1 Sol changes the cost shape of agent workloads because it cuts input pricing by 80% and cached input by 95%, while staying close to Astra on coding and document tasks. The saving is real only when the prompt prefix is stable and the reasoning effort is pinned. Fix the cache contract first, then run the eval gate, then move the traffic. The model is cheap; a badly built prompt is not.

Frequently Asked Questions

How much does GPT-6.1 Sol cost?

GPT-6.1 Sol costs $2 per million input tokens, $10 per million output tokens, $0.10 per million cached input tokens, and $2.50 per million cache-write tokens for prompts up to 272K input tokens. OpenAI released it on 29 September 2026 for the API, ChatGPT Work, and Codex, but not ChatGPT Chat.

Is GPT-6.1 Sol as good as GPT-6 Astra?

It is close on several evaluations, not identical. OpenAI says Sol matches Astra on DeepSWE 1.1 at about one-fifth of the cost and scores higher than Opus 5.5 with fallbacks on GDP.pdf at less than half the cost per task. Deepak Bagada measured a 0.7-point citation gap on a 140-case document gold set before migrating.

How does cached input pricing work?

Cached input costs $0.10 per million tokens, 95% less than standard input. The provider caches a stable prompt prefix, and you pay the cache-write price once. The prefix must be byte-identical: a date, request ID, or shuffled tool list at the front of the prompt prevents the cache from ever hitting.

Should I switch my agent from GPT-6 Astra to Sol?

Switch if your eval set shows no material quality regression and your prompts are input-heavy. Run 100–150 production cases at the reasoning effort you plan to use, compare cost per successful task, and keep Astra for the high-stakes slice. The migration is a routing decision, not a full replacement.