Production recovery

Stuck with AI another vendor could not ship?

About a third of our AI engagements start exactly there.

Recover the build →
Case studies Book a 30-minute discovery call

AI agent development cost: build effort, usage and operating work

AI agent development cost combines a defined build with the recurring workload it creates. Estimate source handling, integrations, evaluation and operating handover, then calculate model calls, tools, infrastructure and upkeep. A bounded support example makes those assumptions inspectable. Compare named price snapshots and equivalent task outcomes before choosing a model, contract or purchased product.

Kanika Mathur
By Kanika Mathur, Service Delivery Lead
Reviewed by Arjun SareenPublished Sep 15, 2026Updated Nov 16, 202613 min read
Cost
A laptop showing a blurred dark dashboard with a rising area chart on a dark desk beside a printed page with blurred text, a calculator, a black mug and a warm desk lamp, no people
Key takeaways

The short version

  • Define the capability. Read-only answers, feasibility work and authorized actions have different acceptance boundaries.
  • Show the workstreams. Source handling, interfaces, evaluation and operating handover belong in the build.
  • Price the actual path. Calls, tokens, tools, retries and human review determine recurring cost.
  • Inspect the operating plan. The support budget itemizes resource quantities and 20 upkeep hours; change both for your usage and coverage.
  • Compare equivalent outcomes. A cheaper token rate does not establish a cheaper successful task.

Estimate the build and the operating workload

AI agent development cost has two distinct estimates: the work to build and release a defined capability, and the cost of operating its actual task paths. Start with data access, integrations, review and failure handling, then model calls, tools, infrastructure and upkeep. A label such as “agent” or “enterprise” cannot determine a quote.

Consider a hypothetical support assistant for one adult-facing SaaS product. It answers in English from one maintained help center, cites relevant material and transfers unresolved questions to one existing helpdesk. The base release cannot change an account, issue a refund or access regulated records. Content is supplied; the estimate includes source handling, the interface, evaluation and operating handover.

Assume 600 hours at $100/hour for that boundary: an illustrative $60,000 labor build. The operating example assumes 20,000 conversations monthly and four model calls each; its selected cost lines total $3,459.40 before additional usage and other exclusions. These are chosen inputs to inspect and replace, not published market averages or a customer result.

$60,000
Illustrative build: 600 chosen hours at $100/hour for the bounded support assistant.
Assumed scope and labor inputs
80,000
Model calls/month at 20,000 conversations and four calls each; retries are not included.
Assumed workload
$3,459.40 +
Monthly subtotal for selected example costs; additional usage, tools and other costs remain.
Worked arithmetic, not a quote

The AI pricing guide discusses commercial choices. For this estimate, keep scope and operating assumptions together so a cheaper build does not hide unpriced integration or review work. The AI TCO calculator separates lifecycle cost categories; its defaults are illustrative rather than evidence of what your agent will cost.2

Compare agent scope patterns

Compare scope patterns by what the system may read, decide and change. A fixed drafting workflow, a read-only assistant, a feasibility study and an action-enabled product have different acceptance boundaries. Estimate their tasks independently. A research phase can end without a production product, so its price is not a rung on a universal complexity ladder.

Scope patterns, not standard market price tiers
PatternBoundaryIllustrative laborWhat the number meansAdditional work to investigate
Fixed workflowClassify one incoming queue and draft a response for staff160 hours x $100= $16,000Chosen example, not an autonomous support productQueue access, categories, review and exceptions
Read-only support assistantAnswer from one maintained help center and hand off600 hours x $100= $60,000The concrete base scope used in this articleSource updates, grounded answers and handoff
Feasibility studyTest an uncertain tool or evidence path without a production release240 hours x $100= $24,000Separate research boundary, not the next size of appTest data, success criteria and a stop decision
Action-enabled extensionBase plus order lookup and reviewer-authorized refunds1,100 hours x $100= $110,000Assumes 200 hours for lookup and 300 for the refund extensionAuthorization, limits, duplicate prevention and reconciliation
Shared platformMultiple products, teams or tenantsEstimate each shared and consumer-specific taskNo general platform price is assignedTenant access, reusable tools, operations and migration

