AI Automation Agency Pricing 2026:Retainers vs Projects

We publish one price for an AI agent: $5,000 for the agent, plus a one-time $5,000 setup fee. That's $10,000 at checkout, paid once, and it's on the page for anyone to read before they ever talk to us.

We also quote $28k to $70k for a single-workflow agent. Both numbers are true at the same time, and the gap between them is most of what you need to understand about how AI automation agencies price work.

This article is about that gap. Not what an agent costs to run (that's the tokens, the phone minutes, the hosting, and it lives in our breakdown of what an AI agent costs in 2026), but how the people who build agents decide what to charge you, and which of those models is on your side.

The wrong model most buyers carry in is that agency pricing is a number. You ask, they quote, you compare three quotes and pick the middle one. The real model is that agency pricing is a risk allocation. Every pricing structure decides who pays when the scope grows, when the model gets retired, when the volume doubles. The number is just what falls out once that decision is made.

Therefore the useful question isn't "what does it cost?" It's "when something changes, whose problem is it?"

AI automation agencies price work in four ways: by the hour, by the project, by the month, or by the package. A fifth, pricing by outcome, shows up in vendor software but rarely in agency contracts, and it gets its own section below.

Here's the short version before we argue about any of it.

Notice the third column. It's the one that matters, and it's the one no quote spells out.

Hourly is the oldest model and the most honest about uncertainty. You pay for time. If the work takes longer, you pay more. If it takes less, you pay less. The agency is never punished for a scope that grew, which is exactly why some buyers hate it.

Fixed projectflips that. The agency writes down what it will build, names a price, and eats the overrun if its estimate was wrong. That's the model most buyers want for a build, and it's the one we use for bespoke work, as a phased proposal so each phase has its own scope and price.

Retainer is a monthly fee. At its best it buys named work every month. At its worst it buys a vague promise of availability, which is a subscription to a phone number.

Productized packageis the newest arrival in this market. It's a fixed project that has been scoped once and sold many times, at a price anyone can read. The agency can commit to it because it has already done the thinking. You get certainty, as long as your problem is the problem the package solves.

Many engagements combine two of these. The structure we use for bespoke work is a fixed-price build followed by an optional retainer, because the build and the life after launch are different kinds of work with different kinds of risk.

Every pricing model protects one side from one kind of surprise, and each has a downside the seller won't volunteer. So here are the downsides, including the ones that cost agencies like mine.

An hourly rate is meaningless until you multiply it by the hours, and the hours are where quotes quietly diverge.Buyers compare rates because rates are easy to compare. That's the trap.

Look at the spread. Clutch's AI guide puts most listed firms at about $25 to $49 an hour. Upwork's own hiring pages, as they appeared in search results (the pages block automated fetches, so treat these loosely), describe AI developers as generally charging somewhere around $30 to $150 an hour, with a marketplace fee on top. Our senior-led rate is $150 to $225.

On rates alone, we're three to nine times the cheapest band. That's the comparison a spreadsheet makes, and it's the wrong one.

Here's the right one. Suppose a job takes a senior builder 100 hours: at $150 that's $15,000. Now suppose a cheaper team at $40 an hour takes three times as long, because it's learning the model's quirks on your budget, and then needs a second pass after launch. 300 hours × $40 = $12,000, plus another 100 hours of rework = $16,000. The rate was 3.75x lower. The bill was about 1.07x higher.

To be clear, that's a scenario, not a law. Plenty of lower-rate teams are excellent, and plenty of expensive ones are slow. The point is only that the rate is one factor and the hours are the other, and nobody quotes you the hours with the same confidence as the rate.

So when you get an hourly proposal, ask for three numbers: the rate, the estimated hours by phase, and what happens when the estimate is exceeded. The third one is the real price. If the answer is "we keep billing", you've bought cost plus with no ceiling. If the answer is "we cap it and talk", you've bought something closer to a fixed price with an honest escape hatch.

Seniority also changes what the hours contain. A senior builder spends a larger share of the hours deciding what not to build: which write path to avoid, which step should stay with a person, which problem isn't an AI problem at all. Those hours don't show up as features. They show up as a smaller system that breaks less.

And for completeness: the hourly model is where the question of who you're hiring (a freelancer, an agency or an employee) matters most, because the rate alone hides benefits, management time and continuity. That's a different decision from pricing, and it deserves its own comparison.

Outcome-based pricing charges per result, and it works for software vendors with enormous volume far better than it works for agencies.It's the model every buyer asks about, so it's worth being precise.

The vendors do publish it. Intercom lists its Fin agent at $0.99 per resolution on its pricing page, on top of seats. Salesforce lists $2 per conversation for Agentforce, alongside a credit-based option. Those are real, published, per-outcome prices.

Why don't agencies copy them? Three reasons, and each one is a risk the agency can't control.

• Volume: A vendor spreads its cost over millions of conversations. An agency building one agent for one client has one client's volume. A quiet month means no revenue for work already done.
• Definitions: What counts as a resolved ticket or a qualified lead? The client's team decides, and the argument about definitions tends to replace the work.
• Attribution: If bookings go up, was it the agent, the new ad campaign or the season? An outcome contract turns every month into a debate about causation.

There's also a quieter problem for you. An agency paid per outcome has a reason to define outcomes generously and to push the agent toward whatever gets counted. That's not a moral failing; it's the incentive. If a lead-qualification agent is paid per qualified lead, it will learn to qualify.

I couldn't find an agency that publishes an outcome-based price list for custom agents. That doesn't prove none exists, and I say so in the limitations section. But if one offers you outcome pricing, read the definition clause before the price.

And do the arithmetic yourself. At 3,000 conversations a month, Fin at $0.99 per resolution is up to $2,970 if every one counts, and Agentforce at $2 per conversation is $6,000. Our own cost scenarios put the raw model tokens for that volume on a mid-tier model at roughly $78 a month, list prices checked September 28, 2026. Per-outcome pricing isn't a rip-off: you're paying for the vendor's whole platform, not just tokens. But the multiplier is about 38x to 77x over the raw tokens, or about 19.5x to 39.5x over the roughly $152 a month full running stack in that article, and you should know that number before choosing.

The published data on AI agency pricing is thin, and none of it splits retainer from project pricing.Here's everything I could trace to a method, and what each source can and cannot tell you.

So here's the plain conclusion. As of September 28, 2026, no credible primary source quantifies AI agency pricing by retainer versus project. Anyone who quotes you a precise market split is quoting a blog that quoted a blog.

That's why this article leans on arithmetic rather than benchmarks. Arithmetic you can check. A benchmark with no method you can only believe.

A retainer earns its fee when it buys specific recurring work that an agent actually needs after launch.An agent isn't a website. It sits on top of a model somebody else owns, and that somebody retires models on their own calendar.

This is the part most buyers underestimate. Anthropic's deprecations page commits to at least 60 days' notice before retiring a publicly released model. In practice that notice has been used: Claude Sonnet 4 and Opus 4 were notified on April 14, 2026 and retired June 15, 2026. Opus 4.1 was notified June 5 and retired August 5.

Do the division. Two retirement cycles in under four months, and four Anthropic retirement events in about ten months once you count Sonnet 3.7 and Haiku 3.5. If your agent runs on one model, plan on roughly one or two migrations a year.

OpenAI is similar, with sharper edges. Its deprecations page shows the gpt-4o-realtime-preview models announced on September 15, 2025 and shut down May 7, 2026, and legacy snapshots announced April 22, 2026 for shutdown on October 23, 2026. Preview models can get as little as about two weeks' notice. If your voice agent runs on a preview model, you're living on a two-week clock.

A migration isn't a find and replace. The new model phrases things differently, follows instructions differently, and calls tools differently. Anthropic's own pricing page notes that newer Claude models' tokenizer produces roughly 30% more tokens for the same text, so even the running cost moves. Every one of those changes has to be tested before it reaches a customer.

So here's what I'd expect a retainer to name, in writing.

Evaluation reruns deserve a sentence of their own, because they're the item most often missing. Without a fixed evaluation set, nobody can say whether the new model is better or worse; they can only say it seems fine. We covered how to build one in our guide to AI agent evaluation and observability, and a retainer should produce that evidence every time something changes.

The security line is there for a reason too. The UK NCSC wrote in December 2025 that prompt injection may never be fully mitigated the way SQL injection was, because language models don't separate instructions from data. It's LLM01 on the OWASP LLM Top 10 for 2026, with Excessive Agency at LLM03. Nobody can sell you a solved problem here. What a retainer can buy is blast-radius reduction: keeping the agent's permissions narrow and re-checking them as the system grows.

If a retainer proposal lists none of these, it isn't a retainer. It's a standing invoice.

How big should a retainer be? Work it backward from the list rather than forward from a tier. Suppose the agent needs one model migration a year, a monthly transcript review, a handful of rule changes each quarter and an on-call promise. Estimate the hours for each at the agency's hourly rate, add them up, and divide by twelve. If the retainer on the table is far above that number, ask what the difference buys. If it's far below, ask what gets left out when a migration lands in the same month as a pricing change.

That exercise does two things. It turns a retainer from a feeling into a budget line you can defend. And it tells you, before you sign, whether you're paying for work or for reassurance. Reassurance has value, but it should be a choice you made, not a default you drifted into.

One more test: ask what happens to unused capacity. Some retainers roll unused hours forward; many don't. Neither is wrong, but a retainer that forfeits unused hours every month is priced for the agency's cash flow, and you should know that going in.

The flip side, to be fair to buyers: if your agent is simple, rarely changes and runs on a stable model, you may not need a retainer at all. Paying hourly for the occasional migration can be cheaper. A retainer makes sense when change is frequent enough that you'd otherwise be onboarding a contractor every quarter.

Our packaged agent is $5,000 for the agent plus a one-time $5,000 setup fee, $10,000 in total, charged once.Everything in this section comes from the product pages and the checkout code. Where they're silent, I say so.

There are eight pages. The custom agent lives at the hub, /ai-agents, and seven packaged jobs sit under it: receptionist, lead generation, appointment scheduler, customer support, sales assistant, business assistant and custom workflow. All eight use the same price and the same two-line checkout.

A few details from the individual pages are worth knowing, because they describe how the guardrails behave. The customer support agent identifies itself as an AI, and anything that changes an order, a refund or an account runs through deterministic code and can require a human approval step. The custom workflow agent page says the rules are configurable, and that process changes are part of the ongoing relationship rather than a rebuild. It also says, plainly, that we won't promise headcount reduction.

And the custom page answers the question every agency should answer and few do: what if AI is the wrong tool? We say so. Some problems are a process fix or a simple integration, and selling an agent into those would waste your money.

To be clear about the limits: a package price is a price for a scoped job, not for any job. If you want the whole service picture, including bespoke builds and retainers, it's on our AI agent creation service page.

The package is a fixed, pre-scoped job on systems you already use. The bespoke bands price the work that goes beyond it.That's the whole explanation for why $10,000 and $28k to $70k can both be true.

What moves a job out of the package and into a band? One of four things: several systems to integrate rather than one, custom write paths into a system that wasn't built to be written to, regulated data, or several agents coordinating. The package connects to what you already use. The bands are for when what you already use isn't enough.

Write paths are the one to watch. Reading a calendar is easy. Writing a booking into a practice management system with no clean API, with an audit trail and a rollback, is a project. That's where the money goes, and it's why we price it separately rather than pretend a package covers it.

I'll admit the downside. A buyer can reasonably ask why the custom agent at /ai-agents is also $10,000 when a bespoke single workflow starts at $28k. The honest answer is that the custom package starts from a workflow that doesn't match one of the seven packaged jobs but still fits the package's shape: systems you already use, nothing migrated. The pages don't say what happens if a job turns out to need the heavier work above, and they don't publish an upgrade path, so I won't describe one. If you suspect your workflow is on that line, ask on the call before you pay.

Every bespoke band carries the same terms: a fixed-price phased proposal within 5 business days of the discovery call, a 30-day post-launch warranty, and full source code and IP ownership transferred to you. If you're shortlisting agencies rather than pricing models, the neutral ranking in our top AI agent development companies for 2026 scores ten third parties on the same rubric, and discloses separately where we'd land on it.

Over twelve months, the pricing model matters less than whether you needed the heavier scope in the first place. Let me show the arithmetic, because this is where buyers talk themselves into the wrong thing.

A worked scenario. Consider a services business that wants a customer support agent on its website, handling roughly 3,000 conversations a month, connected to one help desk it already uses. Three ways to buy the first year. The running-cost figures below are list prices for one illustrative stack, checked September 28, 2026, not our quote and not what any particular build will cost.

Now reduce it. Path B's low end divided by Path A: $59,824 ÷ $11,824 ≈ 5.1x. So a bespoke build with a retainer costs about five times the package in year one, at the cheapest end of both. That comparison gives Path A no maintenance at all. Add the planning assumption from our cost article, about 24 senior hours a year or $3,600 to $5,400, and Path A becomes $15,424 to $17,224; the low-end gap narrows to $59,824 ÷ $15,424 ≈ 3.9x.

That multiplier is the real question. Not "is $10,000 cheap?" but "does my problem need five times the scope?" If the agent answers questions and hands off to your help desk, it almost certainly doesn't. If it has to issue refunds into a billing system with no API, write to two other systems and survive an audit, it probably does, and the package price would be a false economy.

Look at the retainer line too. In Path B the retainer ($30,000) is bigger than the build ($28,000). Over a year, the monthly fee is the larger decision. That's why I'd rather see a retainer tied to named deliverables than a cheaper build with a vague one.

And Path C shows the hourly trade. At 10 hours a month, hourly costs $18,000 to $27,000 a year against a $30,000 low retainer. Hourly wins if your change volume is light and predictable. The retainer wins when a model deprecation lands and you need people who already know the system, this week.

Construction settled this argument a long time ago, and AI agency pricing is relearning it. The concept is the difference between fixed-price and cost-plus contracts.

In a fixed-price (or lump-sum) contract, the builder agrees to deliver a defined building for a set price and absorbs any overrun. In a cost-plus contract, the owner pays the builder's actual costs plus a fee, and absorbs any overrun. One sentence each, and every clause in a construction contract follows from which one you signed.

Builders know the rule that follows. You can only fix a price on a design that's finished. Nobody sensible quotes a lump sum on a house whose plans are a sketch on a napkin; they quote cost plus until the drawings are done, then fix the price on the drawings.

Map that onto agents.

• Hourly is cost plus: You pay actual effort plus the agency's margin baked into the rate. Right when the design is a napkin.
• A fixed project is a lump sum: Right when the scope is drawn. Wrong when it isn't, because the builder prices the unknowns into the lump.
• Discovery is the architect's drawings: It exists to turn a napkin into a plan you can fix a price on. That's why discovery is priced as its own phase.
• A package is a tract home: The plans were drawn once and built many times. That's why the price can be published. Move a load-bearing wall and it isn't a tract home anymore.
• A retainer is the maintenance contract: The building exists; now the roof needs checking every season, and the city changes the code.

The construction lens also explains the most common fight in agency work. A buyer asks for a lump sum on a napkin. The agency either refuses (and looks evasive) or agrees with a fat contingency (and looks expensive). Both are rational. The fix isn't haggling; it's buying the drawings first.

That's why our bespoke proposals are phased. Discovery gets its own price. The build is fixed on what discovery found. Each phase is a lump sum on a finished drawing, rather than one lump on a napkin.

And the model deprecations from earlier? That's the city changing the building code under a finished house. No lump-sum contract covers it, because it didn't exist when the price was fixed. It's maintenance, and maintenance belongs in a retainer or an hourly arrangement, never hidden inside a build price.

Most pricing red flags are omissions: something the proposal should say and doesn't.Here are the ones I'd walk away over, or at least stop and ask about.

1. 1.A retainer with no deliverables: If it doesn't name monitoring, migrations, evaluation reruns and a response time, it's a standing invoice. Ask for the list in writing.
2. 2.Hourly with no cap or estimate: Time and materials is fine for discovery. Open-ended hourly for a build puts all the risk on you with no ceiling.
3. 3.A fixed price with no scope document: The price is only as fixed as the scope. No scope means every surprise becomes a change order.
4. 4.No change process: How is new work priced mid-project? If the proposal is silent, you'll learn the answer at the worst moment.
5. 5.Running costs left out: Model tokens, hosting, telephony and observability are real monthly costs. A proposal that omits them isn't cheaper; it's incomplete.
6. 6.The agency keeps the code or the accounts: Under US law, contractor-written code generally belongs to the contractor unless a signed agreement assigns it. Check the assignment clause, and make sure the cloud and model accounts are in your name.
7. 7.A guaranteed ROI or headcount cut: Nobody can promise what an agent will save you before it has touched your real conversations. A guarantee is a sales tactic.
8. 8.A price you can only hear on a call: Talking first is normal. Never getting a written proposal afterward isn't.
9. 9.Outcome pricing with a loose definition: If you're paying per lead or per resolution, the definition clause is the price. Read it first.
10. 10.Security described as solved: Prompt injection is unsolved. An agency should talk about limiting what the agent can do, not about making it immune.

The code ownership point deserves a footnote, because it's the one that costs the most to discover late. Software isn't one of the listed categories that can be a commissioned work made for hire under 17 U.S.C. § 101, so a written assignment is what moves ownership to you. I'm not a lawyer and this isn't legal advice; have yours read the clause.

A full vetting checklist for the people behind the quote (not just the pricing) is in our companion piece on hiring. The short version for pricing: the better proposal isn't the cheaper one, it's the one that tells you what happens when something changes.

Here's what I could not verify, and where this article could be wrong.

There's no market split for retainer versus project.I looked, and I couldn't find a primary source with a method. If one is published, the argument here about which model to use stands, but I'd want to add its numbers.

Clutch skews offshore.Its figures describe firms listed on Clutch, drawn from reviews. They're not a survey of US senior agencies, and I couldn't re-fetch the Clutch pages on the day I wrote this because they block automated requests; the figures are as recorded in September 2026.

Few agencies publish prices.I found HouseofMVPs and a handful of voice-platform vendors. I couldn't find five more AI agencies with real published price lists, so I can't tell you where our package sits in a distribution. I can only tell you it's published.

Outcome pricing among agencies.I said I couldn't find an agency publishing outcome prices for custom agents. That's a statement about my search, not proof of absence.

Our own package.The pages don't publish running costs, a monthly fee or the length of the tuning period. I've described exactly what they do say and nothing more. If that bothers you, it should: ask for those terms in writing before you pay us or anyone else.

The arithmetic is a scenario. The running-cost stack uses list prices checked September 28, 2026 for one illustrative text-channel setup. Prices change, cached tokens cut costs, voice changes the shape completely. The 5.1x multiplier is for the cheapest end of each path with no maintenance on the package (about 3.9x with it), and your multiplier will differ.

I have a conflict of interest.We sell every model discussed here. The worst case for you, if I've argued badly, is that you ask an agency three extra questions about running costs, code ownership and retainer deliverables. That's a cheap downside, and it holds whoever you hire.

You can turn this into a pricing decision in about a week.Here's the order I'd do it in.

1. 1.Write one paragraph describing the job: what the agent answers or does, which systems it reads, and which it must write to. If it only reads and writes to tools you already use, price a package first. If it writes into several systems or touches regulated data, you're in bespoke territory.
2. 2.Ask every agency on your list for the same four things in writing: the price model, what is excluded, the expected monthly running costs at your volume, and who owns the code and the accounts. Discard anyone who won't put it on paper.
3. 3.If a retainer is on the table, make them list the deliverables (migrations, evaluation reruns, monitoring, changes, response time) and compare the annual total against 10 hours a month at their hourly rate.

If the paragraph in step one reads like one of the packaged jobs, the package pages will tell you more than a sales call will. If it doesn't, buy the drawings before you buy the house. Time to get to work.