What Does an AI Agent Cost? GPT-6, Claude and Copilot Prices

A visual cost breakdown diagram for AI agents showing token consumption, infrastructure layers, and Microsoft Azure platform fees contributing to total cost of ownership.

In Short: What an AI Agent Costs to Run in 2026

An AI agent's bill has four parts. The model tokens most teams estimate during planning are only one of them. The others are retrieval, tools, storage, platform licences and the engineering time it takes to keep the agent good, and they often decide whether the business case holds up. Microsoft frames it well: an agent is a loop around a model, and "a single completed outcome can take a dozen model requests". The number that matters is the cost of each completed task, not the price per token.

This guide breaks down what an AI agent costs to run on Microsoft Foundry, Copilot Studio and Microsoft 365 Copilot at October 2026 prices, with a worked example you can adapt. We first published it in June 2026 and rebuilt it in October around the GPT-6 and Claude 5.5 model families and Copilot Credits.

The Four Cost Dimensions of Production AI Agents

Production AI agent costs fall into four categories:

Token costs - model input and output tokens consumed per agent turn
Infrastructure costs - compute, storage, retrieval, and orchestration
Microsoft platform costs - Foundry, Fabric, and Microsoft 365 components
Operational costs - monitoring, maintenance, prompt engineering, and iteration

Most cost estimates focus only on the first. All four need to be included in a credible TCO model.

Token Costs: The Largest Variable

Token costs are driven by three factors: model tier, context window size, and the number of agent turns per task. Choosing the tier deliberately is its own discipline, covered in our model selection guide for Foundry.

Model Tier

Model prices have moved a long way since this guide first appeared, and the gap between tiers is wider than ever. These are Microsoft's published Foundry prices in October 2026, in USD per million tokens (input / output, Global Standard, short context):

GPT-6 Astra: $10.00 / $50.00. Microsoft recommends starting here for the most demanding reasoning
GPT-6.1 Sol: $2.00 / $10.00. Microsoft calls it "the new default for production agents and complex workflows" (GPT-6 Sol has the same headline price)
GPT-6 Luna: $0.10 / $0.50, for extraction, summarisation, request routing and routine interactions
Claude Opus 5.5: $4.00 / $20.00, Global Standard and US Data Zone, hosted on Azure
Claude Sonnet 5.5: $2.00 / $10.00
Grok 4.7: $2.00 / $6.00 (under 200K tokens of context)

GPT-6 Astra's input price is 100 times GPT-6 Luna's. Data Zone deployments cost more: for GPT-6, Microsoft prices the US Data Zone at a 10% premium to Global and the EU Data Zone at 20%. Our guides to GPT-6 in Microsoft Foundry and Claude in Microsoft Copilot and Foundry explain what each model is for.

Two cautions. On 8 October the Azure OpenAI pricing page still said GPT-6 Sol and Luna prices were being processed for publication, so these figures come from Microsoft's launch posts. And Microsoft has not published a per-token rate for the new Claude Haiku 5.5. It says only that Haiku 5.5 "costs around 75% less than Claude Haiku 4.5 for most tasks". Foundry bills Claude at Anthropic's published rates, so check those before you model it.

Context Window Size

Each agent turn passes the full conversation history (or a summarised version of it) plus all tool results plus the system prompt to the model. Context accumulates quickly in multi-turn conversations. An agent handling a task that requires ten tool calls and responses could be passing 20,000–50,000 tokens of context per turn by the end of the workflow.

Prompt caching is what keeps long contexts affordable, and the discounts are now large. On Microsoft's published Global Standard prices, cached input costs $1.00 per million tokens on GPT-6 Astra against $10.00 uncached, and $0.10 against $2.00 on GPT-6.1 Sol. A cache hit on Claude Opus 5.5 costs $0.20 against $4.00. Writing to the cache can cost more than a normal input token ($12.50 per million on Astra, $5 on Opus 5.5), so caching pays on prefixes that are reused across turns, not on one-off prompts. Microsoft adds that cache reads can be discounted by up to 100% on provisioned deployments.