The 160-hour workflow assumption describes one queue with staff approval and no autonomous support interaction. The 240-hour study instead buys evidence about an unresolved path: representative data, a test implementation, evaluation and a continue-or-stop decision. Neither number establishes the cost of the 600-hour support product. They demonstrate why the deliverable matters more than the tier name.

For an action-enabled extension of the support example, assume 200 additional hours for a read-only order lookup and 300 more for reviewer-authorized refunds. Those chosen allowances bring total effort to 1,100 hours. Before using them in a budget, inspect the actual order and payment APIs, approval policy, limits, duplicate handling and reconciliation requirements.

For a shared platform, estimate tenancy, reusable capabilities and consumer-specific work separately. A reusable tool still needs authorization and acceptance for each consuming workflow. The agent build guide develops these technical boundaries. Do not infer an action's readiness from a successful question-answering demonstration.

Make the build work visible

Build effort includes discovery, source handling, orchestration, integration, evaluation and release preparation. Make those tasks visible instead of presenting model access as the whole product. The example allocates 600 chosen hours across six workstreams so a buyer can challenge the assumptions and see what would change the estimate.

Build workstreams for the 600-hour example
LineWhat the work isWhat drives the cost
Scope and acceptance design40 hours: define supported questions, handoff and failure casesProduct decisions and representative evidence
Source access and refresh80 hours: access the supplied collection and handle changesContent quality, access and withdrawal behavior
Retrieval and response100 hours: connect evidence to cited answersRelevance, applicability and unsupported questions
Interface and handoff120 hours: chat flow and one helpdesk integrationIdentity, sessions, transfer and failed handoff
Evaluation and security testing140 hours: review failures and exercise boundariesTask variety, access controls and consequences of error
Deployment and handover120 hours: release, telemetry, support and recoveryEnvironment, operating evidence and ownership

The source-work allowance exists because the assistant needs maintained evidence, including changed and withdrawn content. The integration allowance covers a user interaction and a helpdesk transfer, not just an API call. Evaluation must include unsupported questions, conflicting material, permission failures and a handoff that cannot complete. Deployment work includes the configuration and operating evidence needed to support the release.

LangGraph provides orchestration for long-running, stateful agents.10 The OpenAI Agents SDK provides agent primitives and development capabilities.11 Evaluate those capabilities against the chosen design. A library's availability or license does not establish a zero-cost deployment, and adopting it does not implement the organization's permissions or acceptance tests.

When requesting an estimate, ask for tasks, dependencies and exclusions for each workstream. Content cleanup, identity access or a helpdesk limitation may change the boundary. If the uncertainty is material, scope an investigation with a specific question and evidence to produce, then update the release estimate from what was learned.

Define handover as work: configuration access, test cases, trace interpretation, source refresh, incident response and the ability to disable a faulty action. Specify who can operate those functions after launch. The required evidence should match the consequence of failure rather than an arbitrary “production-grade” price label.

Calculate monthly operation from the call path

Monthly AI agent cost is the sum of model usage, tools, infrastructure, observability, engineering and any human operating work. Calculate usage by actual task path, including retries and unsuccessful tasks. Separate the cost unit from the billing unit: a conversation may contain several model calls, a trace is not necessarily a conversation, and a vendor-defined outcome has its own conditions.

  • Model usage: sum input, output, cache-read and cache-write tokens at the applicable named-model rates. Divide per-million rates by 1,000,000 before multiplying by token counts.
  • Tools: count searches, execution, storage or other metered operations under the selected service terms.
  • Infrastructure and observability: include hosting, retrieval storage, logs, traces, retention and seats without assuming the seat price covers all usage.
  • Upkeep and review: estimate engineering, content maintenance, support and human checking from the actual responsibilities.

Anthropic distinguishes input, output, cache-write and cache-read billing.3 That distinction matters when estimating a repeated prompt or a long-running workflow. Use the relevant model and cache conditions, and include writes and misses; a headline cache discount does not apply to every token.

A worked support-assistant budget

Assume 20,000 conversations a month, four calls each, 6,000 uncached input tokens and 400 output tokens per call. As of November 11, 2026, OpenAI standard API pricing lists gpt-6.1-sol at $2 per million input and $10 per million output tokens.4 Under those assumptions a call costs $0.016: 6,000 x $2 / 1,000,000 plus 400 x $10 / 1,000,000. The 80,000 calls therefore cost $1,280.

