AI implementation consulting

AI implementation consultant: the job between the demo and the workflow that actually runs

Updated 9 September 2026 9 min read

Short answer

An AI implementation consultant takes an AI use case a company has already chosen — a tool that was bought, a pilot that impressed in a demo, a process the strategy deck says to automate — and gets it running inside real operations: integrated with the systems that hold the data, gated with approvals where mistakes are expensive, logged, measured, and adopted by the team that has to live with it. This is a different job from deciding what to do with AI (strategy) or finding which processes are worth automating (audit). Expect three deliverables: a readiness check that names what will block the rollout, a working integration on your existing stack, and a runbook plus trained owners so the thing survives contact with staff turnover. If your "implementation" so far is a subscription being paid and a demo nobody uses, this is the missing step.

Readiness check names the blockers — access, data quality, undefined exceptions — before anything is built
Integrated with your actual systems: CRM, helpdesk, accounting, document storage
Runs in shadow mode against real data until its error rate is measured, then goes live
Ends with a runbook, a named owner, and a before-and-after number — not a slide deck

Book a readiness check Estimate the payback first

Typical clients: 10–300 person companies with a chosen AI use case — bought, piloted, or mandated — that is not yet running in production.

The five readiness tests we run before implementing anything

Published because failed AI rollouts are rarely killed by the model — they are killed by one of these five, and every one of them is checkable before money is spent on a build.

01Ownership: one named person wants this live and will answer questions within a day. A rollout owned by "the team" is owned by nobody and stalls at the first ambiguity.
02Success metric: there is a number that defines working — minutes saved, error rate, turnaround time — and its current value is measured before the build starts. No baseline, no proof, no budget for the next one.
03Access: the systems the AI must read from and write to have an API, an export, or an inbox, and someone can grant credentials this month. Access delays kill more rollouts than technical problems do.
04Exception shape: everyone agrees where the cases the AI cannot handle should land, and who looks at that queue. An implementation without a defined exception path is a demo with a production URL.
05Data floor: the inputs are good enough to act on. If the CRM fields the AI needs are empty half the time, the project is a data-hygiene project first, and we say so instead of building on sand.

Why most AI pilots never become production systems

The demo works. The subscription is active. And six months later the team still does the work by hand. The gap has consistent causes.

The pilot was built on hand-fed data

In the demo, someone pasted a clean example in and the model shone. In production, the input arrives as a forwarded email chain with an attachment in the wrong format. The work of implementation is mostly plumbing and edge cases — the unglamorous 80% that the demo skipped.

Nobody wired it into the systems of record

An AI that produces an answer nobody transfers into the CRM has added a step, not removed one. Until the output lands where the team already works — the ticket, the record, the ledger — with logging and a way to undo it, adoption is a favour people do you for two weeks.

Shadow adoption already happened, without controls

While the official pilot stalled, the team quietly started pasting customer data into personal chatbot accounts. The fix is not a ban — it is implementing a sanctioned path that is faster than the workaround, with access controls and logging, so the convenient route and the safe route are the same route.

How the engagement runs

Readiness check first, then one use case implemented end to end. You can stop after the check and act on it with your own team or the vendor's.

01
Readiness check
One to two weeks against the five tests above: who owns it, what number defines success, what access exists, where exceptions land, whether the data clears the floor. Each blocker gets a named fix and an owner.
You get A written readiness report: blockers, fixes, and a go or fix-first recommendation.
02
Integration design
Where the AI step sits in the real workflow: what triggers it, which systems it reads, where its output lands, which actions need a human approval, and what gets logged. Designed around your stack, not around a preferred vendor.
You get An integration design with approval gates and the rollback path marked.
03
Build and shadow run
The implementation runs against live data in shadow mode: it does the work, a person still does the work, and the two are compared. Disagreements are triaged weekly — some are model errors to fix, and some turn out to be the humans being inconsistent, which is its own finding.
You get A measured error rate on real data, and a tuned flow that earned its numbers.
04
Rollout and adoption
Go-live is a team change, not a deploy: the SOP is rewritten around the new flow, the owners are trained on the exception queue, and the old manual path is retired on a date rather than left running forever in parallel.
You get A live workflow, an updated SOP, and a team that knows who owns what.
05
Measure and hand over
Four weeks after go-live we compare against the baseline from step one and write down what actually changed. You get the source, the credentials, and the runbook. Some clients take the next use case in-house from here; others keep us on retainer.
You get A before-and-after report, the runbook, and a decision on what happens next.

