AI Automation

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
Bilingual WhatsApp Support Agent for an E-Commerce Retailer — case study visual

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

  1. Handle Arabic and English customer inquiries through the same WhatsApp channel
  2. Automate routine support conversations without degrading customer experience
  3. Preserve context across multiple customer conversations
  4. Route conversations to human agents when the AI cannot resolve them confidently
  5. 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.

Failure mode 01 Bilingual conversations on one thread

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.

Failure mode 02 No continuity between conversations

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.

Failure mode 03 Routine questions consumed agent capacity

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.

Failure mode 04 No graceful escalation path

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.

Decision 01 Bilingual understanding as a baseline requirement

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.”

Decision 02 Per-customer memory across conversations

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.”

Decision 03 Structured handoffs instead of ad hoc escalation

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.”

Decision 04 Catalog grounding to keep answers accurate

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.”

Decision 05 Human takeover as a first-class feature

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

automated

product, order, and policy questions are resolved by the agent without human involvement.

Bilingual support

consistent

Arabic and English conversations are handled in the customer's own language.

Escalation

structured

conversations requiring human judgment are transferred with full context rather than discovered reactively.

Conversation continuity

improved

returning customers no longer need to re-explain prior issues or context.

Catalog accuracy

strengthened

product responses are grounded in current catalog data rather than generated from memory.

Ready 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.