Selected monthly costs at 20,000 conversations; exclusions remain
LineBasisPer month
Model tokens80,000 calls x $0.016 under the stated rate and token assumptions$1,280
Observability seatsTwo LangSmith Plus seats at $39; additional usage excluded$78
Hosting and retrieval storageTwo runtime instances, index, logs, backups and transfer at chosen component rates$101.40
Ongoing engineering20 allocated upkeep hours/month at the hypothetical $100/hour$2,000
Subtotal of these linesBefore additional traces, tools, other usage, tax and human support costs$3,459.40

Choose two runtime instances, each 2 vCPU/4 GB, running 730 hours each: 1,460 instance-hours total. At an assumed $0.04 per instance-hour, that is $58.40. Add a 50 GB retrieval index at $0.50/GB-month ($25), 20 GB logs at $0.25/GB-month ($5), 50 GB backups at $0.10/GB-month ($5) and 100 GB outbound transfer at $0.08/GB ($8). These hypothetical component rates total $101.40, not a vendor offer or a capacity guarantee. Load-test the configuration.

The 20-hour monthly upkeep plan includes 24 sampled answer checks at five minutes each (2 hours), two source-change reviews at one hour (2), regression tests (4), four defect investigations at 90 minutes (6), release/recovery checks (2), usage/alert review (2) and helpdesk-handoff follow-up (2). Assume scheduled weekday reviews during agreed office hours, without on-call coverage. This sampling is separate from staff handling of escalated conversations, which remains excluded.

LangSmith's Plus plan, checked November 11, 2026, lists $39 per seat/month and 10,000 base traces/month included, with additional usage billed separately.9 Two seats therefore contribute $78 in this example, but the subtotal is not an all-in trace quote. Determine what creates a trace, the actual volume, retention and any evaluation charges before annualizing.

Token cost changes with the model and measured call path
Illustrative 20,000 conversations/month, 6,000 input and 400 output tokens/call. Four calls/conversation except the eight-call scenario. Quality is not held equal.
Illustrative token cost by named model and call count At the November 11, 2026 standard API price snapshot, assumed monthly token bills are 64, 640, 1,280, 2,560 and 6,400 US dollars. The fourth scenario doubles calls. Model quality must be evaluated separately. $0$2,000$4,000$6,000 $64$640$1,280$2,560$6,400 gpt-6-luna gpt-6.1-terra gpt-6.1-sol sol,8 calls gpt-6-astra
Assumed workload at named standard API rates
SetupRate per million tokens (in / out)Per month
gpt-6-luna, four calls/conversation$0.10 / $0.50$64
gpt-6.1-terra, four calls/conversation$1 / $5$640
gpt-6.1-sol, four calls/conversation$2 / $10$1,280
gpt-6.1-sol, eight calls/conversation$2 / $10$2,560
gpt-6-astra, four calls/conversation$10 / $50$6,400
Rates: OpenAI standard API pricing as of November 11, 2026, USD per million input/output tokens. Assumed uncached workload; tools, regional or service uplifts and other charges excluded. Different models are not assumed to achieve equal task outcomes.

The chart changes named models or call count while holding chosen token sizes fixed. It does not establish equivalent task quality, latency or tool behavior. A model that needs more attempts can change the effective cost of a successful task. Compare the observed paths and outcomes before treating the cheapest token bar as the cheapest product.

At the same selected monthly subtotal, 12 months would contribute $41,512.80 and the assumed $60,000 build would yield $101,512.80 for those lines in year one. Additional usage, tools, human support and other omitted costs still need inclusion. Recalculate the work, resource quantities and rates for your own workload and service commitments.

Budget the actual support, research or document task

Use case changes both the implementation boundary and the operating unit. Estimate support by conversation paths and handoffs, research by completed tasks and source/tool work, and document processing by the actual input and review flow. The right cost lever must preserve the outcome and constraints that matter for that use case.

