AI-Constituted Services: The Business That Can't Exist Without the Machine

Why "find an AI use case" keeps producing trinkets — and the counterfactual test, the hunting ground and the build architecture for services that only exist because a machine carries the breadth.

Scott Farrell · LeverageAI · August 2026

The trinket problem

Every "find an AI use case" workshop I've seen ends the same way. The current processes go up on the wall — inspection cycles, reporting, service desk, the automation backlog — and the room nominates steps to speed up. A copilot here, a summariser there, a chatbot for the customers. Small, plausible, fundable. Trinkets.

Then everyone wonders why the portfolio underwhelms. The measured answer is that it mostly does: MIT's NANDA initiative found about 95% of generative AI pilots deliver no measurable P&L impact, and placed the cause not in the models but in a "learning gap" and flawed enterprise integration¹. S&P Global found the share of companies abandoning most of their AI initiatives jumped from 17% to 42% in a single year, with the average organisation scrapping 46% of proofs-of-concept before production². RAND puts AI project failure above 80% — twice the rate of ordinary IT projects — and names the leading root cause as misunderstanding what problem needs to be solved³.

Notice what those numbers are not saying. They are not saying the machines don't work. They are saying organisations keep pointing working machines at the wrong target.

Here's my blunter version, from watching consultancies hunt for AI revenue: everyone's trying to automate the existing workflow. In every case I've seen where AI does useful work, it's doing something you're not doing. Changing the pattern. I call the failure mode horse optimisation — strapping intelligence to the current process and asking it to trot faster — and the question "where can AI help?" almost guarantees it, because the question contains the old workflow inside it. You inventory what you already do; you nominate steps to accelerate; you get a faster horse and a shelf of trinkets⁴.

The firms selling those trinkets are exposed too. They're asking how to sell AI through their services. The larger opportunity is to rebuild the service through AI — and there is now a working example of what that looks like, which this article walks through in detail. But first the category needs a name, because the thing that makes it different is invisible in the language most firms are using.

Three kinds of AI service — and the test that separates them

"AI-native" has stopped meaning anything. Any vendor can bolt a model onto an existing product and claim the label. What's needed is a classification you can falsify. Here is the one I use:

The test is a thought experiment you can run against any offer, including your own. Remove the AI. Does the same offer still exist, only more slowly? Then it's AI-enabled — a productivity story. Does the price point break, while the service itself survives? AI-dependent — a margin story. Or does the promise itself become absurd — the fixed price against unmeasured complexity, the full coverage instead of sampling, the evidence chain behind every finding? Then the service is AI-constituted, and you are looking at a genuinely new commercial object:

AI does not improve the service. AI permits the service to exist.

Run the test on a real case and the categories stop being abstract. Klarna's AI assistant famously handled two-thirds of customer-service chats in its first month — the equivalent work of 700 full-time agents, with an estimated US$40 million profit improvement⁵. Impressive, and genuinely valuable. But apply the counterfactual: remove the AI and customer service still exists; it just costs more. That's substitution — AI-dependent at best. And the category predicts what happened next: by May 2025 Klarna was recruiting humans back into service, its CEO conceding that "cost unfortunately seems to have been a too predominant evaluation factor… what you end up having is lower quality"⁶. Cost-substitution offers can snap back. A constituted offer can't snap back, because there is nothing to snap back to — the pre-AI version of the service never existed.

The distinction also explains a strange property of the strongest AI products: the customer often doesn't need to care that AI is involved. Surface embedding — the visible copilot, the chat widget — is marketing. Constitutive embedding is economics: the AI sits inside the production machinery, and what the client experiences is a fixed price where pricing was previously dangerous, comprehensive analysis where consultants previously sampled, and evidence instead of a confident opinion. The machine may be invisible to the buyer and indispensable to the producer.

The hunting ground: services that were never rational to sell

If the counterfactual test tells you what an AI-constituted service is, the next question is where to find one. Not in your current process map — that's the horse paddock. The hunting ground is the set of economically suppressed services: valuable work absent from every catalogue, not because clients wouldn't pay for it, but because the cognition, coordination or uncertainty cost made it commercially irrational to promise.

This is the service-market face of what I've called Version 3 thinking: the first version of AI value automates existing tasks, the second applies ten to a hundred times more analysis to problems you already have, and the third — the frontier — makes entirely new categories of work rational to attempt for the first time⁷. The diagnostic question changes accordingly. Instead of "where can AI help?", ask:

What important thinking do you currently not perform because it would require too many experts, too much coordination or too much time?⁸

Every industry has these absences. The assessment that would require reading hundreds of workbooks. The line-by-line reconciliation of business requirements against an existing systems estate. The tailored decision package for every significant customer rather than the top three accounts. The deep review previously reserved for whoever shouted loudest. These services are missing from the market for one reason: under human-labour economics, the breadth was unaffordable and the complexity unpriceable.

Professional services carry a particularly expensive specimen: the statement of work. When I ran my own consulting company, writing SOWs was so bad I had to write them all myself — I couldn't hand them to sales staff or senior technical staff, because it would take too long and they'd be wrong. It limits how much work you can write up, and how much you can be bothered writing up. The underlying reason is structural: the senior person writing an SOW is manually joining the client request, the account history, the firm's capability, prior architectures, commercial risk and their own scar tissue — context the firm's systems don't reliably hold. The senior SOW author is the join algorithm. That's why one partner quotes $200K and another quotes $600K for the same request: each assembled a different world, and there's no explicit substrate against which either answer can be tested. Economically, a large share of "business development" is unpriced cognition spent reconstructing the same commercial object from scratch.

Now look at the base rates that unpriced join produces downstream. PMI's global project data shows only 62% of projects completing within their original budget and roughly a third experiencing scope creep⁹. The risk in fixed-price work is usually not building the solution. It is discovering too late that the quoted scope was based on an incomplete understanding. Which is precisely why sane consultancies retreat to time-and-materials, vague discovery phases and caveated estimates — the suppressed service stays suppressed.

The market is already punishing that equilibrium. KPMG Australia reported consulting revenues down 18% in FY25, citing reduced government use of consultants and a rebalancing toward technology and AI¹⁰, while BCG grew to US$14.4 billion with AI- and tech-focused services above 40% of revenue, on 25% year-over-year growth in AI services¹¹. McKinsey now takes about a quarter of its global fees through outcome-based arrangements, with its leadership stating plainly that "many of the fundamentals of the professional services model are coming under challenge"¹². Industry commentary goes further, calling the hourly-billing pyramid "fundamentally incompatible" with AI-era productivity¹³. Advice got cheap. Verification did not — and the firms growing are the ones selling verified outcomes rather than narrative¹⁴. Venture capital has noticed the same shift from the other side, branding it "service-as-software" and sizing the global services market it opens at US$4.6 trillion¹⁵. What that conversation lacks is a classification and a build recipe. Those are what the rest of this article supplies.

The build move: Cognitive Workflow Recomposition

Suppose you've found a suppressed service — an outcome clients would buy if anyone could deliver it economically. How do you build the machine that constitutes it? Not by automating the current workflow, because for a suppressed service there usually isn't one; and where a workflow does exist, it was never a purposeful design. The old workflow was the residue of limitations: software couldn't understand messy input, semantic matching was too expensive, specialists couldn't inspect everything, so humans carried ambiguity between applications. Once those constraints lift, there is no reason to reproduce the old sequence⁴.

The move I use — the one every worked example in this article follows — is Cognitive Workflow Recomposition:

Rebuild a business outcome as evidence-bearing units of cognition and authority; assign each unit to deterministic software, AI or a human; then recompose them through a governed application and a learning substrate.

In practice the recomposed workflow almost always takes the same seven-stage shape:

Each placement is deliberate, and the placement is the product. Deterministic code owns the binding work: identity, decomposition into line items, evidence pointers, mandatory checks, workflow state, approvals, and the final compilation of accepted results. AI owns the bounded semantic work: interpreting messy language, judging whether two differently-worded things mean the same, flagging ambiguity, proposing matches — the work where enumerating every rule and edge case would be futile. Humans own consequences: accepting or rejecting material mappings, resolving genuine ambiguity, authorising anything that binds the organisation. The compressed rule: AI handles messy perception; code evaluates the resulting structure; people own what happens next.

Two design choices in that stack deserve emphasis, because they're what most AI builds get wrong.

The line items are the point

