We Doubled Their Pipeline. Then We Made the Machine Sign Fewer People.

Linguana localizes YouTube channels. A creator signs, and their videos start going out in Spanish, Portuguese, French and German — dubbed, uploaded to dedicated channels, monetized, revenue split.

The business works. The constraint was never the product. It was that every step between "we should talk to this creator" and "this creator is live in four languages" ran through a person, and there were only so many people.

Twelve months later, two thirds of their outbound goes out without anyone writing it, and roughly six hundred support tickets a month close without a human touching them.

Here's what we built, what it produced, and the part where I had to go back and make it sign fewer people.

The shape of the problem

Every automation project starts with someone describing a bottleneck. Usually they're describing a symptom.

The symptom here was outreach volume — not enough creators being contacted. But when you follow a single creator from first email through to four live localized channels, you pass through four separate teams and about nine handoffs. Sales finds them. Someone qualifies whether the channel is even worth localizing. Someone negotiates. Someone turns a signed PDF into a CRM deal. Someone onboards them. Someone answers their questions for the next eighteen months.

Automating "outreach" would have moved one of those nine. The rest would have absorbed the extra volume and quietly become the new bottleneck.

So we didn't build an outreach tool. We built a layer.

One layer between the decision and the execution

The idea is simple enough to fit in a sentence: every channel they pursue, every deal they sign, and every support reply a partner gets runs through the same automated spine.

Humans decide who to reach out to, who is worth signing, and what we commit to. The layer turns those decisions into actions at scale. Five pieces:

• Sales agents — outbound at volume, two personas, multi-language, with human approval where it matters.
• Channel qualification — scores every channel against the view thresholds before anyone spends effort on it.
• Deal Creator — signed contract to CRM deal, with no manual data entry.
• CS agent — answers signed partners' support questions automatically.
• Dashboards — one place to approve, act, and see the real state of the pipeline.

None of that is clever. There's no novel architecture here, and I want to be honest about that up front — it's a well-instrumented pipeline with an LLM in four places where judgment is needed and plain deterministic code everywhere else. The interesting decisions weren't about models. They were about where to put the humans.

Where the humans go

This is the part that determines whether a system like this survives contact with a real team, and it's the part that gets the least attention in every AI pitch I've read.

Three rules, in descending order of how much they cost me to learn.

1. Nothing happens in the dark

When the agent sends on its own, it posts to Slack: the prospect, the subject line, and the channel's live stats at the moment it decided to send.

This looks like a logging feature. It isn't. It's the thing that bought the team's trust in month two, when nobody yet believed the agent should be allowed to write to a real prospect. You cannot ask people to hand over the top of their funnel to a system they can't watch.

2. The agent drafts, the team decides — in the tool they already have

For replies that matter, the agent proposes and waits. A person can approve, edit, stop, or disqualify, right inside Slack.

We built a perfectly good approval queue in the dashboard first. Usage was terrible.

Not because the queue was bad — because it was a second place to go. Sales people live in one window and it isn't yours. The moment the same four buttons appeared inside the Slack channel they already had open, approvals started happening in minutes instead of days. Same feature. Different room.

3. Some things never touch the AI

When a partner cancels, the agent does not reply. It flags the partner manager with the full context, links the deal and the CRM thread, and stays out of it.

There's a temptation, once a support agent is answering 78% of tickets well, to let it answer the last 22% too. Resist it. The last slice isn't residual volume — it's the categorically different stuff: someone angry, someone leaving, someone about to become a legal problem. The value of the automation is that it clears the desk so a human can be fully present for exactly those.

An agent that handles 78% of tickets and escalates cleanly is worth more than one that handles 95% and gets one termination wrong.

The boring part that mattered most

The single highest-leverage thing we shipped wasn't an agent. It was making the agent's knowledge editable by the people who own it.

Every answer the CS agent gives comes from an entry in here. The team edits it, and the change is live. No ticket to me, no prompt engineering, no deploy.