Use-case questions for the build and operating estimate
Use caseScope to estimateOperating driverCandidate leverRequired check
Customer supportAnswering, account access and actions as separate boundariesConversation paths, model calls and handoffImprove retrieval or route reviewed task classesResolution quality and staff work remaining
Internal knowledgeSource access, permissions and refreshContext size, updates and authorization checksRetrieve relevant passages and remove duplicationApplicable evidence and revoked access
Research or prospectingSource/tool access and the required deliverableSearches, loops, documents and reviewStop rules and bounded searchEvidence quality and completion of the actual task
Document processingLayouts, fields, review and exception handlingPages, token sizes and correctionsEligible asynchronous batch workUnusual layouts and supported field values
Operations actionsAuthorized write behavior and recoveryExecution, approval, retries and reconciliationKeep deterministic steps outside model selectionPermissions, duplicate prevention and safe failure

Custom support versus a purchased product

For the support example, separate answers from account access and account changes. Ask whether the product must cite the maintained help center, transfer context, respect user identity or execute an authorized action. Those requirements determine whether a purchased component covers the need and which custom tasks remain. The customer service agent guide develops the operational decision.

Intercom documents outcome billing and usage conditions for its AI products.8 Identify the exact product, billable event, commitment and treatment of follow-up or reopened work before multiplying a price by volume. Do not equate an outcome with the conversation assumption used here or infer a universal build-versus-buy break-even from traffic alone.

Compare equivalent coverage over a stated period: implementation, subscription or usage, integration, human work, quality, support and exit. A lower token estimate does not account for vendor-provided operating capabilities, while a per-outcome quote may exclude custom integration or services you need.

Research and multi-step work

For research, define the deliverable and stopping condition before measuring calls or searches. Include failed paths, inaccessible sources and the person's checking effort. Multi-agent parallelism is a design to test, not a universal token multiplier. Anthropic recommends simpler workflows where they are sufficient and distinguishes them from agents that choose their own steps.7 Compare an alternative against the same task and evidence requirements.

Read the work contract and platform bill together

A build contract prices work and uncertainty; a platform contract prices access or usage. Read them together. A fixed amount needs a defined deliverable and change process, while time-based or phased work needs spending authority and evidence at review points. The name of the contract does not decide who absorbs an undefined change.

Commercial structures to assess against the work and uncertainty
ModelFitsTradeoff
Fixed priceDefined deliverables and acceptance with stated assumptionsRead exclusions, change control and responsibility for overruns
Time and materialsUncertain implementation or explorationAgree reporting, spending authority and review points
Phased or milestoneSeparate discovery, feasibility and release decisionsSpecify evidence needed to continue and what each payment accepts
Retainer or managed serviceDefined maintenance and operating responsibilitiesClarify included capacity, response, exclusions and exit
Outcome-basedAn event that can be measured and attributedDefine billable event, reopens, disputes and quality
HybridA base service plus measured usageSpecify units, minimums, caps, markup and reconciliation

For every proposal, establish acceptance, dependencies supplied by the buyer, excluded work, third-party charges and treatment of changed requirements. If discovery is separate, specify what it produces and how the next decision will be made. If operating support is included, distinguish monitoring from correction, incident response and feature work.

For platform spending, write a unit map: token type and model; tool operation; seat; stored data; trace; runtime; or defined outcome. Mark minimum commitments, overage, region and service-level uplifts where relevant. The OpenAI pricing snapshot has distinct standard, cached, Batch and other service rows; the standard figures used here do not cover every billing path.4

Request enough usage detail to reconcile an invoice with the application. If a supplier passes through inference, agree the underlying unit, any markup, access to usage evidence and spending limits. If it bundles usage, ask what is included and how additional work is charged. These are commercial questions to resolve in the actual agreement, not promises of a standard company package.

Reduce cost against the same acceptance criteria

