AI Agent Pricing: Five Questions to Ask Before You Sign an Agentic AI Contract

By Elaine Nowak, Global VP of Product Marketing at Sidetrade 16 October 2026

A proof of concept with a handful of AI agents may be cheap. A production deployment, with agents running every day across collections, cash application, and disputes, is a different financial proposition. And the way vendors price that work is still changing.

That shift changes the question finance leaders ask. “What does AI cost?” gives way to “What will AI cost over the full term, and how do we control it?”

A price list answers the first question. Only a contract answers the second, and that is where the detail matters.

This guide sets out five questions to ask before you sign, what a good answer sounds like, and the governance and lock-in questions that sit next to price. It is written for the CFO who signs the contract, the CIO who approves it, and the O2C leaders who live with it every day.

 

Why is AI agent pricing so hard to forecast?

Seat-based software was easy to budget. If you knew your headcount, you knew your bill. AI agents break that link: cost follows the work an agent performs, regardless of how many people use it.

Agents also cost more to run than a chat assistant. An assistant answers a question once. An agent reasons, calls a tool, reads the result, and reasons again – often several times for a single task.

Consider a collections agent working on one overdue invoice. It reads the account history, checks for an open dispute, chooses a channel, drafts a reminder, sends it, and logs the customer’s reply. That is one business outcome and six steps. Depending on the contract, the vendor might bill it as one unit, six units, or a volume of tokens nobody predicts in advance.

Vendors have responded with a wide range of pricing units, often combined in one contract. Each one puts the forecasting risk in a different place.

Pricing unit	What you pay for	Where the forecasting risk sits
Per seat	Each named user	Predictable for users, but agent work may be billed on top
Per token	Raw model consumption	Rises with every reasoning loop and retry
Per credit	A vendor-defined unit mapped to actions or tokens	The vendor sets what a credit is worth, which makes comparison hard
Per action or task	Each step or task an agent completes	Depends on how “one action” is defined
Per conversation	Each customer interaction	Depends on when a conversation starts and ends
Per outcome	Each successful result	Depends on who defines success

Underneath all of this sits a cost most buyers never see. If your vendor builds on a third-party model, it buys tokens at a rate someone else sets. This does not mean that the price is high today, but it introduces uncertainty as to what the prices might be tomorrow.

 

Five questions to ask before signing an agentic AI contract

Each question below covers what to ask the vendor and what a weak answer tends to sound like. A vendor that volunteers these answers inspires more confidence than one that gives them up only under pressure.

1. What exactly counts as a billable action?

This is the definition that decides every other number in the contract. Three steps make the definition concrete:

• Walk through a real workflow. Have the vendor take one process from your own operation, such as chasing an overdue invoice, and count the billable units out loud.
• Test the edge cases. In cash application automation, for example, matching one payment to ten invoices could count as one action or as ten.
• Put it in the contract. Write the definition into the signed agreement as well as the pricing page.

It also pays to establish what kind of agent the contract covers, because the word now spans four different things:

• Predictive model. It produces a score or forecast, such as a predicted payment date.
• Generative assistant. It drafts or summarizes content, such as a suggested reply to a customer.
• Agentic workflow. It acts on a trigger within policy and monitors the result, such as choosing a collection cadence.
• Autonomous process. It owns an outcome from start to finish, such as resolving a routine dispute from intake to closure.

A high agent count says little about autonomy: what matters is whether each agent owns a complete task.

Red flag: “It depends on usage,” with no worked example.

2. Do retries count against the allowance?

Retries are routine in agent work: a customer’s AP portal times out, a bank file arrives late, or a model reworks a failed step. If an agent needs four attempts to submit one invoice to a portal, you need to know whether that is one billable submission or four.

Three details decide how retries show up on your invoice:

• Billing rules. Clarify which retries the vendor bills, and whether it excludes retries that stem from its own errors.
• Loop limits. Confirm what stops an agent from retrying indefinitely, because an uncapped loop is where surprise bills come from.
• Reporting. Check that your usage reports show retries separately from first attempts, so the bill reflects exactly what the agent consumed.

Red flag: no loop limit, or no way to see retries in your usage reports.

3. Who pays for failed or hallucinated work?

When an agent gets it wrong, you can end up paying twice: once for the action and once for the person who fixes it. A payment matched to the wrong invoice, for example, creates a correction for your team and may trigger a reminder to a customer who has already paid.

Four points settle who carries the cost:

• Failed runs. Check whether the vendor bills for runs that fail, or only for runs that complete.
• Error detection. Find out how the system detects errors and how it surfaces them to your team.
• Cost of rework. Establish whether the vendor shares the cost when your team has to redo the work.
• Outcome-based pricing. If the vendor charges by outcome, agree in writing what counts as a successful outcome before you sign.

Red flag: the vendor bills per action but will not define failure.

4. Does unused capacity roll over?

Order-to-Cash work is seasonal, with month-end close, quarter-end collections pushes, and year-end concentrating volume into a few days. An allowance sized for an average month runs short at quarter-end and sits idle in between.

Two details decide how a seasonal peak affects your bill:

• Unused capacity. Pin down whether it rolls over, expires, or can be pooled across teams and entities.
• The cap. Spell out what happens when you reach it: a hard stop, throttling, a true-up, or overage billed at a rate you know in advance.

If your collections automation runs on a capped allowance, a hard stop in the middle of a quarter-end push is an operational risk, not a billing detail.

Red flag: an overage rate that is “available on request.”

5. How is model cost inflation handled over a multi-year term?

This is the question that matters most over the life of the contract. Order-to-Cash software is usually a multi-year commitment, but a vendor that buys its inference from a third party does not control its own input costs. It can only commit to what its supplier commits to.

Three points turn that into something you can enforce:

• Committed price. Put the question to the vendor in plain terms: what is your committed price, and for how long?
• Price protection. Check whether the contract includes price protection or a cap on increases.
• Model changes. Work out what happens to your price and your agents if the vendor retires or replaces the underlying model mid-term.

Red flag: a multi-year contract where the AI price is only fixed for the first year.

 

AI agent governance: the questions that sit next to price

AI agent governance is the set of controls that decide what an agent may do and record what it did. It also brings in a person whenever the agent should not decide alone. Ask the vendor to demonstrate each control live:

• Guardrails. Which actions can the agent take on its own, and is each action checked against policy before it happens rather than after?
• Audit trail. Is every action logged and traceable back to the event that triggered it, in a form your auditors can read?
• Human approval. Where does the agent pause for sign-off, who receives the escalation, and does the work resume cleanly once approved?
• Recovery. If a run fails halfway through, does it resume where it stopped, or start again and bill you twice?
• Data use. Where does your receivables data go, which models process it, and is it ever used to train a third party’s model?
• Usage visibility. Can you see consumption by user, agent, and entity as it happens, rather than on next month’s invoice?

The last two connect governance straight back to cost. If you cannot see usage as it happens, you cannot govern it.

 

AI vendor lock-in: ask who owns the intelligence

Most buyers check for lock-in to their vendor, covering contract length, exit terms, and data portability. Fewer check the lock-in their vendor has to someone else, which the buyer inherits on the day of signature.

When a model provider changes its model, pricing, or data policy, every vendor built on top of it inherits that change, along with each of their customers.

This distinction separates vendors more sharply than any feature list. Some rent intelligence from a model provider and expose it through their product, while others own and operate models trained on domain-specific data. Both approaches demo well, yet they carry very different risks over a multi-year term.

Whichever approach a vendor takes, find out what happens to your data and your agent configurations if you leave.

 

Building cost control into the architecture

Every question in this guide points to one principle: cost and control hold best when the architecture enforces them and the contract confirms them. Sidetrade built its agentic AI on that principle. SAFE, the Sidetrade Agentic Framework for Enterprise, underpins Aimie IQ, Aimie Agents, and the Customer Agents that teams build in Agent Builder Studio. Every agent on SAFE runs under the same controls, regardless of who builds it.

Sidetrade owns the technology stack. Sidetrade runs its own language models, fine-tuned for Order-to-Cash on open-weight foundations, alongside proprietary predictive models for payment behavior and buyer risk. These models run on Sidetrade’s own compute and private data centers. In practice, it means Sidetrade produces its own tokens rather than buying them. Because the model layer remains Sidetrade’s choice, neither the company nor its customers depend on one model vendor’s roadmap or pricing.

Pricing rests on compute Sidetrade owns. Sidetrade sells Aimie IQ and Aimie Agents on subscription, including a volume of tasks and Sidetrade’s token-equivalent unit. The AI compute it owns has a known cost, which removes customer exposure to third-party per-million-token pricing. Sidetrade also manages consumption to keep AI economics predictable as frontier model pricing moves.

Tokens are spent only where they add value. Not every O2C task needs a large language model. Predicting a payment date or scoring customer risk runs on predictive models, routing and policy checks run as deterministic code, and only language tasks, such as reasoning over a complex dispute, reach the LLM. Deterministic escalation stops an agent from spending compute on a decision that policy reserves for a person.

Governance is built in. SAFE checks each action an accounts receivable AI agent takes against policy before it executes, resolving it to allow, deny, or escalate. When a person must decide, the run pauses with its work intact and resumes from the same point after approval. SAFE records every decision with the rule that applied and the values read, and Sidetrade validates each agent against the OWASP Agentic Top 10 before publication.

Your data stays yours. Sidetrade sends no prompt, document, or customer record to a public model provider or hyperscaler, and never uses customer data to train external models. Its infrastructure holds ISO 27001 and SOC 2 Type 2 certifications.

 

AI agent pricing checklist

Use this list in your next vendor review. Every row should have a written answer before the contract goes to signature.

Question	What a good answer includes	Red flag
What counts as a billable action?	A written definition and a worked example from your own workflow	“It depends on usage”
Do retries count?	Which retries are billed, vendor-caused retries excluded, a loop limit	No loop limit, retries invisible in reports
Who pays for failed work?	How failures are detected, whether failed runs are billed, a definition of success	Per-action billing with no definition of failure
Does unused capacity roll over?	Rollover or pooling rules, what happens at the cap, a known overage rate	Overage “available on request”
How is cost inflation handled?	A committed price, its duration, a cap on increases, model-change terms	AI price fixed only for year one
What governs the agent?	Guardrails before action, full audit trail, human approval, clean recovery	Controls described but not demonstrated
Who owns the intelligence?	Who hosts the models, whether the model can change without changing your price	Your data may train an external or third-party model
Can you see usage live?	Consumption by user, agent, and entity as it happens	Usage visible only on the invoice

 

 

Key takeaways

Agents do variable work, so an agentic AI contract that leaves the unit of work undefined also leaves your budget open. Four points matter most before you sign:

• Define the unit. Get the billable action written into the contract, with a worked example from your own workflow, so you and the vendor count the same thing.
• Settle the edge cases. Agree how the vendor treats retries, failed work, and unused capacity before you sign, because those three decide what a busy quarter-end costs you.
• Fix the price over the term. Request a committed price and its duration, since a vendor that buys its models from a third party cannot control its own input costs.
• Weigh governance and lock-in next to price. Guardrails, an audit trail, human approval, and clear exit terms protect your budget as much as your processes.

For a broader look at how organizations put AI to work in practice, read Sidetrade’s recent whitepaper on operationalizing AI.

---

FAQ