Turns Per Task

An agent that requires three tool calls to complete a task consumes roughly three times the tokens of an agent that requires one. Planning agent architectures to minimise unnecessary tool calls - through better tool design, better system prompt structure, and appropriate task decomposition - directly reduces token costs. Microsoft puts it the same way: an agent "plans, calls a tool, reads the result, and reasons again", and you pay for every turn it did not need.

Infrastructure Costs

Vector Store and Retrieval

Agents that use retrieval-augmented generation (RAG) - querying a knowledge base or document store to retrieve relevant context - incur Azure AI Search costs in addition to model costs:

Azure AI Search (Foundry IQ): dedicated tiers, from Basic to S3 plus the storage-optimised L1 and L2, are billed per search unit per hour, and a serverless option is in preview. Price it for your region on the Azure AI Search pricing page. We have removed the hourly figure this guide originally quoted rather than leave a stale one
Embedding model calls: Converting documents and queries to vector embeddings uses an additional model (typically text-embedding-3-small or text-embedding-3-large) at a separate token cost

For agents with large knowledge bases queried frequently, retrieval infrastructure costs can match or exceed model token costs.

Thread Storage and Memory

Foundry Agent Service lists its built-in tool charges separately from model tokens. On the pricing page in October 2026, file search storage costs $0.11 per GB of vector storage per day (the first 1 GB is free), and web search and custom search cost $14 per 1,000 transactions. Knowledge stores and conversation histories still grow over time, so set retention and pruning rules before volumes build up, for example deleting or summarising threads older than an agreed age.

Code Interpreter and File Processing

Code Interpreter is billed at $0.033 per session. That is small per task, but it adds up on an agent that opens a session for every request. Use it only where it does something a custom function tool cannot.

Compute (for Custom Orchestration)

Agents using Azure Container Apps, Azure Functions, or AKS for custom orchestration logic incur compute costs independent of the model costs. These are typically modest for low-to-medium volume agents but can become significant at high request volumes. Hosted agents in Foundry Agent Service have their own vCPU and memory charges, so check the current rates on the pricing page for your region.

Microsoft Platform-Specific Costs

Microsoft Foundry

The Foundry Agent Service pricing page lists no per-agent fee. You pay for model tokens, the built-in tools above, compute for hosted agents, and the separately priced connections an agent uses, such as Logic Apps connectors, Fabric data agents, Grounding with Bing Search and Foundry IQ (Azure AI Search). Claude models are billed differently. Foundry now invoices all Claude usage in Claude Consumption Units through Azure Marketplace, converting tokens at Anthropic's per-model rates, and that spend counts towards a Microsoft Azure Consumption Commitment.

Microsoft Fabric

Agents that query Fabric data consume Fabric capacity (F-SKU compute units). A Fabric Data Agent or a Foundry agent using Fabric function tools will consume CUs from your provisioned F-SKU capacity. For organisations already running Fabric for analytics workloads, agent query consumption can be absorbed by existing capacity if headroom exists, or may require capacity scaling if agents run at high volume.

Microsoft Copilot and Copilot Credits

This line changed more than any other in 2026. Microsoft 365 Copilot is still $30 per user per month paid yearly, or $31.50 paid monthly on an annual commitment. But Microsoft now pairs that licence with usage-based billing in Copilot Credits for agentic and long-running work. Cowork, Copilot Managed Runtime, the Work IQ API, advanced work in SharePoint and OneDrive, and Teams Phone Agent are all managed under usage-based billing. Our explainer on Microsoft Copilot pricing and Copilot Credits covers the split, and Copilot Business usage-based billing covers the change for smaller tenants.

Copilot Studio agents use the same currency. The pay-as-you-go meter is $0.01 per Copilot Credit, and a capacity pack costs $200 a month for 25,000 credits. On Microsoft's standard-harness billing rates, a generative answer costs 2 credits, an agent action 5 and tenant graph grounding 10. An agent that uses a reasoning model adds 10 credits per 1,000 tokens. Employee-facing use by a Microsoft 365 Copilot licensed user, under that user's own identity, is not charged for those features, but use by website customers and unlicensed staff is. Microsoft's own example is a support agent that gives 900 customers a day four classic answers and two generative answers each. That comes to 7,200 credits a day: $72 a day, or roughly $2,160 a month at pay-as-you-go rates.