Reduce cost by changing a measured source of work while preserving acceptance. Test simpler control flow, smaller task-appropriate models, shorter relevant context, caching and eligible batch processing. Compare the cost of a successful supported task, including human correction, rather than optimizing a token rate in isolation.

  • Simpler control flow: compare a predefined workflow with an agent choosing steps. Anthropic's architecture guidance recommends starting with the simplest approach that is sufficient.7 Measure loops and failures instead of assuming autonomy creates value.
  • Model selection: evaluate each task class with the proposed named model. Include escalation, retries and output checking in the comparison. A low rate can be offset by a longer path or inadequate results.
  • Context: retrieve the passages needed for the question and preserve the evidence to inspect. Remove duplication and irrelevant history only after checking that the task still has the necessary context.
  • Caching: measure reusable input, hits, misses, writes and retention. Apply the selected provider's model-specific billing rather than a universal cache multiplier.3
  • Batch processing: OpenAI's Batch API offers 50% lower costs for eligible asynchronous work with a stated 24-hour turnaround.5 Assess input/output eligibility and other charges. This does not establish interactive latency or a 50% reduction in the total application bill.
  • Limits: bound calls, searches and spend, and decide how the user is informed when the task stops. A cap that silently discards work can reduce the invoice while failing the service.

Run the same acceptance set before and after the change, inspect important regressions and monitor the actual path after release. Update the budget when models, source volume, traffic or operating responsibilities change. Keep the assumptions versioned with the measurement period so a price snapshot is not mistaken for a permanent rate.

The AI cost optimization guide develops the wider operating levers. For an AI agent development discussion, bring the task boundary, sample inputs, integrations, projected volume and review requirements through the contact page. Those inputs support a build-and-run estimate with explicit exclusions.

Frequently asked

Agent build and operating budget questions

How much does AI agent development cost?
Estimate the defined capability, source access, integrations, evaluation and operating handover rather than applying a universal tier price. The support example assumes 600 hours at $100/hour for a bounded read-only assistant, yielding $60,000 in labor. Those are chosen illustrative inputs, not a quote or benchmark. Add recurring model usage, tools, infrastructure, engineering and human operating work for the intended workload.
What is the difference between build cost and AI agent cost per month?
Build cost covers the work needed to prepare and release the agreed capability. Monthly cost covers its actual operation, including model calls, tools, infrastructure, tracing, maintenance and any human checking or support. Define the task paths and billing units before estimating. A conversation can contain multiple calls, while a trace or vendor-defined outcome may follow a different counting rule.
Are the model prices in the worked example permanent?
No. The example uses OpenAI standard API rates as of November 11, 2026 for named models and USD per-million-token rates. Different service rows, caching, tools, regions or other uplifts can change the bill. Recheck the applicable terms when estimating and purchasing. The chart also assumes fixed token sizes; it does not establish equal quality or retry behavior across models.
Does a multi-agent system always cost a fixed multiple more?
No universal multiplier follows from adding agents. Measure the actual task paths, including parallel work, tool calls, context, unsuccessful branches and human checking. Compare them against the same deliverable and acceptance cases. A simpler workflow may be sufficient, while a more complex design needs evidence that its added work serves the task rather than merely producing more activity.
Can caching and batch processing halve the total bill?
Do not apply a discount to the whole application. Cache billing depends on the model, reusable input, reads, writes, misses and retention conditions. OpenAI’s Batch API offers a 50% cost reduction for eligible asynchronous work with a stated 24-hour turnaround, but that does not halve infrastructure, engineering, human support or every ancillary charge. Recalculate the affected lines and test the resulting workflow.
When should we buy an existing AI support product?
Compare its demonstrated coverage with the required answer, identity, handoff and action behavior. Review implementation, usage, integration, quality, support and exit over the same period. Establish exactly what the vendor bills as an outcome or credit and any commitments or exclusions. Traffic alone does not decide the break-even, because purchased capabilities and custom operating responsibilities differ.
What should an AI agent development proposal include?
Ask for the capability boundary, workstreams, dependencies, acceptance evidence and operating handover. Require explicit third-party charges and usage assumptions, plus the treatment of changed scope. If exploration is needed, define the question and continue-or-stop evidence. For operation, clarify included maintenance, spending authority, incident response and access to usage detail so the buyer can reconcile cost with the application.
Kanika Mathur

Kanika Mathur

Author · Service Delivery Lead, Resourcifi

Kanika Mathur is Service Delivery Lead at Resourcifi. She leads the engineering pods that scope, build and run client software, from mobile apps to AI systems, and she reviews the process and figures in our engineering guides for accuracy.

