AI AR implementation guide: from pilot to production

Implementing an AI AR agent works best as a staged path, not a switch you flip. You connect the agent to your ERP and accounting stack, set the policies and approval thresholds that bound what it can do, run a supervised pilot on a slice of the ledger, then widen its authority as the results earn trust. Most teams go from kickoff to production in 8 to 12 weeks.

The goal is a live agent that runs collections, cash application, and dispute work across the whole ledger and is accountable for cash and DSO, with your team supervising by exception. The risk to manage is moving too fast on trust before the data and the metrics support it. This guide walks the sequence that gets you to real autonomy without skipping the steps that make it safe.

Prerequisites and data readiness

Start by checking that the data an agent needs to act actually exists and is roughly accurate. An agent reasons over the state of each account, so its decisions are only as good as what it can see.

The essentials:

• Open invoices with due dates, amounts, and terms, current in the ERP.
• Customer contacts with valid email addresses for the people who handle payment.
• Payment history going back far enough to learn each customer's pattern, ideally a year or more.
• Aging that reflects reality, not a stale month-end export.

You do not need perfect data, and you should not delay the project chasing it. Most ledgers have what an agent needs. The pilot itself is the best tool for finding the gaps that matter, a customer segment with missing contacts, a class of invoices that never get short-pay reasons coded, because it shows you which gaps actually block action versus which are cosmetic.

A quick readiness check before kickoff saves weeks later. Confirm three things: that your aging ties to the general ledger so the agent and your books agree on what is open, that you have a current email contact for the payment decision-maker on the accounts in scope, and that historical payments are recorded against specific invoices rather than lumped at the account level. The first keeps the agent's view honest, the second is what lets it actually reach customers, and the third is what lets it learn each customer's pattern. If any of these is weak in a segment, exclude that segment from the pilot rather than letting it drag the results down.

Connecting your ERP and accounting stack

The agent has to read from and write to your systems of record, or it cannot do the work. Reading the ledger is not enough. To collect, it needs to send messages, log promises, and update invoice status. To apply cash, it needs to post matches back to the ERP.

Map the integration before you start. List every system the agent touches: the ERP or accounting platform for invoices and cash, email and any SMS channel for outreach, your customer or contact data, and any payment portal. Confirm the agent can both read and write where it needs to, and decide which writes require a human approval at first. A read-only integration produces a smarter dashboard, not an agent. The whole point is that it acts, so wiring the write path correctly is the part that earns the return. This is also where many ERP-bound AR projects stall, so treat it as the critical step.

Setting policies and approval thresholds

Before the agent does anything, define the boundaries it operates inside. This is what makes autonomy safe and what lets you sleep at night while software contacts your customers.

Policies to set up front:

• Action limits. What the agent may do on its own versus what needs sign-off, by invoice amount and account type.
• Approval thresholds. The dollar figure or action class above which a human approves before the agent acts. A reminder on a 2,000 dollar invoice is routine; a payment-plan offer on a 200,000 dollar balance is not.
• Tone and cadence rules. How firm outreach can get and how often a customer can be contacted, so the agent never over-chases a relationship.
• No-touch lists. Accounts the agent must leave to a human entirely, such as your largest strategic customers or anyone in active negotiation.

Set these conservatively to start. You can always widen them. Walking back an over-aggressive rule after the agent has emailed a key account is the harder direction.

Running a supervised pilot

Do not launch across the whole ledger on day one. Pick a representative segment, often a band of mid-size accounts where the volume is real but no single relationship is make-or-break, and run the agent there in supervised mode.

Supervised means the agent does the reasoning and drafts the action, but a person approves before it executes. Your collector sees the proposed reminder, the proposed cash match, the proposed dispute routing, and approves, edits, or rejects each one. This does two things. It catches mistakes before they reach a customer, and it gives you a live measure of how often the agent is right, which is the data you need to justify turning up autonomy.

Run the pilot for four to six weeks. Track the approval rate, the edits people make and why, and whether the segment's collection results improve. A rising approval rate that settles high, the team approving the agent's proposals with few edits, is the signal the agent has learned your book. This supervised stage is the foundation of keeping a human in the loop as autonomy grows.

Pay attention to the edits, not just the rejections, because they are the most useful signal you get. If collectors keep softening the tone on a particular customer tier, your cadence rules are too aggressive for that tier and should be adjusted. If they keep correcting which invoice a payment matched to, your remittance handling needs work before you trust cash application to run unsupervised. Treat the pilot as a tuning loop, not a pass-fail test. Each edit tells you exactly which policy or which data input to fix, and fixing it is what raises the approval rate toward the level that justifies turning autonomy up.

Expanding the agent's autonomy safely

Once the pilot proves out, raise autonomy in steps rather than all at once. The mechanism is the approval threshold you already set. You lower the bar for what the agent can do unsupervised.

A sensible progression:

1. Auto-send routine, low-risk actions. Standard reminders on smaller invoices go out without per-message approval, since the pilot showed these are almost always approved as drafted.
2. Raise the dollar limit. As confidence holds, increase the invoice size the agent handles autonomously.
3. Add action types. Let the agent log promises, send statements, and apply clean cash matches on its own, keeping disputes and large write-offs gated.
4. Widen the segment. Extend from the pilot band to more of the ledger, monitoring that results hold as volume grows.

At each step, watch the metrics before taking the next one. If results stay strong and exceptions stay rare, keep going. If something drifts, hold and investigate. Trust is earned in increments, and the threshold model lets you grant it in increments.

Measuring success and going to production

Define success before you start so you are not arguing about it later. The metrics that matter are the outcomes the agent is accountable for: DSO, cash recovered, and the share of routine work the agent now handles without a person. Track these against a baseline you captured before the pilot. Pair them with the standard AR metrics, collection effectiveness index and the aging mix, so you can see not just that DSO moved but why.

Going to production is less a single launch than the point where the agent runs the bulk of the ledger autonomously and your team supervises by exception. The work has inverted. Instead of collectors sending reminders and the system reporting, the agent does the volume and the people handle the cases it escalates: a strategic account pushing back, a complex dispute, a judgment call on a struggling customer.

Keep the audit trail central even after go-live. Every action the agent took, with its reasoning, stays reviewable, which is what keeps the finance team and your auditors comfortable as the agent's authority grows.

How Rex goes from pilot to production

Rex is an autonomous AR agent built to run exactly this path. It connects to your ERP and accounting stack, reads each account, and acts across email, SMS, and the ledger within the policy limits and approval thresholds you set. You start it supervised on a segment, watch the approval rate climb as it learns your book, then raise its autonomy in steps until it runs the routine volume on its own and escalates only the cases that need a person.

In production, Rex works the whole ledger continuously, is accountable for DSO and cash recovered, and logs every action with its reasoning for review. Your team moves from sending reminders to supervising an agent and handling the exceptions it surfaces.

See how Rex takes AR from a supervised pilot to a production agent that owns the outcome.