Inside a WhatsApp sales agent.
Our AI sales agent handles 70% of a solar client’s monthly sales inside WhatsApp. Here’s how it’s put together, and where the human team still comes in.
For one of our solar clients, an AI agent now handles 70% of monthly sales from first message to confirmed order, inside WhatsApp. Customers rate it 4.8 out of 5. It replies in seconds, at any hour, in whichever language the customer writes in.
None of that comes from the model alone. The model writes the messages, but the agent’s reliability comes from the system around it: what it’s allowed to say about price, when it must hand over to a person, and how every conversation is measured. This note walks through that system.
Why WhatsApp
In many markets, WhatsApp is where buying conversations already happen. Customers would rather send a message than fill in a web form and wait for a callback, and a form captures intent at its peak and then lets it go cold.
A conversation is also richer than a form. The customer can ask a question, send a photo of their roof or their electricity bill, change their mind about the budget, and come back three days later. A good agent treats all of that as one continuous thread.
The conversation as a pipeline
We model each conversation as moving through five stages. The model decides what to say; the stage decides what it’s trying to achieve and what it’s allowed to do.
- Capture. Greet, understand the request, and record what the customer has already said.
- Qualify. Ask only the questions that change the recommendation: location, monthly bill, roof type, budget and timeline.
- Propose. Build a quote from the client’s real price list and product catalogue, and explain it in plain language.
- Negotiate. Handle objections and requests for discounts, within limits the business has approved.
- Close or hand off. Confirm the order and next steps, or pass the conversation to a person with full context.
Stage changes are explicit and logged. That makes the agent’s behavior inspectable: for any conversation we can see where it stalled, and across all of them we can see where customers drop off.
Prices come from data, not the model
The fastest way to lose a customer’s trust is to quote a number you can’t honor. The agent never generates prices. It retrieves products and prices from the client’s current catalogue, and a pricing function calculates the quote. The model’s job is to explain the result.
The same rule covers anything factual: warranty terms, installation timelines, financing options. Those answers come from retrieved documents. If the documents don’t cover a question, the agent says so and offers to check with the team rather than guessing.
Negotiating inside a fence
Customers ask for discounts, and a sales agent that can’t negotiate isn’t much of a sales agent. But “use your judgment” isn’t a pricing policy. We encode the business’s actual rules, such as the maximum discount per product line and the minimum margin, and enforce them in code, outside the model.
interface DiscountPolicy {
maxPercent: number; // the most the agent may offer on this product line
minMarginPercent: number; // never go below this margin
}
type Review =
| { action: "offer"; price: number }
| { action: "handoff"; reason: string };
/** The model proposes a discount; this decides. Anything outside policy goes to a person. */
export function reviewOffer(listPrice: number, cost: number, percent: number, policy: DiscountPolicy): Review {
const price = listPrice * (1 - percent / 100);
const margin = ((price - cost) / price) * 100;
if (percent <= policy.maxPercent && margin >= policy.minMarginPercent) {
return { action: "offer", price };
}
return { action: "handoff", reason: `A ${percent}% discount is outside policy` };
}The model can be as persuasive as it likes, but it can’t give away margin the business hasn’t approved. And when a customer pushes past the limit, that’s usually a conversation worth a person’s attention anyway.
Knowing when to hand off
Handing over to a person isn’t a failure. Handing over badly is. The agent passes a conversation to the sales team when:
- the customer asks for a person, or is clearly frustrated;
- a request falls outside policy, such as a larger discount, a custom installation or a contract change;
- it still isn’t confident it has understood the request after asking a clarifying question;
- the deal is large enough that the business wants a person involved regardless.
When it hands off, the salesperson gets a summary: who the customer is, what they need, what’s been quoted, and why the agent stepped back. The customer never has to repeat themselves, which is most of what makes a handoff feel good.
The customer should never have to repeat themselves. That one rule shapes the whole handoff.
Following up, weeks later
Solar is a considered purchase. Plenty of customers go quiet for weeks while they compare quotes or wait for a budget decision. The agent schedules follow-ups based on where each conversation stopped, and picks the thread back up with full context when the customer replies. Some of the most valuable sales start with a reply months after the first conversation.
What we measure
The headline numbers are the ones the business cares about: the share of monthly sales the agent handles end to end (70% for this client), customer rating (4.8 out of 5) and uptime (99%). Behind them sit the numbers that explain them:
| Metric | Why it matters |
|---|---|
| Response time | Speed is most of the advantage over a form or a callback |
| Stage conversion | Shows where conversations stall, stage by stage |
| Handoff rate and reason | Too high wastes the team’s time; too low means the agent is overreaching |
| Quote accuracy | Every quoted price is checked against the catalogue after the fact |
| Policy violations | Should be zero; anything else is investigated the same day |
Every conversation is logged with its stage history, the documents it retrieved and the tools it called, so when a number moves we can find out why. Changes to prompts, retrieval or policy are scored against real past conversations before they reach customers, the same eval-first approach we use everywhere.