Resourcifi on LinkedIn →
Arjun Sareen

Arjun Sareen

Reviewer · Head of Business Development, Resourcifi

Arjun Sareen is Head of Business Development at Resourcifi. He scopes builds with founders and product leaders, matches each project with the right team model, and hears the same buying questions every week, which is what he writes about.

Resourcifi on LinkedIn →

Like this? Get more from Resourcifi in Google Search.

Sources

  1. resourcifi.com, How Much Does AI Cost? AI TCO Calculator | Resourcifi. Resourcifi's AI TCO calculator separates inference, infrastructure, engineering and other lifecycle costs.
  2. docs.claude.com, Pricing - Claude Platform Docs. Anthropic distinguishes input, output, cache-write and cache-read token billing and batch processing.
  3. developers.openai.com, Pricing | OpenAI API. OpenAI's fetched standard API table lists per-million-token USD input/output rates of $10/$50 for gpt-6-astra, $2/$10 for gpt-6.1-sol, $1/$5 for gpt-6.1-terra and $0.10/$0.50 for gpt-6-luna.
  4. platform.openai.com, Batch API | OpenAI API. OpenAI's Batch API offers 50% lower costs for asynchronous eligible work with a stated 24-hour turnaround.
  5. anthropic.com, Building effective AI agents \ Anthropic. Anthropic distinguishes predefined workflows from agents that choose their own steps and recommends simpler approaches where sufficient.
  6. intercom.com, Intercom Pricing | Plans for every team size. Intercom documents its own AI outcome billing and usage conditions.
  7. langchain.com, LangSmith Plans and Pricing. LangSmith Plus lists $39 per seat per month, 10,000 base traces per month included, then pay-as-you-go usage.
  8. github.com, GitHub - langchain-ai/langgraph: Build resilient agents. · GitHub. LangGraph provides orchestration for long-running, stateful agents.
  9. openai.github.io, OpenAI Agents SDK. OpenAI's Agents SDK offers a small set of agent primitives and built-in development capabilities.
Keep reading
Related guides worth your time
All AI insights →
Agentic RAG: step selection, retrieval patterns and evaluation Agents & RAG Agentic RAG: step selection, retrieval patterns and evaluation Understand agentic RAG through routing, corrective retrieval and evaluation, with practical tests for step selection, sou... Read guide → AI agents for customer service: define actions and verify resolution Agents & RAG AI agents for customer service: define actions and verify resolution Build AI agents for customer service with explicit identity, knowledge, action and handoff checks. Measure verified resol... Read guide → AI agents for HR: support workflows and hiring review Agents & RAG AI agents for HR: support workflows and hiring review Plan AI agents for HR around support workflows, data permissions, hiring assessment and meaningful review before changing... Read guide → AI agents for sales: control tools, outreach and record changes Agents & RAG AI agents for sales: control tools, outreach and record changes Build AI agents for sales with scoped CRM access, supported drafts and checked actions. Evaluate outreach, record changes... Read guide → AI agents in finance: use cases, controls and implementation Agents & RAG AI agents in finance: use cases, controls and implementation Plan AI agents in finance around bounded workflows, scoped access, compliance responsibilities and measured operating evi... Read guide → AI agents in healthcare: data access, review and action boundaries Agents & RAG AI agents in healthcare: data access, review and action boundaries Scope AI agents in healthcare with permitted data, FHIR/SMART access and effective review. Assess task evidence, action b... Read guide → Agentic design patterns: choose the right control flow Strategy, architecture & ops Agentic design patterns: choose the right control flow Compare agentic design patterns by task, evidence, tools and control flow. Test retrieval, routing, agents, cost and reco... Read guide → AI business process automation: choose the first workflow Use cases & function AI business process automation: choose the first workflow Choose an AI business process automation project using workload, data, risk and integration evidence, plus an illustrativ... Read guide → AI copilot vs AI agent: SaaS behavior, permissions and user control Building AI AI copilot vs AI agent: SaaS behavior, permissions and user control Compare AI copilot vs AI agent for SaaS through task behavior, permissions, review controls and practical evidence for ar... Read guide →
Bring the task boundary, integrations and expected volume

What will your agent do, and what will it cost to operate?