Official GPT-5.6 pricing is simple: Sol costs $5 per million input tokens and $30 per million output tokens, Terra costs $2.50 and $15, and Luna costs $1 and $6. The invoice for an AI agent is not that simple. Agents call tools, operate browsers, retry failed steps, escalate exceptions, and sometimes consume human review time. A cheaper model can produce a more expensive workflow if it causes extra browser runs or incomplete results. The useful metric is cost per completed task, not cost per tok

Official GPT-5.6 API pricing

For a single chat, the calculation is straightforward:

Model cost =
  input tokens ÷ 1,000,000 × input rate
  + output tokens ÷ 1,000,000 × output rate

Suppose a task consumes 40,000 input tokens and 8,000 output tokens:

Pro Tip: Log input and output tokens by workflow stage. A single total cannot show whether expensive reasoning is being used for planning, extraction cleanup, or repeated error messages.

Why agent cost is different from chat cost

A chat request normally ends when the model produces an answer. An agent may need to prove that an external outcome occurred.

A competitive-pricing task might:

1. Interpret the requested market and products.
2. Open five live websites.
3. Select annual billing on each page.
4. Extract prices and plan limits.
5. Retry a page whose JavaScript did not finish loading.
6. Compare the results with last week's observations.
7. Ask Sol to resolve one ambiguous promotion.
8. Update an approved report.

The cost surface now includes more than tokens:

Completed-task cost =
  model cost
  + browser runtime cost
  + external tool cost
  + retry cost
  + escalation cost
  + human review cost

The denominator is equally important:

Cost per completed task =
  total workflow spend ÷ verified successful tasks

If a $0.09 Luna run succeeds 60% of the time, the model portion alone is effectively $0.15 per successful outcome before retries. If a $0.22 Terra run succeeds 95% of the time, its effective model cost is about $0.23. The gap is much smaller than the list price suggests.

The seven costs hidden behind token pricing

1. Browser runtime

Dynamic pages require a real browser, rendering time, network traffic, and session resources. Longer runs cost more even when the model is idle.

2. Tool calls

Search, document parsing, databases, email, storage, and proprietary APIs may have their own usage charges. A model that calls tools unnecessarily can increase total cost without producing more value.

3. Failed attempts

A failed run still consumes tokens and browser time. Repeating the same broken action compounds the loss.

4. Recovery

Recovery is cheaper than restarting when the system preserves browser state and evidence. Without resumability, a failure at step nine may repeat the first eight steps.

5. Model escalation

Routing an exception from Luna or Terra to Sol adds cost, but it may be cheaper than allowing the lower tier to retry blindly.

6. Human intervention

Approval is often correct and intentional. Unplanned human debugging is different. Five minutes of an engineer's time can exceed the model cost of hundreds of routine tasks.

7. Incomplete or incorrect outcomes

The most expensive run can be the one reported as successful with the wrong region, account, price, or source. Verification cost belongs in the budget because it protects against downstream errors.

Pro Tip: Separate “human approval required by policy” from “human rescue required by failure.” Reducing the second improves reliability; reducing the first may weaken safety.

A cost-per-completed-task example

Consider 1,000 weekly website-monitoring jobs. These numbers are illustrative, not vendor quotes.

A practical GPT-5.6 routing strategy

Use Luna for work with clear boundaries and deterministic validators:

• Classify a job.
• Normalize fields.
• Check required values.
• Route a verified record.

Use Terra for the normal decision path:

• Follow a repeatable research plan.
• Compare current and previous observations.
• Summarize verified sources.
• Handle expected page states.

Use Sol for ambiguity and consequence:

• Plan a new workflow.
• Resolve conflicting evidence.
• Diagnose an unexpected page.
• Review high-impact recommendations.
• Supervise parallel workers.

The Sol vs Terra vs Luna model guide provides a full decision matrix. The economic principle is simple: route by uncertainty, not by content length alone.

How BrowserAct affects the cost equation

BrowserAct is not a discount on OpenAI token prices. Its economic role is reducing duplicated execution work and failed browser runs.

A shared browser layer can preserve the website workflow while the model tier changes:

Luna: classify and normalize
  → BrowserAct: retrieve live page evidence
  → Terra: evaluate the normal case
  → Sol: resolve the exception
  → BrowserAct: execute the approved action

The same session, selected filters, page evidence, and structured output can be reused across the routing chain. The browser does not have to restart because the reasoning tier changes.

Reusable BrowserAct agent skills also reduce engineering repetition. Instead of rebuilding login, navigation, extraction, and handoff behavior for every agent, teams can reuse a defined browser capability and measure it consistently.

This affects two cost categories that token tables ignore:

• Implementation cost: how much engineering is required to create and maintain the workflow.
• Failure cost: how much work is repeated when a page, session, or step changes.

Pro Tip: Version browser skills and model prompts separately. When success rate changes, this makes it possible to identify whether the model, website workflow, or evidence contract caused the regression.

Build a pricing dashboard that reflects reality

Track these fields for every production workflow:

The pricing recommendation

Use official GPT-5.6 pricing to estimate the direct model component. Use completed-task telemetry to decide the architecture.

Start new and ambiguous workflows with Sol. Move the normal path to Terra after the task contract and evidence are stable. Move bounded, high-volume transformations to Luna when software can validate the result. Keep browser execution and evidence consistent across all three tiers.

The cheapest token is not the goal. The goal is the lowest reliable cost for a verified outcome.

The GPT-5.6 release overview covers availability and benchmarks. The complete browser automation guide explains the surrounding agent architecture.

Reduce browser workflow cost with reusable BrowserAct skills →

Sources

• OpenAI — GPT-5.6 pricing and release
• TechCrunch — GPT-5.6 launch and pricing
• Every — GPT-5.6 Sol Vibe Check

Frequently asked questions

How much does GPT-5.6 cost?

Per million input and output tokens, GPT-5.6 Sol costs $5 and $30, Terra costs $2.50 and $15, and Luna costs $1 and $6.

Which GPT-5.6 model is cheapest?

Luna has the lowest token price. It is cheapest for bounded tasks only when its accuracy does not create extra retries, escalations, or human review.

How do you calculate GPT-5.6 agent cost?

Add model tokens, browser runtime, external tools, retries, escalation, and human time, then divide total spend by verified successful tasks.

Is Terra more cost-effective than Sol?

Terra can be more cost-effective for stable repeatable workflows. Sol may be cheaper overall for highly ambiguous work if Terra would require multiple retries and escalation.

When should an agent use Luna?

Use Luna for classification, normalization, validation, routing, and other high-volume tasks with clear schemas and deterministic checks.

Can BrowserAct reduce GPT-5.6 token prices?

BrowserAct does not change OpenAI's token rates. It can reduce total workflow cost by reusing browser skills, preserving execution state, structuring evidence, and avoiding repeated implementation or failed runs.