A giant model answer — "here is the correct project scope" — is impossible to inspect, partially accept, correct or govern. Decomposed into line items, every judgment gets a stable identity, a bounded question, a minimum evidence set, a proposed result with sources, a confidence or unresolved status, a human disposition and an accountable owner. That converts a vague intelligent answer into a decision surface — turn the complex problem into line items, with a brain that helps assess the line items. It's also what makes the machinery auditable: you can ask, of any single finding, what evidence supported it, who decided it, and what it caused downstream.

The AI runs in bounded, reviewable positions

The model never holds the pen on the deliverable and never improvises against production systems. It proposes within validated bounds — its citations checked by code, its outputs parked as proposals until disposed. Where the raw environment is too private or too messy for a model, AI is used in a second form: at design time, writing the deterministic extractors and tests that will run where the model may not. There's a live form of AI interpreting evidence and proposing judgments — and a solidified form of AI in the deterministic code it authored, reviewed and tested like any other software. That routing — reviewable artefacts through existing software governance, rather than live AI decisions through governance you'd have to invent — is what lets these systems pass security review in weeks instead of quarters¹⁶.

The specimen: a fixed-price Data Readiness Review

Theory earns nothing without a working instance, so here is mine — one production-shaped specimen, honestly labelled. FDE BI is a deployed evidence workbench I built for data consulting: it reads a Power BI estate, treats the client's business spreadsheets as declarations of a target architecture, and compiles the difference into an evidence-backed readiness decision and a scoped next engagement. The retained runs use synthetic fixtures — this is a demonstrated architecture, not a surveyed market — but every number below comes from the system's retained records, not a slide.

Walk it through the seven stages. Deterministic sensors inventory the estate and perform the spreadsheet archaeology — extracting formulas, structure, tables, connections and lineage while keeping raw business values out of the model's sight. (Vendor tooling now supports exactly this shape of read: Microsoft's own scanner APIs catalogue tables, columns, measures and DAX expressions as governed metadata, without touching row-level data¹⁷.) The extracted evidence is compiled into a navigable current-state knowledge base. A model then reads each workbook packet blind — no answer key, no access to prior conclusions — and must cite exact workbook coordinates and permitted current-state pages for every mapping it proposes; code validates the citations but does not decide the mapping. In the retained blind runs, the matching workbook came back 14 of 14 direct mappings, the partially-matching workbook came back ten direct and three not found, and the deliberately unrelated workbook came back eight not found — the machine said "this isn't here" rather than hallucinating a fit.

Then the stage most AI demos skip: the machine stops. The dashboard's central message is not "AI found the answers." It is:

45 findings still need your call.

Of 45 scope-bearing findings, the system held 24 as found, six as partially supported and 15 as not found — every one an unreviewed model position until a consultant disposes it. Dispositions are immutable receipts. And the scope document — 21 proposed work items with assumptions, dependencies, exclusions and acceptance criteria — remains blocked until every material finding has a human decision. The human decision is the organising object; the report is downstream of the decision surface.

Now apply the counterfactual test. Remove the AI and what collapses is not a margin — it's the offer. Without machine reading, full coverage of hundreds of workbooks reverts to sampling. Without machine matching, the many-to-many reconciliation reverts to hundreds of senior hours nobody will fix-price. Without the compiled evidence chain, "evidence-backed scope" reverts to "trust our judgment". A fixed-price, full-coverage, evidence-backed readiness review was never on any consultancy's price list — not because nobody wanted it, but because it was commercially insane to promise. That is an AI-constituted service.

The same architecture in different clothes

The obvious objection: perhaps this only works in data consulting, where the inputs are already digital. So strip the domain and re-run the recomposition on two businesses I've sat across the table from — both stuck in horse-optimisation conversations at the time.

Parts e-commerce: the customer stops translating

A parts retailer with a big incumbent e-commerce system, heavy support load, and a firm belief that customers needed more help using the catalogue. The inherited frame — "how do we help customers use our website?" — assumes the customer should learn the vendor's ontology. Recompose the outcome instead: let the customer express purchasing intent in whatever artefact they already have — a purchase order, a bill of materials, a photo, an old invoice — and make the supplier perform the translation. Deterministic code extracts lines, quantities and known part numbers; retrieval assembles candidate products; AI judges semantic equivalence and possible substitutions per line; the ambiguous or high-consequence lines route to a human; approved lines compile into an order on the existing platform. The e-commerce system keeps its job as catalogue and transaction engine. It just stops being a cognitive burden placed on the customer: your system learns what the customer is trying to order, instead of the customer learning how to order from you. Run the test: remove the AI and "order by sending us whatever you've got" collapses — the translation cost lands back on humans and the promise dies. Constituted.

