Skip to main content
    SupportContact

    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. 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

    The hidden economics of agentic AI. Why the cost of enterprise AI depends on how work is executed. A panel shows an average case taking seven model calls, with context growing on every turn.
    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 Mustonen15 min read
    A glowing data line rising across a dark violet to teal background, with points marked along it.
    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 Mustonen6 min read
    Three glass platforms in a row, linked by a glowing line, representing the Agentforce Core, Advanced and Max editions.
    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.

    Ortoo11 min read