Agents that your own application calls through Foundry, rather than through Copilot, need no Copilot licence. You pay for the model and tools directly.

Cost Optimisation Strategies

Model Tiering

Route simple steps such as intent classification, extraction, formatting and summarisation to GPT-6 Luna or Claude Haiku 5.5. Use GPT-6.1 Sol or Claude Sonnet 5.5 as the production default, and keep GPT-6 Astra or Claude Opus 5.5 for the steps where deeper reasoning changes the outcome. Foundry's model router can make that choice per request behind a single endpoint, but check which models it supports before you rely on it for the newest families. This is still the biggest cost lever you have: in the worked example below, routing takes the same workload from about $19,800 a month to about $825.

Prompt Caching

Put the stable part of every prompt first (system instructions, tool definitions, examples) and the content that changes last (user input, retrieved chunks, turn history, timestamps). Cached input is billed at 10% of the normal input rate on GPT-6 Astra and 5% on GPT-6.1 Sol and Claude Opus 5.5, so a prefix that keeps matching is the cheapest optimisation you will ever ship. Put anything that changes per request at the top and the cache never matches.

Retrieval Precision

Improve retrieval precision in your vector store to reduce the number of chunks returned per query. Returning ten chunks when three are needed inflates context size and token costs. Tune chunk size, overlap, and top-k values to balance recall against context size.

Turn Minimisation

Audit your agent's tool call patterns. Agents that call the same tool multiple times in a single task, or that call tools unnecessarily due to vague system prompt instructions, are burning tokens that better tool design would eliminate.

Batching and Caching at the Application Layer

For agents handling repetitive queries (the same question asked frequently by different users), application-layer response caching can dramatically reduce model calls. Cache responses for parameterised queries where the answer is deterministic given the same inputs.

Measure Cost per Outcome

Track the cost of each completed task alongside quality, not just tokens per request. A change that cuts the price of each call but adds turns has made things worse, and only cost per outcome shows it. Foundry's evaluation, tracing and agent optimizer tools are built for this loop. Our guide to evaluating AI agents in Foundry and Copilot Studio explains how to build the evaluation set first.

Building a TCO Model

A realistic AI agent TCO model for 2026 should include:

Model costs: estimated tokens per task × tasks per month × model tier pricing, with caching adjustments
Retrieval costs: search units + embedding calls per month
Storage costs: thread storage + knowledge base storage
Compute costs: orchestration infrastructure at expected request volume
Fabric capacity headroom: additional CU consumption from agent queries
Copilot licences and Copilot Credits: if agents surface through Microsoft 365 Copilot or run in Copilot Studio
Operational costs: engineering time for prompt maintenance, evaluation and iteration, budgeted as a named line rather than absorbed

A Worked Example

Take an agent that completes 1,000 tasks a day, with six model turns per task. Each turn sends a 20,000-token cached prefix (instructions, tools, examples) plus 4,000 fresh input tokens and returns 1,000 output tokens. Our arithmetic below uses Microsoft's Global Standard short-context prices and a 30-day month. It excludes cache-write charges, tools and retrieval:

All GPT-6 Astra: about $0.11 per turn, $660 a day, roughly $19,800 a month
All GPT-6.1 Sol: about $0.022 per turn, $132 a day, roughly $3,960 a month
All GPT-6.1 Sol without caching: about $0.058 per turn, roughly $10,440 a month
All GPT-6 Luna: about $0.0011 per turn, roughly $200 a month
One Sol planning turn plus five Luna turns: about $0.028 per task, roughly $825 a month

That is a hundredfold spread for the same workload. Your evaluation set has to answer whether Luna is good enough for those five turns, and that question is worth answering before any other.

