AI Agent Development Cost (2026): What You Pay to Build Agents That Take Real Actions

A custom AI agent that takes real actions costs about $7,000-32,000 for a narrow pilot and about $17,000-93,000 for a production agent covering one business workflow at Eastern Europe rates. At US onshore rates the same production agent lands around $38,000-186,000, and agents that span several workflows or coordinate sub-agents start near $42,000 and can pass $190,000 even with an offshore team.

We are engineers who build these systems: assistants that write and test code against a live runtime, AI wired into CRM and ERP, and model pipelines that run hundreds of jobs in parallel. The numbers below are planning ranges based on effort and published market rates, not a quote. They are meant to help you size a budget and ask better questions before you talk to any vendor, including us.

By “agent” we mean software that uses a language model to decide which tools to call and then calls them: it looks up an order, updates a CRM record, files a ticket, runs a script. If you need a system that mostly answers questions, read our guides to chatbot development cost and the broader AI development cost instead. Agents cost more because every action needs integration, permissions and testing.

Cost at a glance

Costs are hours multiplied by a rate band. We use about $35-80 per hour for Eastern Europe, the band in 2026 outsourcing rate surveys, and $80-160 per hour for US onshore teams, inside the $80-180+ range the same surveys give for North America. The wide spread inside each row comes from seniority, how clean your APIs are and how much risk the agent’s actions carry.

What drives the cost

1. Number and quality of tools. Each tool is an integration: authentication, input schema, error handling and a description good enough for the model to choose it correctly. A clean REST API with documentation takes days. A legacy system with no API, rate limits or inconsistent data takes weeks. Tool count is the single biggest lever in most agent budgets.

2. Read versus write actions. An agent that only reads (search orders, summarize tickets) is cheap to make safe. An agent that writes (issues refunds, changes prices, sends emails to customers) needs validation, limits, idempotent operations so retries do not duplicate actions, and a way to undo or escalate.

3. Permissions and identity. Should the agent act as itself or on behalf of the user who asked? Per-user permissions mean passing identity through every tool call and respecting each system’s access rules. That is real engineering, and it is not optional when the agent touches customer or financial data.

4. Human-in-the-loop design. Most production agents start with approval steps: the agent proposes, a person approves or edits, then the action runs. You need a review queue, notifications and a record of what was approved. As evaluation results improve, you can remove approvals for low-risk actions.

5. Evaluation. You cannot improve what you cannot measure. A useful evaluation suite holds real task samples with expected outcomes and is rerun after every prompt, tool or model change. Building the dataset often takes more domain time than engineering time, so plan for your experts to help.

6. Observability and cost control. Agents make several model calls per task and can loop. Tracing every step, recording tokens and cost per task, setting hard limits on steps and spend, and alerting on failures prevents surprise bills and makes debugging possible.

7. Reliability at volume. Running a few tasks a day is easy. Running hundreds in parallel means queues, retries with backoff for API rate limits, and choosing cheaper models for simple steps. This is mostly backend work and it grows with volume, not with intelligence.

Use the estimator to price your own scope; the preselected modules match a production agent for one workflow.

Cost by component

The same modules as the estimator, with what each one usually includes and its share of a typical production build.

The preselected modules add up to 480-1,160 hours, the production row in the table above.

Running costs after launch

Model usage. Agents bill per token, and a single task often makes 5-15 model calls because the model plans, calls a tool, reads the result and decides again. As a worked example, take a task with 10 calls averaging 8,000 input tokens and 500 output tokens: about 80,000 input and 5,000 output tokens. At Anthropic’s list prices in November 2026, that task costs about $0.01 on Claude Haiku 5.5 ($0.10 input and $0.50 output per million tokens for prompts up to 100,000 tokens), about $0.21 on Claude Sonnet 5.5 ($2 and $10) and about $0.42 on Claude Opus 5.5 ($4 and $20). On OpenAI’s price list, GPT-6.1-terra at $1 and $5 per million tokens comes to about $0.11. At 10,000 tasks a month, the Sonnet figure is about $2,100 a month.