Before this existed, every "the agent said something slightly wrong about payment terms" became a message to me, and I became the bottleneck I'd been hired to remove. That's the failure mode nobody puts in the case study: you automate the work and accidentally centralize the knowledge in the consultant.

Give the client the keys. It's less impressive and it's the only version that lasts.

The cockpit

Two screens carry most of the operational weight. Sends, follow-ups, deals won and reply rates over time, per agent:

And every thread, with each send split into agent versus human, and every pending suggestion in a single queue:

Splitting agent sends from human sends in the same table sounds like a reporting nicety. It's the only reason anyone can answer the question "is this thing actually doing anything" without taking my word for it.

The other place that split shows up is onboarding. When localized channels go live, the system posts the update, links every channel by language and slot, and closes the support ticket itself:

What it produced

Period: August 2025 through July 2026. Figures pulled live from HubSpot on 2 August 2026.

The support curve is the one I'd point at first, because it's the cleanest natural experiment in the whole engagement. Under 1% through April. Then 37% in May, 78% in June, 77% in July — while total ticket volume kept climbing.

Note what the chart does not show: headcount coming down. Nobody was replaced. The same team now absorbs a ticket volume that grew about 50% without anyone noticing it grew.

On the pipeline side, strategic-tier signings roughly doubled — from about four a month in late 2025 to about nine a month through 2026.

And then the part that didn't go to plan

Everything above is the version of this story I'd put on a slide. Here's the one that actually taught me something.

We were hired to fix volume. We fixed volume. Signings went from a handful a month to fifty, sixty, eighty. Every dashboard was green.

Then we plotted signings against the thing that actually pays: how many views each cohort's localized channels earned in their first 45 days.

The two lines came apart. Signings climbed. Returns didn't.

We had built a machine that was extremely good at getting people to say yes, and pointed it at a pool that included a lot of people whose channels were never going to perform. Every one of those signings cost real money downstream — dubbing, uploads, channel management, a partner manager's attention — and returned close to nothing.

The automation wasn't wrong. It was faithful. It did exactly what we asked, at a scale that made the flaw in the asking impossible to ignore.

That's the thing about building a layer like this: it doesn't just execute your strategy, it audits it. Manual processes hide bad targeting because the volume is too low to see the pattern. Run the same targeting at ten times the rate and the pattern shows up in a chart within two quarters.

We had spent twelve months making a decision execute faster. Nobody had asked recently whether the decision was right.

Pointing the same machine at quality

The fix wasn't a new system. It was the same machine, aimed differently — three changes, all of which reduce throughput on purpose:

• Raised the qualification threshold to 500K views. Fewer channels qualify. That's the point.
• Human screening before servicing — a person looks at a signed creator before the delivery machine spends money on them.
• A performance prediction added as a filter, so the agent stops pursuing channels the model expects to underperform.

And a change that wasn't technical at all: the reported metric moved from creators signed to first-45-day views per cohort. Signings are now an input, not a result.

I've written before that approval rate is a vanity metric. Creators signed was the same mistake wearing a bigger suit — a number that goes up when you make the business worse, reported monthly, by me, for the better part of a year.

What I'd tell you before you build one

Automate the whole path, not the loudest step. If you automate one handoff in nine, the other eight absorb the gain and you've bought a faster queue.

Put the controls where the team already lives. Our dashboard approval queue was better software than the Slack buttons. The Slack buttons got used.

Decide what the AI is never allowed to touch, and write it down. Ours is terminations. Yours will be something else. The list is a design artifact, not a limitation.

Hand over the knowledge base on day one. If changing what the agent knows requires you, you haven't finished building — you've just moved the bottleneck to someone with a higher rate.

Instrument the outcome, not the activity. Before you scale a motion, find the number that tells you the motion was worth running. If you can't name it, the automation will find it for you, expensively, about nine months in.

We spent a year making Linguana's decisions execute at scale. The most valuable thing the system produced wasn't the 66%, or the 600 tickets, or the doubled close rate.

It was a chart that proved one of the decisions was wrong.

If you're about to automate something: what's the number that would tell you the thing you're scaling shouldn't be scaled? Go find out whether anyone is watching it.