What the stalled-pilot maths actually looks like

A model, not a case study — run it with your own numbers. This is the arithmetic of the gap between a pilot and a production rollout, and it is usually larger than the implementation fee.

A 40-person company chose an AI step for supplier-invoice intake: extract, code, and post to accounting with approval. The pilot worked on ten hand-picked PDFs in a demo. Getting it to production stalled in the gap between "works in a demo" and "wired into the mailbox, the ERP, and the approval chain".

Manual cost of the process while the rollout stalls: $785 / month
Months stalled since the pilot impressed everyone: 6
Manual cost paid during the stall: $4,710
Internal DIY estimate: ops lead's hours to wire it up: ~80 h
Loaded cost of those hours: $4,400
Realistic DIY calendar time at 3 h/week spare capacity: ~6 months
Manual cost paid during those further months: $4,710
DIY total: hours plus the waiting: ~$9,110
Implementation engagement, fixed fee: from $1,900
Calendar time to production, including shadow mode: 6–8 weeks

The expensive part of a stalled pilot is not the subscription — it is the manual work that keeps being paid for while the rollout waits for someone's spare hours. In this model the do-it-internally path costs roughly $9,000 once the waiting is priced, against a fixed implementation fee from $1,900. The arithmetic flips when your team genuinely has the hours and the integration is simple: one clean system, native connectors, no approval chain. Then you should not hire us, and the readiness check will say so.

What an AI implementation consultant should and should not sell you

Implementation is a bounded job. Being explicit about the boundary is the fastest way to tell it apart from an open-ended transformation programme.

In scope

Readiness assessment: ownership, metric, access, exceptions, data floor
Integration with the systems of record — CRM, helpdesk, ERP, document storage, mailboxes
Approval gates, exception queues, logging, and a rollback path
Shadow-mode measurement against real data before go-live
SOP rewrite, owner training, and retirement of the parallel manual path
Before-and-after measurement against the baseline

Not in scope

Deciding your AI strategy — that comes before this, and is a different engagement
Multi-month transformation programmes with no shipped workflow
Replacing your CRM, ERP, or accounting system to make a tool fit
Custom model training that needs a data science team you do not have
Implementing on top of data that fails the floor test — the data gets fixed first, or we stop

What it costs — and what the same work costs elsewhere

Published in full, next to the market rate, because implementation is where AI budgets quietly triple. We are deliberately at the bottom of the market for this work, and the reasons are listed below the table.

Readiness check

$490

Typical market rate: $2,500–8,000

A tool was bought or a pilot impressed, and the rollout has been "next quarter" twice.

The five readiness tests, run against one use case
Named blockers, each with a fix and an owner
Baseline measurement of the manual process
Credited in full against the implementation

Implementation

from $1,900

Typical market rate: $6,000–15,000

The use case is chosen and you want it live, measured, and owned by your team.

One use case, integrated end to end
Approval gates, exception queue, logging
Shadow-mode run until the error rate is known
SOP, runbook, and two weeks of post-launch tuning

Retainer

$690 / month

Typical market rate: $3,000–8,000 / month

The first use case is live and the roadmap has more where it came from.

Monitoring and incident response
One new or reworked implementation per month
Integration maintenance as your tools change
Cancel with 30 days notice

The implementation price is a floor, not an average: one AI step against one system with clean inputs lands near $1,900; a flow crossing three systems with an approval chain and messy source documents lands higher. You get a fixed number in writing after the readiness check, before any build starts, and the $490 check comes off it in full.

Why this costs a fifth of the agency price

Cheap implementation usually means junior people learning integration on your systems. That is not what is happening here, so it is worth being specific about where the difference comes from.

