Clients buy a workflow they can check and keep. Scope it, write down who approves what, test it on their own work, then price and hand it over.
Sell one workflow the client already pays people to do. Scope it in writing, give every agent action a named approver, test it on the client’s past work, match pricing to who carries the risk, get a lawyer on the contract, and hand over a pack the client can run without you. Not legal advice.
Agent services tend to stall at the same point in the sales conversation. The proposal promises an AI agent workforce for the client’s operations team, everyone nods, and then someone in procurement asks what exactly they’re buying, who signs off on what it does, and what happens when it gets something wrong. If the answer takes more than a minute, the deal slows down, and usually it should.
What sells, and keeps selling, is narrower: one workflow the client already pays people to do, rebuilt so agents do the preparation and a named person at the client does the deciding. The workforce language can stay in the pitch. The thing you scope, test, price and hand over is the workflow, and every section below is one part of turning that workflow into something a client can buy, check and keep.
Sell the workflow the client already pays people to do, then let the agent workforce grow one workflow at a time.
This guide is for freelancers, consultants and small agencies who can already build with agent tools. If you’re earlier than that, start with our practical guide to building an AI agent and the explainer on assistants, copilots and agents.
There’s a technical reason to sell narrow as well as a commercial one. Anthropic’s engineering guide separates workflows, where models and tools follow predefined code paths, from agents, which direct their own process, and recommends finding the simplest solution possible and adding complexity only when it’s needed.[1] A client paying for a predictable result is usually better served by the predictable design. I’d reach for open-ended autonomy only where the steps genuinely can’t be known in advance, and I’d price that risk separately.
So how do you tell which workflows are worth packaging? Look for work that repeats on a schedule, has a clear input and output, and already has a person who decides what happens next. A weekly competitor digest for a sales team fits. So does triage of inbound enquiries at a professional services firm, the example used through the rest of this guide. “Run our marketing” doesn’t fit until it’s broken into workflows like those.
Once one workflow is live and handed over, the workforce grows workflow by workflow, each with its own scope, approval table and owner. That’s how a client ends up with several agents working for them, which I’d find easier to run than one sprawling system. Managing several agents once they exist is its own skill, covered in our guide to being an agent boss.
The scope is where agent projects quietly go wrong, because builders tend to write it last. The build gets demoed, the client is pleased, and only then does anyone ask what counts as done, which systems the agent touches, or what happens in month three. Writing the scope first forces those questions while they’re still cheap to answer.
A good scope reads like a job description for the workflow, written in the client’s own nouns. Here’s a filled-in one for the enquiry-triage example, which you can adapt line by line.
| Field | Enquiry triage for a professional services firm |
|---|---|
| Workflow | Triage of new enquiries from the website form and the shared inbox. Today a coordinator sorts them by hand each morning. |
| What good looks like | Each enquiry tagged by service line and urgency, with a draft reply waiting for the right account owner by 10am on working days. |
| Inputs it may use | The shared inbox, the web form export, the public services page and an approved FAQ document. Nothing from the CRM. |
| Outputs | A triage sheet, plus draft replies saved as drafts. No message leaves without a person sending it. |
| Must never | Send, delete or forward email. Quote prices. Promise dates. Contact anyone outside the firm. |
| Client owner | Head of client services, who reviews the triage sheet daily for the first month. |
| Acceptance test | Run on a past month of real enquiries, with pass marks agreed in writing first. |
| Out of scope | New channels, CRM integration, other workflows, and platform or model changes requested after sign-off. |
| Changes and support | Changes quoted and tested separately. Support hours and response time set in the contract. |
A Future Factors working template. The values show what a filled-in scope looks like; they are not from a client project.
The two rows that get left blank most often are Must never and Out of scope. The first protects the client’s customers. The second protects you, because “while you’re in there, could it also…” is how a fixed-fee build turns into unpaid months. A specific Out of scope list also becomes the menu for your next proposal.
If you use AI to help draft the proposal around the scope, our guide to writing a business proposal with AI covers that side. Keep the scope itself in your own words, since it ends up attached to the contract.
Every agent service carries an authority question: which actions the agent takes on its own, which need a person at the client to approve, and which it shouldn’t attempt at all. Clients rarely raise it in the sales call. They raise it the first time the agent does something nobody expected, and by then the conversation is about blame.
The security community has a name for getting this wrong. OWASP’s list of top risks for LLM applications includes excessive agency, which it traces to excessive functionality, excessive permissions and excessive autonomy. Its mitigations include limiting tools and permissions to the minimum necessary and requiring a human to approve high-impact actions before they happen.[2] That translates neatly into a table you can put in front of a client.
| Action | Agent may | Approval from | Logged in |
|---|---|---|---|
| Tag service line and urgency | Do it alone | None. Spot-checked weekly by the head of client services | Triage sheet |
| Draft a reply | Do it alone, saved as a draft | Account owner, before anything is sent | Drafts folder |
| Send a reply | Not allowed | Account owner sends it personally | Sent items |
| Mention price, dates or terms | Not allowed | Account owner writes that part | Not applicable |
| Handle a complaint or legal threat | Flags it and drafts nothing | Head of client services, same day | Escalation log |
| Change its own instructions or tools | Not allowed | You, under the change process, with client sign-off | Change log |
A Future Factors working table. Every row needs a named approver or a firm Not allowed before go-live.
Before go-live, every action the agent can take has a named approver at the client, or it’s switched off.
Most agent platforms can enforce this in the build rather than leaving it to good intentions, and I’d choose the tool partly on how well it does that. n8n’s documentation describes a human review step that pauses an agent before a selected tool runs and asks a reviewer to approve or deny the call, through channels that include Slack, Microsoft Teams and email.[3] Microsoft documents multistage approvals in Copilot Studio agent flows, with human and AI approval stages, and labels the capability as preview, which is worth telling a client before you build on it.[4] Whichever platform you use, check its current docs and make the build enforce the table.
An operations lead at the client opens the drafts folder on the first Monday and finds replies waiting, each tagged and ready, none sent. That’s the moment the approval design earns trust, and it shows you whether the client’s owner is actually reviewing.
A demo on tidy sample data proves the agent can work. The client needs to know it works on their mess: the enquiry with three questions in it, the forwarded thread, the message that’s only an attachment. So the acceptance test runs on a batch of the client’s real past work, chosen by the client, with pass marks agreed in writing before you run it. Anthropic’s guide makes a similar point from the builder’s side, recommending extensive testing in sandboxed environments with appropriate guardrails.[1]
For the method behind a good evaluation, our piece on the evals to run before an agent touches real work goes deeper. For a service, the extra step is turning those evals into something both sides sign.
| Check | How it’s run | Pass mark |
|---|---|---|
| Tagging | The agent tags a past month of enquiries; compare with the coordinator’s own tags | A match rate the client sets before the run |
| Draft quality | The head of client services reads a sample of drafts without knowing which came from the agent | Usable with light edits; nothing that would embarrass the firm |
| Must never list | Planted enquiries asking for prices, dates and refunds | Zero breaches |
| Escalation | Planted complaints and legal-sounding threats | All flagged, none answered |
| Bad input | Empty forms, long forwarded chains, attachment-only messages | Fails safely and hands the item to a person |
A Future Factors working test plan. The client sets the numbers; the structure stays the same.
Write the pass marks down before you see the results. Agreeing them afterwards turns a test into a negotiation.
The test is also the moment to put the division of labour in writing.
| What the agent does | What the client still owns | How it gets checked |
|---|---|---|
| Sorts and tags new enquiries | Which service line takes the work | A weekly random sample reviewed by the head of client services |
| Drafts replies | Every word that’s sent, and anything about price or timing | The account owner reads each draft before sending |
| Flags complaints and legal language | The response and any decision about liability | Same-day review of the escalation log |
A Future Factors working view for the enquiry-triage example.
Pricing is where agent services get vague, partly because nobody wants to name a number and partly because the cost of running agents moves. I’m not going to suggest figures here; your costs and your market set those. What I’d do first is pick the model that matches who carries the risk, then price inside it.
| Model | When it fits | Risk to watch |
|---|---|---|
| Fixed fee for the build | Clear scope, stable workflow, acceptance test agreed | Scope creep. Without a firm Out of scope list you absorb every extra request |
| Monthly retainer for running and improving | Inputs change, instructions need tuning, the client wants reporting | Drift into unlimited support. Define the hours or change requests per month |
| Per-outcome | The outcome is countable, clearly attributable and mostly within the agent’s control | Disputes over what counts. Needs a written definition and an audit trail |
| Hybrid: fixed build, then retainer | Many first engagements, in my view | Two agreements that have to stay consistent |
A Future Factors working comparison. It describes trade-offs, not prices, and it isn’t financial advice.
Per-outcome pricing sounds the most modern and is the hardest to administer. It works when both sides would count the same thing the same way. If the client’s staff can reopen a resolved ticket, you’ll spend the relationship arguing about the meter.
Whatever the model, keep your fee separate from platform and model costs. Usage-based charges change, and some platforms meter particular steps: Microsoft notes that AI approval stages in Copilot Studio need Copilot Credits assigned, and that an approval stalls without them.[4] The proposal should say who pays those costs, whose accounts they run on, and what happens if a vendor changes its pricing mid-contract.
A retainer also needs a monthly report that shows it’s earning its keep. Run counts are the easy number to pull, and they only show the agent is switched on. I’d report three layers instead:
I’m not a lawyer, and nothing in this section is legal advice. What follows are questions to take to one, because agent services raise them in ways a standard consulting agreement may not cover. Client data handling, ownership of what you build, and who carries liability when the agent is wrong all need a lawyer and a written agreement, in your jurisdiction and the client’s.
The liability point is easiest to see in a real case. In Moffatt v. Air Canada, a British Columbia tribunal found the airline liable for negligent misrepresentation after its website chatbot gave a customer wrong information about claiming a bereavement fare after travel. It rejected the suggestion that the chatbot was effectively a separate entity responsible for its own actions, and said it makes no difference whether information comes from a static page or a chatbot.[5] The sum involved was small. The principle, that a business answers for what its agent tells people, is why your authority table and your contract need to say the same thing.
| Topic | Question to ask |
|---|---|
| Client data | Which data may the agent process, where is it stored, and which vendors see it? |
| Accounts | Whose accounts do the platforms and models run on, and who owns the logs? |
| Ownership | Who owns the workflow, instructions and any reusable parts you bring from earlier work? |
| Liability | Who answers for an error inside the approved authority, and for one after a client approves it? |
| Warranties | What exactly do you promise about performance? |
| Disclosure | Must people dealing with the agent be told it’s AI? |
| Exit | What happens to data, accounts and your access when the work ends? |
A Future Factors working checklist of questions, not answers. Your lawyer supplies the answers for your situation.
A finance controller reads the draft agreement and stops at the liability clause, because it doesn’t say what happens if the variance commentary misstates a number that later reaches the board. It’s a fair question and a good sign that someone is reading closely. The workable answer comes from the authority table: the agent drafts and the controller signs off, so the agreement should describe responsibility in those same terms.
A service the client can’t run without you is fragile for both sides. They can’t pause it when you’re away, their IT team can’t review it, and every small change becomes a ticket on your desk. A clean handover is also, in my view, one of your most useful sales assets, because it’s what the client shows the next department that wants one.
If the client can’t pause it, check it and change its instructions without you, you’ve sold a dependency rather than a service.
| Item | What it contains | Done when |
|---|---|---|
| Workflow map | Inputs, steps, outputs and every point where a person approves | The client owner can explain it back to you |
| Authority table | The final signed version, matching what the build enforces | Every action has a named approver or is switched off |
| Instructions | Current agent instructions and prompts, with a change log | Stored in the client’s own workspace |
| Accounts and access | Which platforms, who’s an admin, and how to remove your access | The client holds admin rights |
| Off switch | How to pause the workflow, written as plain steps | The client owner has paused and restarted it once with you watching |
| Weekly check | What to look at and what a bad week looks like | The client has run the first check themselves |
| Support terms | Hours, response times, what’s covered and what’s a change request | Signed |
A Future Factors working checklist for handing an agent workflow to a client.
OWASP’s advice to keep permissions to the minimum necessary applies to you as well as to the agent, so remove any access you no longer need once support ends.[2]
The handover session is training, and it’s worth treating it that way. Training builds the client team’s capability to run the workflow. Workflow design, which you’ve already done, gives that capability somewhere to be used. Reinforcement comes from the weekly check and an owner who actually does it, and adoption is what you see a couple of months later, when the workflow is simply how enquiries get handled. Skip the reinforcement and even a well-built service tends to fade.
Who sits in the session changes what it covers. I’d run it in this order:
Three short sessions usually land better than one long one.
The fastest way to lose a client’s trust is to promise what the agent can’t guarantee, and the riskiest claims are the ones that read most like sales copy. The FTC’s Operation AI Comply sweep in 2024 is a useful warning. One case concerned DoNotPay, which marketed itself as “the world’s first robot lawyer” and which, the FTC alleged, hadn’t tested whether its output matched a human lawyer’s work; it agreed to pay $193,000 to settle.[6] Other cases in the same sweep targeted schemes promising AI-powered passive income.
None of that means you can’t sell with confidence. It means each claim in the proposal should point at something you can show: the acceptance test, the authority table, the handover pack. Lina Khan, then the FTC’s chair, put the wider point plainly in the announcement, saying there is no AI exemption from the laws on the books.[6]
| Don’t promise | Say instead |
|---|---|
| “Replaces your team” | “Prepares the work so your team spends its time on the decisions” |
| “Fully autonomous, no oversight needed” | “Runs inside the approval table we agree, with a named owner on your side” |
| “Saves a set number of hours a week”, before any test | “We’ll measure time spent before and after, on your own work, during the pilot” |
| “Error-free” or “100% accurate” | “Meets the pass marks in the acceptance test and hands over what it can’t handle” |
| “Guaranteed return” or any income figure | “Here’s what we’ll report each month so you can judge it” |
A Future Factors working list of proposal language. Have your lawyer review the final wording.
A marketing lead forwards the proposal to the CFO with one line highlighted: the time-savings estimate. If it came from your test on their own data, it survives the question. If it came from a vendor’s case study, it often doesn’t.
You can learn to build and sell these services on your own. Structured training shortens that curve, and it builds the same habits across a whole team, yours or the client’s, instead of leaving everything with one enthusiastic builder; that’s the work Future Factors does through our AI courses and corporate workshops.
If you’re putting together a first offer this week, start smaller than feels impressive. Pick one workflow at a client you already know, fill in the scope with a real Must never row and a real Out of scope row, draft the authority table, and agree the acceptance test before you build. Price the build as a fixed fee and the running as a retainer, and book time with a lawyer before the agreement goes out.
The second workflow is much easier to sell once the first one has a handover pack the client actually uses.
Not necessarily. Several agent platforms are visual builders, so the build itself may need little or no code. The parts clients pay for, scoping, approvals, testing and handover, aren’t coding work at all. Where an integration needs code, scope and price it separately.
As many as one workflow needs, which is often one or two. Count agents by what the workflow requires rather than by what sounds impressive in the pitch. Each extra agent adds instructions to maintain and something else to monitor.
For anything that touches the client’s data, the usual safer default is that the client owns the accounts and grants you access they can remove. That keeps logs and data with them and makes the exit clean. Confirm the arrangement with your lawyer and write it into the agreement.
Widen authority one action at a time, after a logged period with no breaches of the Must never list, and record the change in the signed authority table. I’d keep anything that mentions price, dates, terms or complaints behind approval regardless, because those carry the client’s liability.
Only if your agreement says you can. Decide before the first engagement which parts are your reusable components and which are the client’s configuration, data and instructions, and keep them separate in the build. That split is a question for your lawyer, not a default to assume.
I checked these sources on October 21, 2026: Anthropic’s engineering guide to building effective agents, OWASP’s entry on excessive agency, n8n’s documentation on human review for agent tools, Microsoft Learn’s page on advanced approvals in Copilot Studio agent flows, the Moffatt v. Air Canada decision from British Columbia’s Civil Resolution Tribunal, and the FTC’s announcement of Operation AI Comply. Platform features change, so check current docs. I did not test these platforms hands-on. I left out prices, income figures and AI disclosure timelines because I couldn’t confirm them from a primary source. The scope template, approval table, test plan, pricing comparison and handover checklist are Future Factors working methods, not research-validated models, and the scenes are illustrations, not client stories. This article is not legal advice.