Concrete remediation: the RFQ becomes a compiled object

An engineering firm drowning in complex remediation RFQs wanted "AI to automate our quoting process" — the classic faster-horse request. Recomposed: atomise site notes, drawings, photographs and past jobs into defects, areas, constraints and evidence gaps; match each item against remediation classes and analogous completed work; let AI propose scope items, risks, exclusions and information requests per line; an engineer disposes each material item; deterministic code compiles the approved items into the RFQ structure. The output isn't faster document writing. It's an evidence-backed scope-forming system that did not previously exist — every scope line traceable to a defect, a photo, a standard or a decision.

Same seven stages, three different industries. The domain changes; the architecture is recognisable every time. That's the tell that this is a category, not a product.

The consulting compiler: standardise the pipeline, not the client

Productised services traditionally mean standardised output — the same template deck for every client. Consulting value means client-specific answers. The recomposition architecture dissolves that trade-off, and it's worth being precise about how, because it's the economic heart of the category.

Every client begins as a different mess: different models and reports, workbooks with different structures, requirements in different language, different maturity. The system lowers that heterogeneity into a small set of standard objects — source evidence, observed estate, declared requirement, proposed mapping, finding, human disposition, scoped work item. Once a client's world is translated into that language, the rest of the engagement follows a stable process even though every answer remains client-specific:

You standardise the compilation pipeline, not the client's reality. Under traditional consulting, each client is a new expedition. Under the compiler, each client is a new source program passed through the same compiler.

This is economies of specificity applied to professional services: bespoke at the answer layer, standardised at the machinery layer — computing a fitted answer for every client through one production system¹⁸. The broader economy is already reorganising around the same inversion: McKinsey finds faster-growing companies drive 40% more of their revenue from personalisation than slower-growing peers¹⁹, and MIT Sloan Management Review called the underlying shift "economies of unscale" — AI learning about individuals and tailoring at scale, dissolving the old advantage of standardised size²⁰.

Be careful with the complexity claim, though. The complexity has not disappeared; it has been compiled. A thousand spreadsheets still cost more machine work than ten. What collapses is the complexity borne by expensive human cognition: the consultant no longer holds the entire many-to-many graph in their head. The machine holds the graph; the human sees one evidence-bearing case at a time. The unit of senior human work changes from understanding the whole estate to disposing bounded findings — and that shift, not headcount replacement, is the economic event. Breadth becomes cheap parallel machine work. Human attention is reserved for the places where interpretation, authority or consequence is material.

Typed uncertainty: how fixed price becomes honest

The sharpest commercial consequence of the architecture is that fixed price stops being reckless — and the mechanism deserves spelling out, because it's counter-intuitive. The system doesn't promise to resolve every unknown. It promises to type them. Valid terminal states for any line item include: directly mapped; partially mapped; not observed; insufficient evidence; inaccessible within the audit boundary; unsupported source type; ambiguous — consultant decision required; excluded from this phase.

Those aren't failures of the product. They're part of the product. Unknowns become typed deliverables instead of unbounded consulting labour. The fixed-price review isn't promising "we will completely understand and solve your estate"; it's promising a defensible inventory of what is present, what maps, what does not, what remains unknown, and which decisions are required. Honest gaps — the explicit confession of what could not be verified — are a product feature, exactly the discipline that makes an evidence package trustworthy rather than a brochure²¹. One contractual boundary matters enough to state in every report: not observed within the audit boundary is not proof of absence outside it.

The price itself still needs an envelope, because AI flattens the cost curve; it doesn't make it perfectly flat. The defensible shape: an automated preflight census measures the estate — workbooks, sheets, formulas, connections, semantic models, measures, early ambiguity rates — before expensive work begins, and assigns the engagement to a volume band. The band includes a set number of material findings or review cases; a flex reserve absorbs unusual access problems or exception density; unsupported sources are handled by explicit rule. That is not old-fashioned time-and-materials estimation. It is machine-measured product configuration — the machine measures the complexity before the promise is made, and types it while the promise is being kept. Against an industry base rate where a third of projects blow their budgets⁹, that's not a pricing trick; it's a different risk instrument.

