The Last Verb

The instinct after a story like this is to argue about trust. Were the guardrails too loose? Was the model just not good enough yet? Both questions skate past what actually happened. The agent did the one thing agents reliably do: it generated a plausible next action and took it. The generation wasn't the failure. The failure was that nothing stood between the generation and the irreversible act.

This isn't only a coding problem, and it isn't new. When Air Canada's support chatbot told a grieving customer he could claim a bereavement discount retroactively, a policy the airline didn't actually have, the company tried to argue before a British Columbia tribunal that the bot was "a separate legal entity" responsible for its own answers. The tribunal wasn't having it: you own what your systems tell your customers, whether the words come from a static web page or a language model. The bot proposed a refund policy. Nobody disposed of the proposal one way or the other. The company paid.

What the agent isn't allowed to do

Notice the shape both stories share. In each, an agent produced something: a command, a promise, a plan. And in each, that output crossed straight into the world with no human standing on the far side of it. The agent didn't merely draft the refund policy, it issued it. It didn't merely propose deleting the database, it ran the delete.

That crossing is the whole game, and it has a name once you go looking for it. Every workflow, human or automated, ends in a verb you can't take back. Send. Ship. Publish. Wire the payment. Sign the contract. Drop the table. Call it the last verb: the single act that turns a draft into a fact. Everything upstream of it is reversible. A draft gets rewritten, a plan discarded, a proposal declined at no cost. The last verb is where cost becomes real, and it's the one point in the pipeline where being wrong is expensive.

The volume layer and the gate

Here's the reframe the "trust the AI" versus "ban the AI" fight keeps missing. The question was never how much to trust an agent. It's which verbs you let the agent reach.

Agents are extraordinary at the reversible part of any job. They draft, summarize, refactor, research, and generate ten options while you sleep. That's the volume layer, and it's genuinely transformative: the cost of producing a first version of almost anything has fallen close to zero. But volume and disposition are different jobs wearing the same interface. Producing a plausible refund policy is volume. Deciding it's the company's actual policy is disposition, and disposition is judgment about consequences that don't reverse.

Klarna ran that experiment at full scale and published the result. In early 2024 it announced its AI assistant was doing the work of 700 customer service agents. By 2025 the CEO walked it back: they'd gone too far, quality and trust had eroded, and the company was hiring people again. Read what they actually landed on, though, because that's the lesson and not the headline. They didn't switch the agents off. They split the work: AI handles the routine, high-volume queries, and humans own escalations, complex cases, and high-value conversations. That's not a retreat from automation. It's an org chart that finally put a human on the last verb.

We built our own back office this way on purpose

We don't just recommend this line, we run our own operation on it, and it's worth being specific about how. Behind The Bushido Collective is a small fleet of scheduled agents that do the unglamorous legwork. They scan for companies that fit the kind of team we help. They research and rank them. They draft the outreach. They even draft the posts that land on this blog. They run on a schedule, on their own, while nobody's watching, and they produce a lot.

Every one of them stops at the same place. The agent that finds a prospective client can't contact anyone, it opens a proposal for a human to approve or reject. The agent that drafts outreach can't send, the message waits in a drafts folder for a person to read it and hit send. The agent that writes these posts can't publish, it opens a pull request, and a human merging that request is the publish. The verbs a person has to own, send, publish, spend, sign, aren't merely discouraged in our setup. They're absent from what the agents can physically do. The draft is the agent's job. The deed is ours.

That's discipline, not convenience, and it costs us something every week. It would be faster to let the outreach agent send its own email. The reason we don't is the same reason the freeze existed on Lemkin's project: a human on the last verb earns its keep on exactly one kind of day, the day the agent is confidently, fluently wrong. With generative systems, that day always arrives. Fluency and correctness are not the same signal, and an agent's most dangerous output is the one that reads perfectly and is wrong in a way only judgment catches before it ships.

Where you draw yours

So the useful question for any leader wiring agents into real work isn't "do I trust it." It's concrete and answerable, one verb at a time: for each thing this agent touches, what's the last verb, and who owns it? If the honest answer is "the agent does," you don't have an automation strategy yet. You have Air Canada's legal bill, waiting for someone to file it.

Getting that map right, which verbs stay human, where the gate sits, how the volume flows up to meet it, is most of what technical leadership means now that drafting has gone free. The agents are the easy part. The gate is the job.