The Pricing Structure Shapes the Relationship
How you pay for an AI agent isn't just a financial decision — it sets the shape of the development relationship, the incentives your developer has, and what kind of support you actually get after launch.
Two models dominate. Fixed project pricing — you pay a defined amount for a defined deliverable. Monthly retainer — you pay an ongoing fee for continuous development, maintenance, and improvement.
Neither is universally better. Each makes sense in different situations. This piece is meant to help you figure out which fits yours.
Fixed Project Pricing: How It Works
In a fixed project engagement, you agree the scope before work starts. The developer quotes a price for that scope. You pay (usually in milestones — a deposit to start, a payment at midpoint, a final payment on delivery). You receive a defined deliverable.
What you get: A completed AI agent built to your specification, at a known total cost.
What you don't get: Ongoing improvement, monitoring, or support beyond whatever is explicitly written into the contract.
Typical structure:
- 30% deposit on signing
- 40% at delivery of working prototype / midpoint milestone
- 30% on final delivery and sign-off
Typical inclusions: Scoping and discovery, agent build, integrations specified in the brief, testing, deployment, a short post-launch support period (usually 2–4 weeks).
Typical exclusions: Scope changes after sign-off, ongoing monitoring and tuning, knowledge base updates as your content changes, integration maintenance when third-party APIs update.
Fixed Project vs Monthly Retainer: Side-by-Side Comparison
| Factor | Fixed Project | Maintenance Retainer (£500–£1,200/mo) | Active Improvement Retainer (£1,500–£3,000/mo) |
|---|---|---|---|
| Upfront cost | £5,000–£25,000 one-time | Low or zero (post-build) | Low or zero (post-build) |
| Cost predictability | High — locked at sign-off | High — fixed monthly fee | High — fixed monthly fee |
| Scope flexibility | Low — changes trigger renegotiation | Low — minor fixes and updates only | Moderate — new features within agreed capacity |
| Post-launch support | 2–4 weeks, then billable | Ongoing — included in fee | Ongoing — included in fee |
| API / integration maintenance | Not included by default | Included | Included |
| Performance tuning | Not included | Not included | Included — regular review and prompt optimisation |
| Response time for production issues | Best-effort / queue | Priority response | Priority response |
| Best for | Stable, well-defined single agents | Agents that need upkeep but minimal change | Agents expected to grow and improve over time |
When Fixed Price Makes Sense
You have a well-defined, stable problem. If you know what you want, the scope is clear, and the workflow won't change much, fixed price is straightforward. You pay once, you get the thing.
You have a finite budget with no room for ongoing cost. Fixed price gives you cost certainty. If you're capped at a specific number and can't commit to anything recurring, this is the right starting point.
It's your first AI agent project. Starting with a scoped engagement lets you evaluate the developer's output quality and communication before signing up for a longer relationship. We'd actually recommend this approach even to clients who'd be a better fit for a retainer eventually — start small, see how the partnership feels.
The agent has low ongoing complexity. An FAQ bot trained on a stable knowledge base needs minimal maintenance, so fixed price fits. An agent making decisions on live data that changes constantly needs active management, and a fixed project leaves you without that support a few months in.
The Risk With Fixed Price
The biggest risk is misalignment between what you specified and what you actually need. Specifications always miss something. The edge cases that emerge in production weren't in the brief. The workflow that looked simple had three exceptions nobody mentioned.
In a well-run fixed project a responsible developer absorbs minor scope adjustments. Significant ones require renegotiation, which adds friction and time at exactly the moment you most need momentum.
The other risk is post-delivery abandonment. Once delivered and paid, plenty of developers simply move on. If the agent breaks three months later because an integrated API changed, you're negotiating new work instead of having someone already handling ongoing AI agent maintenance fix it that afternoon.
Monthly Retainer: How It Works
In a retainer engagement, you pay a fixed monthly fee for ongoing access to the development team. They maintain, monitor, improve, and extend the agent continuously.
What you get: An ongoing relationship — the team knows your system deeply, responds quickly to issues, and continuously improves performance.
What you don't get: Cost certainty in the same way fixed price gives you. The monthly fee is predictable; the exact scope of what gets done within it varies.
Typical structure:
- Initial build as a fixed project or as the first 1–2 months of the retainer
- Monthly fee covering: monitoring, knowledge base maintenance, prompt tuning, integration maintenance, feature additions within agreed capacity
Typical retainer tiers:
- Maintenance only (£500–£1,200/month): monitoring alerts, bug fixes, knowledge base updates as content changes, integration maintenance when APIs update
- Active improvement (£1,500–£3,000/month): everything above plus regular performance reviews, new feature additions, A/B testing of prompts and flows, expansion of the agent's scope
- Full partnership (£3,000–£6,000+/month): dedicated capacity for significant ongoing development — multiple agents, complex integrations, continuous optimisation
When a Retainer Makes Sense
The agent handles evolving workflows. If your business processes change, your products update, your policies shift — the agent needs to reflect those changes. A retainer means this happens systematically instead of through emergency one-off requests.
Performance matters and you want it to improve over time. An AI agent's first version is rarely its best. Real conversations reveal gaps, edge cases, and improvement opportunities. A retainer team reviews real conversations and tunes the agent on a cadence. Without that, the agent at month twelve looks identical to the one at month one.
The agent is business-critical. If a production failure costs you customers or revenue, you want a team that already knows the system and can respond in hours, not days. Retainer clients get priority response. One-off project clients get in the queue.
You're building more than one agent. Businesses that get the most from AI automation typically deploy multiple agents over time, starting with one workflow and expanding. A retainer gives you the continuous development capacity to do that without re-scoping and re-contracting every time.
The Risk With Retainers
The risk is paying for capacity you don't use. If the agent is genuinely stable and your business isn't changing rapidly, a full retainer can be more than you need. We've had clients downsize their retainer with us mid-year — we'd rather adjust the level than have them feel they're overpaying.
The other risk is lack of accountability. A retainer without clear deliverables and reviews drifts toward paying for availability rather than output. Define what you expect — features delivered, metrics tracked, regular reports — and hold the team to it. A retainer where nobody can articulate what was done last month is a retainer that's quietly become a bad deal.
The Hybrid Model: How Most Good Engagements Actually Work
In practice, the most effective engagements blend both approaches:
Phase 1 — Fixed project: Build the initial agent. Defined scope, defined cost, defined timeline. Typically 4–8 weeks.
Phase 2 — Maintenance retainer: After delivery, move to a lower-cost maintenance retainer (£500–£1,200/month) covering monitoring, updates, and minor fixes.
Phase 3 — Active improvement retainer (optional): If the initial agent performs well and you want to expand scope or push performance further, move to a higher-capacity retainer.
This gives you cost certainty for the build, ongoing support for the operation, and the flexibility to invest more once the value is proven.
Where Both Models Fail Quietly
Two honest caveats worth flagging. First, the cheaper option isn't automatically the right one. A fixed project at a tempting price that excludes meaningful post-launch support can cost you more in six months than a retainer would have, because every fix becomes a re-scoping conversation. We've inherited several "we'll just keep it cheap" projects that ended up costing more total than a maintenance retainer would have.
Second, retainers can rot if neither side audits them. The first three months are usually active and engaged, the next nine slowly devolve into "we should probably check in" emails. If you're on a retainer, set a quarterly review with concrete deliverables. If the team can't show what was done, downgrade or move on. If they consistently can, you've got a real partnership.
Questions to Ask Any Developer About Their Pricing
These sit alongside the broader red flags worth watching for when you're choosing who to work with.
"What is explicitly included in post-launch support?" If the answer is vague, assume it's nothing. Get specifics — how many weeks, what types of issues, what triggers an additional charge.
"What happens if an integrated API changes and breaks the agent?" Third-party APIs change — providers like OpenAI publish their own versioning and deprecation policies, and most other SaaS and CRM vendors do the same. This will happen. Know whether it's included in the project price, covered by the retainer, or a separate bill.
"How do you handle scope changes during the project?" Minor changes should be absorbed. Significant ones should have a transparent process for assessment and pricing. "We'll figure it out" is a risk.
"How do you structure retainers and what does a client get each month?" A good retainer has clear inclusions — hours or capacity, reporting cadence, priority response time. A vague retainer is just a recurring invoice with extra steps.
Related guides
- AI agent development cost: pricing tiers
- How much it costs to build an AI agent
- Writing an AI agent scope of work
- How to evaluate AI agent vendors
- Measuring AI agent ROI with a template
- AI agent development services
What We Offer
We typically work with a fixed project for the initial build, followed by an optional maintenance retainer. We try to be transparent about what each covers.
For clients who want active ongoing improvement — performance reviews, regular tuning, feature additions — we offer higher-capacity retainers with clear deliverables and monthly reporting. We'd rather recommend you a smaller retainer than upsell you to a tier you don't need yet.
If you want to talk through which structure makes sense for your situation, we'd be happy to walk you through it — including the cases where a fixed project followed by nothing is the right answer.
Talk to us about your project — no commitment, just a conversation.
Frequently Asked Questions
How much does it typically cost to build an AI agent on a fixed project basis?
Most small-to-mid scope AI agents — a customer support bot, a lead qualification agent, or an internal workflow automator — fall in the £5,000–£25,000 range on a fixed project basis. Simpler, single-integration agents sit at the lower end; complex multi-step agents with several API integrations sit higher. The single biggest factor in price is scope clarity: a well-defined brief reduces cost because developers don't need to price in uncertainty.
Is a monthly retainer worth it if my AI agent is already working well?
It depends on how stable your business is. If your products, policies, and workflows rarely change and the agent handles a narrow, well-defined task, a basic maintenance retainer (£500–£800/month) may be all you need — or possibly nothing at all. If your content updates frequently, you want ongoing performance tuning, or you're planning to expand what the agent does, a more active retainer pays for itself. A well-tuned agent typically converts or deflects materially better than one left static.
What is the difference between a maintenance retainer and an active improvement retainer?
A maintenance retainer is defensive: it keeps the agent working as the world changes around it — API updates, content changes, minor bugs. An active improvement retainer is offensive: the team reviews real conversations, identifies failure points, tests prompt variations, and ships new capabilities on a cadence. If you want the agent to get measurably better over time, you need an active improvement retainer, not just maintenance.
Can I switch from a fixed project to a retainer after the agent is built?
Yes, and this is actually the most common path. Most clients start with a fixed project to build the initial agent, then decide post-launch whether ongoing support makes sense. Good agencies offer a natural handover to a retainer tier. The advantage is that the team already knows your system, so the retainer starts with zero onboarding time.
What should be in an AI agent retainer contract?
The contract should specify: what's included each month (hours, feature additions, bug fixes, reporting), what's explicitly excluded (large-scope new builds, for example), response time SLAs for production issues, how the monthly deliverables are reported, and the notice period to cancel or adjust tier. Avoid retainers that are vague on deliverables — they almost always drift toward paying for availability rather than output.
How do I know if a developer is padding scope to increase the fixed project price?
A few signals: the estimate has no line-item breakdown, there's no clear scoping phase before the quote, or the quote arrives within 24 hours of your brief without any follow-up questions. Responsible developers ask clarifying questions before quoting because scope ambiguity increases their risk. If a quote arrives fast and round with no detail, it's either been padded or the developer hasn't thought it through — both are problems.
What happens to my AI agent if I cancel a retainer?
You should own the agent outright — the code, the configuration, the integrations. If a contract ties the agent to continued payment in a way that limits your access, that's a red flag. When cancelling, ensure you have documentation of how the agent is configured, what prompts are used, and how integrations are set up so another team (or your own) can take it over. A good agency makes this handover clean even when the relationship ends.