The moat: they can copy the offer by Tuesday

A competitor can copy the offer's name overnight. "Fixed-Price Data Readiness Assessment" will be on someone else's brochure by Tuesday, with the same report headings and, eventually, screenshots that look similar. What they cannot copy from the outside is the system that lets you make that promise without losing money or shipping unreliable work: the deterministic sensors and their tests; the safe-representation design that decides what the model may see; the compiled context the judgments run against; the citation validators; the separation of observed, declared, interpreted, decided and scoped states; the disposition and authority controls; the scope compiler; and the accumulated failure cases baked into all of the above.

The moat is not "uses AI". The moat is a governed delivery system that makes an otherwise dangerous commercial promise economically repeatable.

This matters more now than it ever did, because the model itself confers no advantage. Frontier capability is symmetric — every competitor rents the same models from the same labs on the same day²². Whatever edge a new release provides, it provides to everyone at once. Under symmetry, the only durable assets are the ones that can't be rented: the composition. And the composition compounds. Each engagement produces another tested source shape, another extractor, another failure pattern, another scope structure — improvements to the shared machinery (never the client's private data) that lower delivery cost, which makes the fixed-price promise safer, which wins more engagements. The imitator starts with your brochure. You start with the production system behind it. Until they reproduce enough of the composition, they can imitate the claim but not safely honour it.

One more consequence for consultancies anxious about advisory: advisory doesn't die in this model. It moves inside the product — frameworks shape what the system notices, senior judgment defines the decision criteria, consultants resolve the escalations. Advisory becomes the control plane inside the product rather than the deck delivered at the end. What's dying is not judgment; it's the business model of selling judgment as retyped narrative.

Where this fails — and what I haven't proven

A taxonomy is only a tool if it cuts both ways, so apply the test where it fails.

Some services are human-constituted: remove the human and the offer collapses, no matter how much machinery you install. Work whose product is accountability — an audit signature, a legal opinion, a medical decision — is constituted by a licensed human taking liability; AI can prepare every input and the offer still cannot exist without the signer. Work with extreme judgment density — where nearly every line item is ambiguous, high-consequence and precedent-poor — defeats the economics from the other side: if the human must effectively re-perform each judgment, the machine layer adds cost without absorbing breadth, and you've built an expensive routing system around what remains artisanal work. RAND's failure research names the same boundary from the field: some AI projects fail simply because the problem is too hard for AI — it "is not a magic wand"³. The recomposition discipline helps here precisely because it makes the placement explicit: if, when you decompose the outcome, the honest assignment of nearly every unit is "human", you've learned the offer is human-constituted. Build the evidence rails anyway if they help; don't pretend the machine constitutes the service.

And the honest status of my own evidence: this is a capstone built on one production specimen plus two design recompositions. The specimen's retained runs are synthetic; its first real-client engagement, and the harder proof that a second consultant can deliver it without the original builder's heroics, are still ahead — and I've argued elsewhere that engagement two, not engagement one, is the only proof that machinery rather than heroics carried the work²³. The architecture is demonstrated. The category claim is falsifiable — the counterfactual test is public, and you can run it against any offer, including mine. That's deliberate: a category that can't lose arguments can't win them either.

What to do with this

Three moves, in order.

1. Classify your current offers. Run the remove-the-AI test across your catalogue. Most of what you'll find is AI-enabled — fine, but understand it buys parity, not position, and cost-substitution plays can snap back the way Klarna's did⁶.
2. Inventory the suppressed services. Ask the scarcity question — what valuable analysis, reconciliation, vigilance or synthesis does your market not sell because it was never affordable to promise? That list, not your process map, is where AI-constituted offers live.
3. Recompose one outcome. Pick one suppressed service. Decompose it into line-item judgments. Assign each to code, model or human — deliberately, defensibly. Type the uncertainty. Gate the output on human dispositions. Measure the complexity before you price it. Then ship the smallest version that keeps every one of those properties.

The question that started this piece — "where can we use AI?" — produces trinkets because it's a question about your existing workflow. The question that produces new businesses is different: what would you promise if a machine could carry the breadth? Somewhere in your market is a service nobody sells because it was never rational to sell. The machinery to constitute it now exists. Stop selling AI as the subject of the engagement. Embed it deeply enough that a better engagement can exist.