Jack Crabtree, Founder · 4 August 2026 · Case study

Overview

Enchant is an eCRM agency, which means a meaningful part of its client work starts with a discovery call: understanding a client’s business, their goals, and what a strategy engagement with them should actually cover. The output of that call, eventually, is a strategy deck the client reviews, discusses and signs off on before the engagement moves forward. Between the call happening and the deck existing, there was traditionally a write-up step: someone reviewing the recording or their own notes, and manually building the deck’s first draft from scratch. We built the automation that removes that specific write-up step, turning a call transcript directly into a first-draft strategy deck through a multi-agent AI chain, and we’re describing the chain’s structure in some detail because a single-prompt approach to this problem doesn’t hold up under real-world use, and understanding why is useful context for anyone weighing up something similar for their own agency.

The Problem

The write-up step between a discovery call and a first-draft deck is real work, and it’s work that doesn’t scale well with the volume of calls an agency runs. It requires someone to have been on the call, or to review the recording closely enough to extract what actually matters from it, and then to structure that into the specific format a strategy deck needs: not a transcript, not raw notes, but an organised, client-facing narrative. That’s a skilled task, and doing it well takes real time per client, time that’s spent on a fairly mechanical transformation from “what was said” to “how we present it,” rather than on the higher-value strategic thinking the agency’s own people are genuinely best placed to contribute to a client relationship. The bottleneck wasn’t the strategic thinking; it was the mechanical transformation step in front of it.

That distinction matters for how we scoped this build, and it’s worth being explicit about it. It would have been possible to frame this as “automate strategy deck creation” and try to have a system generate finished strategic recommendations directly from a call. We didn’t build it that way, and we wouldn’t have wanted to, because the actual value Enchant provides a client isn’t the deck’s structure, it’s the judgement behind what goes in it. The problem worth solving was specifically the mechanical bottleneck between a call happening and a draft existing to work from, not the strategic thinking that happens once that draft is in front of a person who knows the client and the account’s history.

Our Solution

We built a multi-agent AI chain that takes a call transcript as input and produces a first-draft Google Slides deck as output, deliberately structured as a chain of distinct stages rather than one large prompt asking a single model to do everything at once. A single-prompt approach to this problem tends to produce a plausible-looking but structurally weak result, because “summarise this call and turn it into a strategy deck” is actually several different tasks bundled together: extracting the substantive content from a transcript that includes filler, tangents and small talk; organising that content into the narrative structure a strategy deck actually needs; and then producing the specific slide-by-slide output in a format a client can review. Asking one pass of a model to do all three at once tends to produce a result that’s mediocre at all three rather than good at any of them.

We split the chain accordingly. An early stage in the chain is responsible for extracting the substantive content from the raw transcript, separating what the client actually said about their business, goals and constraints from the conversational noise that surrounds it in any real call. A middle stage takes that extracted content and organises it into the narrative structure a strategy deck needs, which is a different task from extraction: it’s about sequencing and framing, not just identification. A final stage takes that structured narrative and produces the actual Google Slides output, slide by slide, in a format the agency’s team reviews and edits rather than ships untouched. Each stage does one job well rather than one stage attempting all three at once, and each stage’s output becomes the next stage’s input, so problems at an early stage are visible before they propagate all the way through to a client-facing deck.

That visibility between stages turned out to matter in practice, not just in theory. Because each stage’s output is inspectable on its own, we could tell, when a generated deck came out weaker than expected, whether the problem originated in extraction, missing something substantive from the transcript, in organisation, structuring good content in a way that didn’t land well, or in the final slide generation, producing an awkward or unclear rendering of otherwise good structure. A single-prompt system that failed would have given us none of that diagnostic information; a bad output would just be a bad output, with no reliable way to tell which part of the process actually needed adjusting. The staged design turned debugging from guesswork into something closer to normal software debugging, where a specific failure points at a specific stage.

How We Deployed It

The most important design decision in this build wasn’t the chain structure itself, it was where we deliberately stopped automating. The output is explicitly a first draft, reviewed and edited by Enchant’s own team before it goes anywhere near a client, not an auto-send pipeline that skips human judgement entirely. We built it that way on purpose. A strategy deck carries the agency’s judgement and expertise, not just a structured summary of what was said on a call, and an AI chain, however well designed, doesn’t have the context of the agency’s broader relationship with that client, prior engagements, or strategic considerations that never came up explicitly in one discovery call. Treating the automation’s output as a first draft rather than a finished deliverable keeps the human judgement in the loop exactly where it matters most, while still removing the mechanical transcription-to-structure work that used to consume real time before any of that judgement could even be applied.

Getting the middle, organising stage right took the most iteration of the three. Early versions tended to follow the chronological order of the call rather than the narrative order a strategy deck actually needs, which are often different: a client might mention their biggest constraint halfway through the call almost as an aside, but a well-built deck needs to surface that constraint early because it shapes everything that follows. We adjusted the prompting and structure of that middle stage specifically to prioritise narrative importance over conversational chronology, testing it against a set of real calls where we could compare the automated draft’s structure against how a skilled person on the team would have organised the same material by hand, adjusting the middle stage’s approach whenever the two diverged in a way that mattered.

The Outcome

Discovery calls now turn into client-ready first-draft strategy decks without the manual write-up step that used to sit between a call ending and a draft existing. We’re stating this outcome in terms of what changed in the process, a mechanical bottleneck removed, rather than attaching a time-saved or output-volume figure, because we don’t have a clean, evidence-backed metric for this build that we’d be comfortable standing behind. What we can say is that the deck the team now starts from is a structured first draft built directly from what the client actually said, not a blank page, and the team’s own review and editing time goes into refining strategy rather than assembling the deck’s basic structure from scratch.

We’d also note what this build deliberately doesn’t do, because it’s as informative as what it does. It doesn’t attempt to make strategic recommendations on the client’s behalf, and it doesn’t produce a deck intended to go to a client without human review. Both of those omissions were deliberate design choices from the outset, not gaps we simply ran out of time to close. An agency’s actual product is the judgement its people apply to a client’s situation, and a tool that tried to automate that judgement away would be undermining the thing Enchant is actually selling, not supporting it. The chain’s job ends at giving a skilled person a strong starting point, faster than they’d have had one otherwise.

Related: AI Deployment. More on the team behind this build: About Equanax.