---
title: "Agentic AI technical appendix: cost model | Ortoo"
url: https://ortooapps.com/resources/blog/hidden-economics-of-agentic-ai-technical-appendix
description: "Prices, token assumptions, formulas and sensitivity behind the worked example in The hidden economics of agentic AI. Model charges only, illustrative."
lang: en
---

# The hidden economics of agentic AI: technical appendix

Elisa Mustonen · 17 November 2026 · 6 min read

The prices, assumptions, formulas and sensitivity behind the worked example in The hidden economics of agentic AI (https://ortooapps.com/resources/blog/hidden-economics-of-agentic-ai). The figures are an illustrative estimate of model inference charges only. They are not customer data.

## A1. Model prices used

USD per 1 million tokens, standard processing, short context. Checked against the providers' pricing pages on 17 November 2026.

| Provider | Model | Input | Cached input | Cache write (short) | Output |
| --- | --- | --- | --- | --- | --- |
| OpenAI | GPT-6 Luna | $0.10 | $0.01 | $0.125 | $0.50 |
| OpenAI | GPT-6.1 Terra | $1.00 | $0.05 | $1.25 | $5.00 |
| OpenAI | GPT-6.1 Sol | $2.00 | $0.10 | $2.50 | $10.00 |
| OpenAI | GPT-6 Astra | $10.00 | $1.00 | $12.50 | $50.00 |
| Anthropic | Claude Haiku 5.5 | $0.10 | $0.01 | $0.125 | $0.50 |
| Anthropic | Claude Sonnet 5.5 | $2.00 | $0.10 | $2.50 | $10.00 |
| Anthropic | Claude Opus 5.5 | $4.00 | $0.20 | $5.00 | $20.00 |
| Anthropic | Claude Fable 5.1 | $10.00 | $0.25 | $12.50 | $50.00 |
| Anthropic | Claude Fable 5.2 | $8.00 | $0.20 | $10.00 | $40.00 |

Short cache: 30 minutes at OpenAI, 5 minutes at Anthropic. Claude Fable 5.2 is Anthropic's newest frontier model; the worked example and the article's frontier price class use Claude Fable 5.1, which is still listed. OpenAI cache-write charges apply to GPT-5.6 and later through the Responses API. Claude Haiku 5.5 rates apply to prompts up to 100,000 tokens; above that, all of the request is billed at $0.50 input and $2.50 output.

## A2. Billing mechanics

- Reasoning. OpenAI bills reasoning tokens as output; they are not visible through the API. Anthropic bills the full thinking process as output, whatever is displayed. Thinking from earlier turns that stays in context is billed again as input.
- Caching. OpenAI: writes at 1.25x input (30 minutes) or 2.5x (12 hours); reads at 0.1x, or 0.05x on GPT-6.1 Sol and Terra; minimum cacheable prompt 1,024 tokens. Anthropic: 5-minute writes at 1.25x; reads between 0.025x and 0.1x depending on the model.
- Processing tiers. OpenAI Batch and Flex at 0.5x standard, Fast at 2x, Ultrafast at 6x (GPT-6 Astra and GPT-6.1 Sol only). Anthropic Batch at 50% off.
- Data residency. OpenAI regional processing adds 10% for models released from 5 March 2026.
- Tools. Tool definitions are sent as input on every call that includes them; tool results return as input.

## A3. Formulas

Cost of one execution of a step, where P = stable prefix tokens per call (instructions and tool definitions), h = cache-hit rate on the prefix, H = earlier-turn context re-read from cache, N = new input tokens, R = reasoning tokens, V = visible output tokens, and i, r, w, o = input, cache-read, cache-write and output prices. k is the number of model calls in the step.

```
C(step) = k × P × (h × r + (1 - h) × w) + H × r + N × i + (R + V) × o
```

In an agent loop, each turn re-reads all earlier new input and visible output from cache, so H accumulates. Reasoning from earlier turns is not resent.

```
A(case) = [(1 - c) × C(routine) + c × C(complex)] × (1 + f) × (1 + t)
```

```
B(case) = [C(triage) + (1 - c) × C(draft) + c × C(complex) + (1 - c) × e × C(complex) + (1 + (1 - c) × e) × C(check)] × (1 + t)
```

Rework and checks. In Architecture A, the check that triggers rework is a rule with no model call, and a failed case is processed again in full (f). In Architecture B, the policy check is a model call on every draft, routine and complex, and again on escalated drafts; complex-path drafts are not escalated further.

c = complex share (25%), f = Architecture A rework rate (4%), e = share of routine drafts in Architecture B that fail the check and are escalated to the complex path (8%), t = technical retries (3%, both). Monthly cost = cost per case x 100,000.

## A4. Architecture A: one general-purpose agent

Prefix of 9,000 tokens per call (3,000 instructions, 25 tool definitions at about 6,000), cache-hit rate 95%.

| Turn | New input (tokens) | Reasoning | Visible output |
| --- | --- | --- | --- |
| Read case, classify, request record | 1,500 | 600 | 100 |
| Full record with activity history returned | 8,100 | 800 | 100 |
| Knowledge search results | 4,100 | 1,000 | 100 |
| Entitlement and SLA lookup | 1,600 | 600 | 100 |
| Complex cases only: 2 investigation turns | 5,150 and 3,150 | 2,500 each | 150 each |
| Draft reply | 100 | 2,000 | 600 |
| Update record and notify | 700 | 300 | 150 |

Routine case: 6 calls, 54,000 prefix tokens, 57,500 cached history, 16,100 new input, 6,450 output (5,300 reasoning) = $0.6260 on GPT-6 Astra. Complex case: 8 calls, 72,000 prefix, 111,400 cached history, 24,400 new input, 11,750 output (10,300 reasoning) = $1.0563. Weighted $0.7336, then x 1.04 x 1.03 = $0.7858 per case, $78,585 a month. Calls per case: 6.5 base, 6.96 with rework and retries.

## A5. Architecture B: orchestrated process

| Step | Executes on | Calls | Prefix (hit rate) | New input | Reasoning + visible | Cost per execution |
| --- | --- | --- | --- | --- | --- | --- |
| Classify and extract to JSON | GPT-6 Luna, every case | 1 | 2,000 (95%) | 1,500 | 150 + 200 | $0.00036 |
| Retrieve 12 record fields | Function | 0 | | | | No inference |
| Choose path | Rule | 0 | | | | No inference |
| Draft routine reply | GPT-6.1 Terra, 75% of cases | 1 | 3,000 (95%) | 3,800 | 500 + 500 | $0.00913 |
| Investigate and draft | GPT-6 Astra, 25% of cases plus escalations | 3 | 5,000 (85%) | 7,100, plus 8,700 cached history | 4,500 + 700 | $0.38058 |
| Check draft against policy | GPT-6 Luna, every draft | 1 | 1,500 (95%) | 1,200 | 100 + 50 | $0.00022 |
| Update record, notify | Functions | 0 | | | | No inference |

Per case: $0.00036 + 0.75 x $0.00913 + 0.25 x $0.38058 + 0.06 x $0.38058 + 1.06 x $0.00022 = $0.1254, then x 1.03 = $0.1292 per case, $12,918 a month. The GPT-6 Astra path accounts for 94% of the spend and 31% of cases. Calls per case: 3.85 with retries.

## A6. Where the saving comes from

From Architecture A ($78,585), through two intermediate designs:

| Change | Monthly cost | Change |
| --- | --- | --- |
| A: one agent on GPT-6 Astra | $78,585 | |
| B's structure, GPT-6 Astra on every AI step, no check or escalation | $20,635 | -$57,950 |
| GPT-6 Luna and GPT-6.1 Terra on triage and routine drafts | $10,542 | -$10,093 |
| Add the GPT-6 Luna check and 8% escalation | $12,918 | +$2,376 |

The split depends on the order in which the changes are applied.

## A7. Sensitivity

| Change from base case | A monthly | B monthly | B saving |
| --- | --- | --- | --- |
| Base case | $78,600 | $12,900 | 84% |
| Complex share 10% | $71,700 | $7,600 | 89% |
| Complex share 50% | $90,100 | $21,700 | 76% |
| Escalation 0% | $78,600 | $10,600 | 87% |
| Escalation 20% | $78,600 | $16,400 | 79% |
| Escalation 40% | $78,600 | $22,300 | 72% |
| A rebuilt on GPT-6.1 Sol | $14,400 | $12,900 | 10% |
| B with GPT-6.1 Sol on the complex path | $78,600 | $3,100 | 96% (78% against A on Sol) |
| A with no caching | $199,800 | $12,900 | 94% |
| A prefix cache-hit rate 50% | $111,000 | $12,900 | 88% |
| Claude: A on Fable 5.1; B on Haiku, Sonnet and Opus 5.5 | $68,400 | $6,200 | 91% |
| Mixed providers: Luna, Terra, Claude Opus 5.5 on the complex path, Haiku check | $78,600 | $5,500 | 93% |
| Policy check on GPT-6.1 Terra instead of Luna | $78,600 | $13,100 | 83% |
| Policy check on GPT-6.1 Sol | $78,600 | $13,400 | 83% |
| Policy check on GPT-6 Astra | $78,600 | $15,300 | 81% |

Why Architecture A scales by about 5.5 times, not 5, between GPT-6.1 Sol and GPT-6 Astra: list input and output rates differ by 5 times, but cached input differs by 10 times ($0.10 against $1.00), and most of A's input is cached prefix and history.

Break-even against A rebuilt on GPT-6.1 Sol: B costs $10,564 + $29,417 x e a month, so it stops being cheaper at an escalation rate of about 12.9%.

## A8. What the model leaves out

- Ortoo fees, Salesforce licences, infrastructure, human review, engineering, evaluation and model migration.
- Hosted tool fees: knowledge search is assumed to be a function over the customer's own search, so no provider tool charge applies.
- Cache-write premiums on new content inside agent loops. Leaving them out understates Architecture A's cost.
- Long-context rates (no prompt exceeds 100,000 tokens), regional processing uplift and Batch or Fast tiers.
- Tokenizer differences: the Claude variants reuse the same token counts, which is a simplification.
- Quality: the model assumes both designs reach the same outcome quality after rework and escalation. That has to be tested.

Token counts are assumptions for illustration, not measurements or customer data. All figures come from a single calculation, last run on 12 November 2026.

## Related insights

AI governance

### The hidden economics of agentic AI

Model prices set the rate. How work is executed decides how often you pay it. A worked example of what agentic AI really costs per case.

Elisa Mustonen 15 min read
https://ortooapps.com/resources/blog/hidden-economics-of-agentic-ai

Salesforce architecture

### AI pricing should be simple to understand and granular to control

Seats suit AI assistants. High-volume operational AI needs pricing per task and granular control. What Agentforce editions show about pricing AI by how it's used.

Elisa Mustonen 6 min read
https://ortooapps.com/resources/blog/ai-pricing-simple-to-understand-granular-to-control

Salesforce architecture

### Agentforce editions: what is actually in Core, Advanced and Max?

What Agentforce Core, Advanced and Max include, how far Flex Credits go, what changes at renewal, and why Workforce Engagement does not settle who gets each case.

Ortoo 11 min read
https://ortooapps.com/resources/blog/agentforce-core-advanced-max-editions

## Structured data

```json
[
  {
    "@context": "https://schema.org",
    "@type": "Article",
    "headline": "The hidden economics of agentic AI: technical appendix",
    "datePublished": "2026-11-17T09:00:00+00:00",
    "dateModified": "2026-11-17T09:00:00+00:00",
    "author": {
      "@type": "Person",
      "name": "Elisa Mustonen"
    },
    "publisher": {
      "@type": "Organization",
      "name": "Ortoo Orchestrator",
      "logo": {
        "@type": "ImageObject",
        "url": "https://ortooapps.com/logo.png"
      }
    },
    "mainEntityOfPage": "https://ortooapps.com/resources/blog/hidden-economics-of-agentic-ai-technical-appendix"
  },
  {
    "@context": "https://schema.org",
    "@type": "Organization",
    "name": "Ortoo",
    "url": "https://ortooapps.com/",
    "logo": "https://ortooapps.com/ortoo-logo-square.png",
    "parentOrganization": {
      "@type": "Organization",
      "name": "Ascendx"
    }
  },
  {
    "@context": "https://schema.org",
    "@type": "WebSite",
    "name": "Ortoo",
    "url": "https://ortooapps.com/"
  }
]
```