We stopped trying to make our AI smarter. We gave it a sense of who it was instead.

Every AI support system sounds the same. Ask it something off-script and it says, "please contact our support team." Not exactly wrong, just strange, because you're already talking to it, and now it's telling you it isn't support.

Martha used to do this too. And the fix turned out not to be better answers. It was figuring out who she was supposed to be in the first place.

Here's the situation that made it obvious. A customer messages in about a failed payment. Martha doesn't have that in her knowledge base, so she reaches for the safe line: contact support. Except the customer is already in a support conversation. They came to Martha because Martha *is* the front door. Telling them to go find support somewhere else doesn't just fall flat, it derails the whole thing. They start wondering what they've been talking to this entire time.

From an engineering angle, that fallback made sense. If Martha couldn't find an answer, deflecting was safer than guessing wrong. But safe for the model isn't the same as coherent for the customer. And it got worse as Martha showed up on WhatsApp, SMS, and email, because someone texting a business number or replying to a support inbox is *already* in a support conversation. Telling them to find one elsewhere makes no sense at all.

So the real question was never "how do we make Martha smarter." It was: how do we keep her safe when she doesn't know something, without ever making her sound like she's standing outside the thing she's supposed to be running?

We tried the obvious stuff first. More documents, fine-tuning, tighter guardrails. It helped, the way talking louder helps someone who doesn't speak your language. A little clearer, same fundamental problem.

What actually changed things was giving Martha an identity: a clear sense that she's the support layer, not a bot sitting in front of one. That single shift touches everything, how she words things, when she brings in a human, and what she hands that human when she does.

Before, it looked like this. A customer asks about a delayed refund. Martha doesn't have the specifics, so she falls back: "Please contact our support team for further assistance." The customer is already talking to support. They just stare at the sentence.

Now the same question gets this: "I can look into that for you. Can you share your order ID? If this needs an account-level check, I'll loop in the right person and give them everything we've discussed so far."

Same uncertainty underneath. Completely different experience on top.

The bigger change was underneath. Every reply now carries a decision with it, what kind of answer this is, what it implies, what the risks are, what's missing, and whether it's safe to send.

The old safety net worked by phrase-matching: it scanned Martha's own answers for things like "I don't have any information" and pulled back when it found them. That held up fine until the model's phrasing shifted slightly, and then the whole mechanism quietly stopped firing. Reading intent from a sentence is fragile. Reading it from a structured field isn't.

So escalation stopped being an automatic fail-safe and became an actual decision. Martha escalates when the problem is account-specific, genuinely risky, outside what she knows, or when the customer simply asks for a person.

And when she does, it's a real handoff, not a disappearing act. She logs the issue, writes a short brief for whoever's picking it up, updates the status, tells the customer she's connecting them, and pings whoever's around. If no one's available, she doesn't just leave it, she stays and keeps gathering whatever the transfer will need. Once a human takes over, she steps back completely. No overlapping conversations. Ownership stays clear the whole way through.

Every decision gets recorded too, the nature of the issue, the risk assessment, what she was missing, whether it was safe to automate. Alongside that, we log whether a new classifier would have made the same call. Right now that classifier runs in shadow: watching, not touching production, so we can confirm it agrees with the existing system thousands of times before it's trusted to decide anything for real.

The part that made this feel real is that it isn't stuck to one interface. Same flow across web chat, WhatsApp, SMS, and email. A WhatsApp message comes in, goes to Martha, her reply goes back out through WhatsApp. SMS runs the same way through Twilio. Email gets matched to the right thread and answered under the subject line the customer already sees.

And every one of those replies gets saved back into the conversation as Martha, not some anonymous system line. That's what actually closes the gap. Whichever channel you reach for, you're talking to the same support experience, not five fragments of one.

None of this was about making her answer everything. It was about killing the lazy deflection while keeping the safety. When she can't answer something, she asks a clarifying question, explains what's missing, escalates with real context, or refuses outright if it's unsafe, without leaking prompts or making things up while she does it.

Since rolling this out, our support deflections dropped sharply, Martha started asking the right follow-up question far more often instead of giving up, and unnecessary escalations roughly halved. She isn't answering more by guessing. She just stopped bailing out when she didn't need to.

(A note on those numbers: they're measured against our own baseline over the rollout period, not an industry benchmark, I'd rather tell you the direction honestly than dress up a precise figure.)

As far as I can tell from the outside, tools like Meta's Business Agent and Intercom's Fin are built to solve routing. Get the conversation to the right destination as fast as possible, ideally without the customer noticing the handoff at all. That's the job: move the conversation along.

Martha isn't optimizing for speed of handoff. She's optimizing for whether the customer still trusts they're talking to something coherent, before, during, and after the handoff. Routing tools treat escalation as success: the conversation reached a human, job done. Martha treats escalation as one possible outcome of a conversation she's still responsible for. That's why she stays present, gathers context, and hands off with a brief instead of just stepping aside.

Before, hitting an unknown felt like: "Sorry, I can't help with that — should I transfer you to a human?" Technically fine. Emotionally, a dead end.

Now it sounds like this:

Customer: Can you help me with a problem with my payment?

Martha: I can help with that. Share the transaction ID and I'll figure out the next step. If it needs an account-level check, I'll connect you to the right agent with everything we've covered so far.

Same system underneath. Same willingness to bring in a human when it's actually needed. The difference is that nothing about it sounds like she ran out of road. It sounds like she's still driving.

We didn't tear up the core logic to get here. The escalation rules, the risk checks, the refusal to guess, all of it stayed. What changed is what sits on top: an identity that treats escalation as one small part of the job instead of the whole job, a structured way of deciding instead of a fragile one, and one continuous presence across every channel a customer reaches for.

She still hands off sometimes. But now it reads like something she chose to do for the customer, because that's exactly what it is.