Bilingual WhatsApp Support Agent for an E-Commerce Retailer
A self-hosted Arabic-English WhatsApp support agent with per-customer memory, structured handoffs, human takeover, and catalog grounding.
- bilingual WhatsApp AI support agent
- WhatsApp customer support automation
- e-commerce AI customer support
- Arabic English WhatsApp support
- AI customer support system
- WhatsApp human agent handoff
Overview
The project at a glance
A B2C e-commerce retailer needed a way to handle growing volumes of WhatsApp customer support without expanding their human team at the same rate. The company served a customer base that communicated in both Arabic and English, and their support operation had relied on human agents working through WhatsApp Business directly.
Octacer was engaged to design and build a bilingual WhatsApp support agent capable of handling routine customer inquiries independently, while recognizing when a conversation needed human intervention and transferring it cleanly to a live agent. The scope of the engagement was a self-hosted AI system grounded in the retailer's product catalog, with per-customer conversation memory, structured handoffs, and human takeover capability.
The primary objective was to reduce the manual coordination burden on the support team by handling repetitive, predictable inquiries automatically — while preserving the option for human involvement whenever the situation required judgment, empathy, or escalation.
What the engagement had to achieve
- Handle Arabic and English customer inquiries through the same WhatsApp channel
- Automate routine support conversations without degrading customer experience
- Preserve context across multiple customer conversations
- Route conversations to human agents when the AI cannot resolve them confidently
- Ground responses in the retailer's actual product catalog
The story
From shared inbox to structured triage
What was at risk
The Challenge
The retailer's support team managed customer conversations through a shared WhatsApp Business inbox. Every inquiry — a product question, an order status check, a return request — landed in the same queue and required a human agent to read, interpret, and respond. As order volume grew, so did the volume of routine, repetitive questions that consumed agent time without requiring any special expertise. The operational problem was not that the support team was underperforming. It was that the structure of the channel forced the same human effort onto every conversation, regardless of complexity.
Customers switched between Arabic and English, sometimes within a single conversation. The support team needed agents who could handle both languages comfortably and respond in the language the customer was using. This constrained hiring, increased training time, and made consistent response quality harder to maintain across shifts.
Each customer conversation started without context. If a customer followed up on a previous inquiry, the agent had to reconstruct the history from scattered WhatsApp threads. There was no reliable mechanism to carry relevant context — a prior order, an ongoing issue, a previous resolution — from one conversation to the next.
A large share of inbound messages were predictable: product availability, shipping timelines, return policies, order status. Each one required an agent to look up information, compose a response, and send it. The volume of these routine inquiries created a ceiling on how many meaningful conversations the team could handle, because every routine exchange consumed the same time as a complex one.
When a customer's issue went beyond what the team could resolve — a damaged shipment, a payment dispute, a request that needed human judgment — there was no structured mechanism to identify that need early and transfer the conversation cleanly. Escalation happened when an agent decided a conversation needed attention, which was reactive and inconsistent.
How we responded
The Solution
Octacer's approach combined a bilingual AI conversation layer with deterministic workflow control around it. The system was built to handle the full conversation lifecycle: receive a message, understand it, resolve it if possible, and hand off to a human when necessary — with all relevant context packaged for the receiving agent. The decision to make the system self-hosted rather than relying on a third-party support SaaS was deliberate. The retailer retained full control over conversation data, model configuration, and the escalation workflow, rather than depending on a vendor's constraints.
The agent was built to detect the language of each incoming message and respond in the same language. Arabic and English conversations could proceed naturally, and the system would maintain the language match across a single thread even if the customer switched mid-conversation. This removed the language constraint from the retailer's support hiring and put it into the system layer.
“Respond in the customer's language, not the system's default.”
The system maintained a persistent memory per customer, storing relevant conversation history, resolved issues, and open items. When a returning customer messaged, the agent had access to prior context rather than treating each conversation as a fresh inquiry. This reduced friction for repeat customers and removed the need for them to re-explain issues they had already raised.
“Context follows the customer, not the thread.”
When the agent determined it could not confidently resolve a conversation, it transferred the full thread to a human agent with structured context attached: what the customer asked, what the agent had attempted, and why the conversation needed human attention. The human agent received the conversation with the information needed to pick up where the AI left off, instead of reading through the entire history to reconstruct the situation.
“Hand off with context, not with a blank slate.”
Responses about products were grounded in the retailer's product catalog data rather than generated from the model's general knowledge. The system looked up product information from the actual catalog before composing an answer, which kept responses accurate and aligned with what the retailer was actually selling — current stock, prices, and product details.
“Answer from the catalog, not from memory.”
Human takeover was built into the workflow as an explicit system capability, not an afterthought. The agent could recognize when a conversation had moved beyond its scope and transfer it to the human team. From the customer's perspective, the transition was clean — the conversation continued in the same WhatsApp thread, and the human agent stepped in with the context already assembled.
“The machine, not the customer, should ask for a human.”
Deliverables
What we built
The concrete capabilities designed, built, and shipped in this engagement.
AI conversation engine
The core conversation engine handled incoming WhatsApp messages, detected the language, classified the intent, and composed responses in the appropriate language. It processed each message within the context of the customer's conversation history and resolved what it could independently.
- Arabic and English language detection and response matching
- Intent classification for common support categories
- Context-aware responses using per-customer memory
Catalog lookup layer
Product-related inquiries were resolved against the retailer's catalog data rather than the model's internal knowledge. The system retrieved current product information before composing responses about availability, pricing, or product details.
- Product information retrieval grounded in catalog data
- Responses reflect current catalog state at the time of inquiry
- Reduces hallucinated or stale product answers
Conversation memory
Each customer's conversation history was stored and made available to the agent in future conversations. The memory layer allowed the agent to recognize returning customers and reference prior interactions when relevant.
- Persistent per-customer conversation history
- Cross-conversation continuity for repeat customers
- Context available to both AI responses and human handoffs
Escalation and handoff workflow
When the agent could not confidently resolve a conversation, it initiated a structured handoff. The conversation thread and supporting context were passed to the human support queue, where a live agent could take over within the same WhatsApp thread.
- Confidence-based escalation triggers
- Structured context packaged with each handoff
- Clean transition without requiring the customer to repeat themselves
Human takeover interface
Human agents received transferred conversations with the context assembled by the system. The interface presented the conversation history plus the agent's assessment of why the conversation needed human attention, allowing the support agent to respond without reconstructing the thread.
- Conversation history presented at takeover
- Context about what the AI had already attempted
- Support agents operate in the same WhatsApp channel
Self-hosted deployment
The entire system was deployed on infrastructure the retailer controlled, rather than running inside a third-party support platform. The customer's conversations, configuration, and escalation workflows remained within the retailer's own environment.
- Full control over conversation data
- Model and workflow configuration managed in-house
- No dependency on a vendor's support platform
Technology
The stack
The tools behind the build, and the role each one played.
AI
OpenAI
provided the language model used for conversation understanding and response generation; language detection and intent classification ran through the same model layer.
Orchestration
n8n
managed the workflow logic connecting WhatsApp messages, catalog lookups, memory retrieval, and escalation decisions; handled the deterministic routing around the AI conversation layer.
Communications
WhatsApp Business Platform
the channel through which customers sent and received messages and where human agents took over transferred conversations.
Outcome
What changed
The system changed how the retailer's support operation handled its incoming volume. Routine inquiries — product questions, order status checks, policy clarifications — could be resolved without consuming a human agent's time. The bilingual capability removed a constraint on who could respond to which conversations, and the memory layer eliminated the need for customers to repeat context across conversations.
Routine inquiry handling
automatedproduct, order, and policy questions are resolved by the agent without human involvement.
Bilingual support
consistentArabic and English conversations are handled in the customer's own language.
Escalation
structuredconversations requiring human judgment are transferred with full context rather than discovered reactively.
Conversation continuity
improvedreturning customers no longer need to re-explain prior issues or context.
Catalog accuracy
strengthenedproduct responses are grounded in current catalog data rather than generated from memory.
Related work
Legal Intake Automation for a Criminal-Defense Law Firm
Converts scanned packets into reviewed structured data and syncs it into the firm's case-management system without manual retyping.
View case studyAI Upload Validation for an Agri-Tourism Grant Portal
Real-time AI verification flags invalid documents and farm photos during upload while a fail-open policy keeps legitimate applicants unblocked.
View case studyAirtable Review-Form Contact and Retailer Automation
Links review submissions to the right Contact and Retailer by email and creates a flagged Contact when no match exists without dropping submissions.
View case studyReady to build something like this?
Let's discuss how we can deliver a similar outcome for your team — scoped to your stack, your data, and your workflow.