Two levers cut that bill. Prompt caching charges a fraction of the input price for the repeated part of the context (Anthropic lists cache reads for Sonnet 5.5 at $0.10 per million tokens), and agents resend the same instructions and tool definitions on every call. Batch processing, where tasks do not need an instant answer, is 50% cheaper on Anthropic’s API. Routing simple steps to a small model and hard ones to a large model also helps.

Tracing and evaluation tools. Langfuse Cloud has a free Hobby tier with 50,000 units a month, Core at $29 a month and Pro at $199 a month, each with 100,000 units and $8 per additional 100,000; it can also be self-hosted for free because it is open source. LangSmith offers a free Developer seat with 5,000 base traces a month and Plus at $39 per seat with 10,000 base traces, then pay as you go. Evaluation runs also consume model tokens, so budget for them.

Hosting and maintenance. The agent’s backend, queues and database usually cost far less than model usage. The larger ongoing cost is engineering: APIs change, models are updated or retired, and new task types appear. Plan for a few days a month of maintenance on a production agent, more while you are still widening its scope.

Build, buy or combine

Hosted agent platforms and no-code builders work for internal automations with standard connectors: summarize email, update a spreadsheet, post to Slack. You pay per seat or per run, setup is fast, and limits show up when you need custom permissions, your own data model or tight cost control.

Frameworks and vendor SDKs (open-source agent frameworks or the model provider’s own agent SDK) handle the loop, tool calling, memory and tracing hooks. For most custom agents this is the right base. Writing your own orchestration only makes sense when you need behavior the frameworks fight, such as a strict domain-specific execution loop.

Custom work on top is where the budget goes in any case: connectors to your systems, scoped credentials, approval flows, evaluation built from your own cases and monitoring. That part does not come in a box, because it encodes your processes and risks. The usual best path is a framework for the loop plus custom integrations, permissions and evaluation.

How to get an accurate estimate

1. Collect 20-50 real task examples. Include the inputs, what a good outcome looks like and where people currently get it wrong.
2. List every tool the agent needs, with the system, the API (or lack of one) and whether the action reads or writes.
3. Mark risky actions. Decide which ones need approval at launch and what the agent may never do.
4. Set success and cost targets: for example, the share of tasks completed without help, and a maximum cost per task.
5. Estimate volume: tasks per day and peak concurrency, which decide model choice, caching and infrastructure.
6. Ask for a pilot first. A fixed-scope pilot on read-only tools gives you real success rates and cost per task before you fund write access.

From our work

For Lokad, a supply chain software company, we built an assistant inside its platform that answers questions and writes scripts in Envision, Lokad’s own language. It works like an agent loop: generated code runs against the real Envision runtime, and scripts that fail go back for another pass. 82% of generated scripts run on the first attempt and 94% by the second, and users reach a first working script about 70% faster. The assistant also suggests the right Lokad contact in about 78% of cases. Details are in the Lokad AI assistant case and in our guide on how to validate LLM-generated code.

For an educational lecture archive, we built a transcription pipeline on Kubernetes that runs more than 300 jobs at the same time, with retries and adaptive backoff for API rate limits. Choosing between Gemini Pro, Flash and Flash-Lite by job cut AI and API costs by up to 60%. The same model-routing idea applies to agents. See the AI transcription pipeline case.

In a cross-industry automation project, we connected AI services to existing CRM, ERP and marketing tools so assistants could answer inquiries, book appointments and send replies inside the current workflow. Customer response times improved by 40%. See AI business automation.

Where OSKI fits

OSKI is a .NET, React and AI engineering company with a team mostly in Ukraine. We design and build agents, from a scoped pilot to production with approvals, evaluation and tracing, through our AI development and custom software development services. If you already have a product team, we can add engineers as a dedicated team, and our cloud and DevOps group handles queues, scaling and monitoring. Send your scope from the estimator above and you get a written estimate with the assumptions spelled out.