No sales layer

You talk to the person who will do the integration, on the first call and every call after. Nobody's pre-sales salary is being recovered from your invoice.

The readiness check is productised

Five tests, same intake, same deliverable every time. Agencies bill this as bespoke discovery because for them it is — the checklist already exists here, so you are not funding its invention.

We reuse integration patterns

Mailbox-to-ERP, helpdesk-to-CRM, document-to-ledger: the tenth one takes a fraction of the time the first did, and we price the tenth. Your policies are specific; the plumbing rarely is.

No vendor allegiance

We resell no licences and take no commissions, so the recommendation can be "the tool you already bought is fine, it was never wired in" — which is, more often than this market admits, the truth.

Implementation consultant, vendor professional services, or internal IT

All three can get a use case live. They fail in different places, and the honest answer depends on how many systems the workflow crosses and whose interests you want in the room.

Criterion	Implementation consultant	Vendor professional services	Internal IT / ops team
Best when	The workflow crosses systems and needs approval gates, exceptions, and measurement	The use case lives entirely inside that vendor's product	The integration is simple and your team genuinely has the hours this quarter
Whose interest drives the design	Yours — tool-agnostic, paid for the outcome	The vendor's — every problem is solved with more of their product	Yours, competing with everything else on their backlog
Time to production	6–8 weeks including shadow mode	2–6 weeks inside their product's walls	3–9 months of spare-hours progress
Cost shape	Fixed check, then fixed fee per use case	Day rates, often bundled into the contract	Invisible — paid in delay and opportunity cost
Main risk	Knowledge leaves at handover — mitigated by the runbook and trained owners	Lock-in deepens with every workflow built inside the walls	The rollout stalls the moment anything urgent lands on the same people

Which of these you actually need

Read down to the line that matches your situation. Two of the five answers do not involve hiring us.

A tool is bought or a pilot worked, and it is still not running in production
This page is for you. Start with the readiness check — it names the blockers in two weeks, and it is credited against the implementation.
You have not yet decided where AI belongs in the company
That is strategy, not implementation, and doing it backwards is how tools get bought and shelved. Start with the AI strategy consultant engagement instead.
You know something is manual and expensive but have not picked the process
That is an audit question. Start with the process audit — it produces the ranked shortlist that implementation then executes.
The use case lives entirely inside one product you already pay for
Use the vendor's professional services or their setup guides first. Bring in an outside implementer only if the workflow has to cross into systems the vendor does not touch.
Your team has the skills and the spare hours, and the integration is one clean system
Do it in-house. Take the five readiness tests above, run them yourself, and spend the fee on something harder.

A one-week readiness test you can run before hiring anyone

This is our readiness check, done manually on your own use case. If it comes back clean, your team may not need us; if it names three blockers, you have found the actual project.

Day 1Write one sentence: what the AI should do, triggered by what, producing what, landing where. If the sentence cannot be written, the use case is not chosen yet — stop here and fix that first.
Day 2Name the owner. One person who wants it live and will answer questions within a day. Write their name down; "the ops team" does not count.
Day 3Define the success number and measure its current value: minutes per instance, error rate, turnaround time. Use real counts from last month, not estimates.
Day 4List every system the flow must read from or write to. For each, check: is there an API, an export, or an inbox — and who can grant credentials this month?
Day 5Decide where exceptions land. Which queue, which person, what happens if it fills up. Write it down and get the named person to agree.
Day 6Pull twenty real, recent inputs — actual emails, actual documents, actual records. Count how many are complete and readable. Below about 80%, you have a data project first.
Day 7Tally the blockers from days 2–6. Zero: implement in-house. One or two: fix them, then decide. Three or more: the pilot was the easy part, and the gap is the real work.

If the manual process costs more than about $500 a month and the test surfaced blockers your team cannot clear this quarter, an implementation engagement pays for itself in the waiting time alone. If the test came back clean, run the rollout in-house and spend the fee on the next use case — that is a legitimate outcome and we will say so on the call.

Looking for a different starting point?

Frequently asked questions

What does an AI implementation consultant actually do?