Copilot is a separate line. At $30 per user per month, Microsoft 365 Copilot for 1,000 users costs $30,000 a month before any Copilot Credits. That is why licence coverage by role deserves as much attention as model choice. Build a bottom-up model for your own use case before you commit to production infrastructure, and re-run it whenever prices or models change.

Our AI Solutions team runs agent cost modelling workshops with organisations evaluating production agent deployments on Microsoft Foundry. We help you build a realistic TCO before you commit, not after.

Costing an Agent for Your Own Business

Published ranges only take you so far. Real numbers come from a defined use case, a known data foundation and a measurable outcome.

That is the work we do - see our AI readiness assessment, and for the background, why so many agent projects never reach production.

If you would like a straight assessment of where your estate stands, book a free 30-minute consultation.

Sources and Further Reading

Frequently asked

It depends on four things: tokens (model input and output across every turn), infrastructure (retrieval, storage, tools and compute), Microsoft platform costs (Foundry tool charges, Fabric capacity, Copilot licences and Copilot Credits) and the engineering time to keep the agent good. In our worked example at Microsoft's October 2026 prices, an agent completing 1,000 tasks a day with six model turns each costs roughly $200 a month in tokens on GPT-6 Luna, $3,960 on GPT-6.1 Sol and $19,800 on GPT-6 Astra, before tools, retrieval and people.

Model tiering means sending each step of an agent workflow to the cheapest model that does it well. Simple tasks like intent classification, routing and extraction go to cheaper models such as GPT-6 Luna ($0.10 input and $0.50 output per million tokens in Foundry) or Claude Haiku 5.5. Harder reasoning goes to GPT-6.1 Sol ($2/$10), Claude Opus 5.5 ($4/$20) or GPT-6 Astra ($10/$50). Astra's input price is 100 times Luna's, so routing decides most of the token bill.

Prompt caching bills a reused prompt prefix at a fraction of the normal input rate. On Microsoft's published Global prices, cached input is $1.00 per million tokens on GPT-6 Astra against $10.00 uncached, $0.10 against $2.00 on GPT-6.1 Sol, and $0.20 against $4.00 for a cache hit on Claude Opus 5.5. Writing to the cache can cost more than a normal input token, so put stable content (system prompt, tool definitions, examples) first and anything that changes per request last, so the cache keeps matching.

Foundry agents that query Microsoft Fabric data through function tools consume Fabric capacity (F-SKU compute units) for each query. For organisations already running Fabric for analytics, agent consumption can often be absorbed by existing capacity if headroom exists. High-volume agent deployments that query Fabric frequently may require capacity scaling. The Fabric capacity consumption should be modelled separately from Azure OpenAI token costs when building an agent TCO.

The most common reason is underestimating how many model calls one task takes. Each agent turn passes the conversation history plus tool results to the model, so context grows quickly, and Microsoft notes that a single completed outcome can take a dozen model requests. Add retrieval, tool charges, storage, compute and the engineering time to maintain the agent, and the total is well above the token estimate most teams start with.

Microsoft 365 Copilot is $30 per user per month paid yearly. Agentic work such as Cowork is billed separately in Copilot Credits. Copilot Studio agents consume Copilot Credits at $0.01 each on pay-as-you-go, or from $200-a-month packs of 25,000: 2 credits per generative answer, 5 per agent action and 10 for tenant graph grounding. Employee-facing use by Microsoft 365 Copilot licensed users under their own identity is not charged for those features; use by unlicensed and external users is. Agents your own application calls through Foundry need no Copilot licence.

Build a bottoms-up model covering: estimated tokens per task (input context size + expected output length) × tasks per month × model tier pricing with caching adjustments; retrieval costs (search units + embedding calls); storage costs (thread + knowledge base); compute costs at expected request volume; Fabric capacity headroom; and Microsoft 365 Copilot licences and Copilot Credits if required. Run the model against three scenarios - conservative (low volume, cheap model), base case, and aggressive (high volume, premium model) - to understand the cost range before committing to infrastructure.

What Does an AI Agent Cost to Run? 2026 Prices for GPT-6, Claude and Copilot Credits