Takes a chosen AI use case and makes it operational: integrates it with the systems that hold the data, adds approval gates and exception routing, runs it in shadow mode against real data until the error rate is known, rewrites the SOP around it, trains the owners, and measures the result against a baseline. It is the execution half of AI adoption — distinct from strategy (deciding what to do) and from an audit (finding which processes are worth it).

How is this different from an AI strategy consultant?

Sequence. Strategy decides where AI belongs across the company and produces a roadmap; implementation takes one item off that roadmap and gets it running in production. Buying implementation before the decision is made is how companies end up with tools nobody uses; buying strategy twice is how they end up with two decks and no workflow. If you are unsure which you need, the test is one question: can you name the specific use case? If yes, you need implementation.

How much does AI implementation cost?

Our readiness check is $490 and is credited in full against the implementation. Getting one use case to production starts at $1,900, and ongoing support is $690 a month, cancellable with 30 days notice. Agencies typically charge $2,500–8,000 for the assessment and $6,000–15,000 per rollout. The larger hidden cost is usually the stall itself: every month a pilot sits unimplemented, the manual process it was meant to replace keeps being paid for.

We already bought an AI tool. Can you implement that instead of selling us another one?

Yes, and this is the most common engagement shape. We take no vendor commissions and resell nothing, so there is no incentive to swap your tool for a preferred one. A meaningful share of readiness checks conclude that the tool you have is fine and was simply never wired into the mailbox, the CRM, or the approval chain — that wiring is the actual project.

Why do AI pilots fail to reach production?

Almost never because of the model. The consistent causes: the pilot ran on hand-picked clean inputs while production inputs are messy; the output was never wired into the system of record, so using it meant extra work; nobody owned the rollout; there was no baseline, so nobody could prove it worked; and the exceptions had nowhere to land. All five are checkable in advance, which is what the readiness check is.

What is shadow mode and why do you insist on it?

The implementation does the work while a person still does the work, and the two are compared for several weeks. It is the only honest way to learn the real error rate before customers or ledgers depend on the flow. It also regularly produces an uncomfortable finding: the humans disagree with each other as often as the AI disagrees with the humans, which means the process rules needed writing down first.

How long does an implementation take?

The readiness check takes one to two weeks. A typical implementation is live in six to eight weeks from there, of which about four are shadow-mode measurement. The calendar is dominated by two things we ask for early: credentials to the systems involved, and an hour a week from the named owner. Where those arrive late, the timeline moves with them.

What if our data is not good enough?

Then the readiness check says so, with specifics: which fields are empty, which documents are unreadable, what share of inputs fails the floor. Sometimes the fix is small — a required field on a form, a naming convention for attachments. When it is large, the honest sequence is a data-hygiene project first, and building AI on top of bad data is the one job we will decline rather than deliver badly.

Do you work with our internal IT team or replace them?

With them, and deliberately so — they own the systems we integrate with and they inherit the result. The usual division: we design the flow, build the AI steps and the integration, and write the runbook; internal IT grants access, reviews the security posture, and takes over operations at handover. The runbook is written for them, not for us.

Which tools and models do you implement on?

Whatever the use case needs: your existing AI tool where one was bought, n8n, Make, or direct API integrations for orchestration, and current large language models for the steps that need judgement — extraction, classification, drafting. Tool choice follows the workflow, and we take no commissions, so the recommendation is not for sale.

Who owns the implementation when the engagement ends?

You do. The flows live in your accounts, the credentials are yours, and the documentation is written for whoever inherits the system. Nothing is held hostage to keep a retainer alive — the retainer exists for companies that want a steady cadence of new implementations, not as a ransom on the first one.

Do you sign NDAs and work with sensitive data?

Yes. NDA before the intake call if you prefer, and a DPA before any work touching personal or financial data. Where processing must stay in a specific jurisdiction or inside specific vendors, we design for that constraint upfront — retrofitting compliance onto a live workflow usually means rebuilding it.

Next step

Start with the readiness check

Tell us what was bought or piloted and where it stalled. We will come back with which of the five blockers we suspect, and what the check would confirm.