Open the OLX app and you’ll find everything a buyer or seller could need: categories, filters, search, packages, and help. But a feature only helps if people can find it and know how to use it. Most users don’t think in categories and filters. They think in sentences, in English, in Hindi, or in a mix of both: “Delhi mein 5 lakh ke around koi achi used car dikhao.”

That gap between how people speak and how a product expects them to navigate is why we built VAYA AI, OLX India’s conversational assistant. VAYA AI lets users say what they want in their own words, on the OLX app or on WhatsApp, and takes care of the rest. It can search for listings, answer questions about a user’s account and packages, connect people to customer care, and even start a conversation when something relevant happens.

Building it meant solving problems that go well beyond a simple chatbot: understanding mixed-language input, turning loose requests into precise search queries, coordinating several specialised agents, and giving users the same experience on two very different channels.

The Problem

OLX India serves a wide range of user journeys like searching for a specific listing, finding leads, exploring and buying packages, looking for recommendations or returning to the platform after time away. Each journey begins at a different entry point, across both the app and WhatsApp and each is served by its own screens, filters and workflows.

This model works when users already know where to go and what to look for. But natural intent is rarely structured. A user thinks, “Delhi mein 5 lakh ke around koi achi used car dikhao,” and is then expected to translate that into a category, a location, a price range and a set of filters before the platform can help. The traditional model for searching on OLX looks something like this :-

The problem is not a lack of features. It is discoverability and effort. Users must know where a journey lives and convert their intent into the product’s structure, instead of the product understanding their intent. This gap widens for:

• Multilingual users, who think and type in Hindi, English, or a mix of both, which keyword search and fixed filters handle poorly
• Users with loosely defined needs, who want recommendations rather than precise searches
• Lower-visibility journeys, such as packages and Elite, where users often don’t know what to ask for or where to find it
• Users across channels, who expect the same experience on WhatsApp as in the app

The challenge therefore was to let users say what they want in their own words and have the system understand the intent, take the right action, and guide them through the journey, on any platform and in any language.

Motivation

The motivation behind VAYA was to reduce the distance between user intent and OLX action. Instead of asking users to understand the structure of the platform, we wanted the platform to understand the structure of the user’s request. This changes the interaction model like this :-

This also allows the same intelligence to be exposed through different surfaces. The user shouldn’t have to care whether they are interacting through the OLX App or WhatsApp.

The challenge therefore, is not simply to provide more features. It is to make existing OLX capabilities easier to discover and use for the buyer and sellers. This led us to VAYA AI.

VAYA AI

VAYA AI is an LLM-powered conversational engagement platform designed to understand user intent, work across multiple interaction surfaces and connect natural-language conversations with the platform capabilities. With VAYA AI, our goal is to make the OLX buy & sell experience more convenient, trustworthy and simple, powered by the orchestration of multiple AI agents across key moments of the buyer and seller journeys like matchmaking, pricing evaluation, negotiation and beyond. 

What is VAYA ?

Conversational – Users can express their intent naturally instead of learning a predefined command structure

Intelligent – An LLM helps understand multilingual and natural-language requests and determine the appropriate action.

Connected– VAYA is connected to OLX services and can route requests to agents or internal services that perform the actual business operations.

Architecture

VAYA AI is built as a layered, backend-driven system. Channels sit at the edge, a conversation orchestrator at the center coordinates everything and capability layers (AI agents, domain services, and asynchronous services) do the actual work. A separate pipeline handles conversations that VAYA starts itself. Four design principles shaped it.

Multi-Platform Support (App and WhatsApp)

Users reach VAYA through the OLX App and through WhatsApp. These channels differ in how they deliver messages, what UI they can render, and how they identify users.

To keep one brain behind both channels, we put a channel-agnostic orchestrator at the front

• Channel adapters translate incoming events (WhatsApp webhooks, in-app chat calls) into a common internal message format and translate responses back into what each channel supports.
• An identity resolution step maps a phone number or app user to the same OLX user so a person gets a consistent experience on either channel.
• A fast session store keeps conversation state and cached identity, so every turn doesn’t start from scratch.
• Incoming messages are acknowledged quickly and handed to a queue, so WhatsApp’s webhook time limits never block on slow downstream work.

Multi-Lingual Support

Users write in English, Hindi, and a natural mix of both. VAYA AI handles this at the understanding layer rather than building separate bots per language. Because language handling lives in the shared core and not in each channel, adding a language improves both the app and WhatsApp experiences at once.

Backend Driven Architecture

All conversational logic lives on the backend. The clients whether the app or WhatsApp, are thin, they send what the user typed and render what the backend returns.

This approach provides us the edge as

• Faster iteration.
• Consistent behaviour.
• A clean integration surface.
• Decoupled processing.

AI agents plug into the orchestrator the same way. The orchestrator decides which agent or service should handle a request, and each of them reaches platform data only through the aggregation layer.

Proactive Engagement

Most chatbots only react. VAYA AI can also start the conversation, for example to nudge a seller, follow up on an ad a user viewed, or tell a user something relevant has changed.

A dedicated pipeline powers these proactive engagements

1. Business events.
2. Alerting layer.
3. Message templates.
4. Delivery workers.

Replies to these messages flow back into the same orchestrator, so a proactive nudge becomes a normal conversation, with the same context, identity, and language handling.

Multi-Agent Support

As VAYA AI grew from answering questions to completing real tasks, a single do-everything agent stopped being practical. One agent with every instruction, tool and edge case in a single prompt becomes slow, hard to test, and prone to confusion and a change for one journey risks breaking another. So VAYA uses multiple specialized agents, each responsible for one well-defined area, coordinated by the conversation orchestrator.

Why multiple agents

• Focus – Each agent has a narrow scope, a small set of tools, and clear instructions, which improves accuracy and reduces wrong or off-topic answers.
• Independent evolution – Teams can improve, test, and release one agent without touching the others.
• Cost and latency control– Simple tasks can go to lighter agents or models, while complex reasoning goes to heavier ones.
• Safer boundaries – Each agent only gets access to the tools and data its job requires.

How requests reach the right agent

1. Intent understanding. The orchestrator first works out what the user wants (see the Intent Classification section).
2. Routing. Based on the intent and the current conversation state, it picks the agent best suited to handle the turn.
3. Execution. The chosen agent reasons about the request and calls the tools it needs. These tools reach OLX platform data only through the domain aggregation layer, never directly.
4. Response. The result returns to the orchestrator, which formats it for the user’s channel (app or WhatsApp) and language.

Guardrails

• Scoped tools. Each agent can call only the tools it needs.
• Grounded answers. Account and listing information comes from platform services, not from the model’s memory.
• Fallbacks. When an agent is unsure or a tool fails, VAYA asks a clarifying question or escalates instead of guessing.

Natural Language to Structured Search

Search is where the gap between how people speak and how platforms expect them to navigate is most visible. OLX’s search is built on structured inputs like a category, a location, a price range, and filters such as make, model, year, fuel type, or number of bedrooms. VAYA AI lets users skip that structure and type what they mean. Its job is to turn free-form, often code-mixed text into a precise structured query that the existing search backend can execute.

From a sentence to a query

“Delhi mein 5 lakh ke around koi achi used car dikhao.”

VAYA AI converts this into a structured request like

{
  "intent": "search_listings",
  "category": "cars",
  "location": "Delhi",
  "price": { "min": 400000, "max": 600000 },
  "sort": "relevance"
}

The pipeline

1. Understand the request. The orchestrator identifies that this is a search intent and routes it to the search agent.
2. Extract entities. The model pulls out category, location, price, condition, and attributes from the text.
3. Normalize. Raw phrases become standard values: “5 lakh” becomes 500000, “Delhi” or “dilli” becomes one canonical location, “Activa” maps to the right make and model.
4. Validate against the platform. Extracted values are checked against OLX’s actual taxonomy and filter definitions, so the query only uses categories and filters that really exist.
5. Execute. The structured query goes to the search service through the domain aggregation layer, the same path used by the rest of the platform.
6. Respond. Results are formatted for the channel, as cards in the app or a compact message on WhatsApp, in the user’s own language.

Why this is hard

• Code-mixing and transliteration. Users blend Hindi and English and type Hindi in Roman script, with inconsistent spelling.
• Fuzzy numbers. “Around 5 lakh,” “under 5 lakhs,” “5-6 lakh,” and “budget 5L” all express different constraints. VAYA has to decide between a ceiling, a range, or a target.
• Local vocabulary. Brand and model nicknames, locality names, and informal terms for categories and conditions rarely match the catalog exactly.
• Category-specific filters. A car search needs make, year, and kilometers driven, while a property search needs BHK, furnishing, and area. One extraction layer has to adapt to many schemas.
• Subjective language. Words like “achi,” “cheap,” or “good condition” don’t map to a filter.

Handling ambiguity and missing information

Not every request is complete, and guessing wrong is worse than asking.

• Missing essentials. If a request has no usable category or location, VAYA AI asks one short, specific clarifying question instead of returning irrelevant results.
• Progressive refinement. Users can narrow results conversationally (“only 2018 or newer,” “make it automatic”) and VAYA AI updates the existing query instead of starting over.
• Defaults and fallbacks. When a filter returns nothing, VAYA AI can relax constraints and tell the user what it changed.
• Confidence checks. Low-confidence extractions trigger a confirmation (“Did you mean Delhi NCR?”) rather than a silent assumption.

Keeping it reliable

• Schema-constrained output means the model can only produce fields the search backend understands.
• Validation before execution rejects malformed or unsupported queries.
• Grounding in platform data ensures category names, filters, and locations come from OLX’s own catalog, not the model’s memory.
• Reuse of the existing search stack. VAYA changes how the query is formed, not how search ranks, so ranking quality and behavior stay consistent with the rest of the product.

ChatBot Orchestration – Different Chat Flows

A chatbot that serves buyers, sellers and support requests across two channels is not one conversation. It is many different conversations each with its own rules. Searching for a car is open-ended, posting an ad is a sequence of required steps and a request for customer care ends with a person. VAYA’s conversation orchestrator is the layer that keeps these apart and makes them feel like one assistant.

It is the single entry point for every message, from either channel. It doesn’t answer questions itself. It owns the lifecycle of a conversation like who the user is, where they are, what they want and which flow should handle the next turn. The diagram below shows what happens to each message.

The life of a message

1. Receive. WhatsApp sends messages as webhooks that expect a quick response. The orchestrator acknowledges immediately and places the message on a queue. Slow work such as AI calls and backend lookups never blocks the channel, and messages aren’t lost under load. In-app messages follow the same path through the internal chat APIs.
2. Identify. The orchestrator resolves who is talking. On WhatsApp the starting point is a phone number, and in the app it is a user ID. Both resolve to the same OLX user through an identity cache. It then loads the session: language preference, conversation history, and any flow already in progress.
3. Classify. It works out what the user wants, using the message together with the context . The same words mean different things mid-flow. “Yes” is meaningless alone but is a confirmation when VAYA AI has just asked a question.
4. Route. Based on intent and the current state, it picks the flow that should handle this turn.
5. Compose and save. The flow’s output is formatted for the channel and language, and session state is updated so the next message continues where this one ended.

Guided flows are the right choice wherever correctness matters more than flexibility, such as payments or required listing fields. Agent-led flows are the right choice wherever users say something unpredictable. The orchestrator lets one conversation move between them.

Keeping state across turns

A flow is only useful if it remembers where it is. For each conversation, the session layer holds:

• the active flow and its current step.
• the details collected so far (for example, the category and price of an ad being posted)
• the user’s identity and language preference
• recent conversation context for the agents

This state lives in a fast session store, with durable conversation history written separately by the chat service. Keeping the hot state fast and the history durable lets a conversation continue smoothly even when messages arrive minutes or hours apart, which is common on WhatsApp.

Failure and fallback

Reliability matters as much as intelligence in a customer-facing bot. The orchestrator is designed so that failures degrade gracefully:

• Unclear intent. Ask one short clarifying question instead of guessing.
• Slow or failed dependencies. Time out, retry where it’s safe, and tell the user plainly if something can’t be done right now.
• Duplicate messages. Channels sometimes deliver the same message twice, so processing is made safe to repeat.
• Dead ends. After repeated failures, offer a handoff to a human rather than looping.

Adding a new flow

Because channels, identity and state are handled once in the orchestrator, adding a new chat flow is a contained change. A new flow declares which intents trigger it, what state it needs and which services or agents it calls. It then plugs into the same routing, session and delivery path. It automatically works on both WhatsApp and the app in every supported language without touching the channel layers.

Observability

Every message carries a conversation and flow identifier through the whole path from webhook to reply. This makes it possible to see which flow handled a turn, where users drop off inside a guided flow, and how often conversations end in a handoff.

Intent classification

Every message that reaches VAYA starts with the same question like what does this person want? Intent classification is the first decision the orchestrator makes and everything after it depends on the answer. If the intent is wrong, the right agent never gets the request, the wrong flow starts and the user has to repeat themselves. It is a small step that has a large effect on how good the whole assistant feels.

The diagram below shows where it sits and what it can decide.

What the classifier has to handle

On paper, intent classification looks simple like map a sentence to a label. In practice, VAYA’s users make it harder in several ways:

• Mixed languages and scripts. “Delhi mein 5 lakh ke around koi achi used car dikhao” and its English equivalent must land on the same intent.
• Very short messages. “Price?”, “Yes,” or “Haan” mean nothing alone and depend entirely on what came before.
• Context-dependent meaning. The same word can answer a question inside a guided flow or start a brand-new request.
• Unstructured phrasing. People skip grammar, misspell words, and use informal terms for categories and brands.
• Out-of-scope requests. Users will ask for things VAYA doesn’t do, and it should recognize that instead of forcing the closest intent.

The intent taxonomy

VAYA groups intents by what the user is trying to achieve. A well-designed taxonomy is what makes routing predictable.

How it works

• Model-based. A fine-tuned classifier trained on labeled OLX conversations, with the model type if shareable.
• LLM-based. A language model prompted with the intent definitions and examples, returning a structured result.
• Hybrid. Fast rules for obvious cases such as button taps and menu selections, and a model for free text.

Whichever approach is used, the classifier doesn’t see the message alone. It also receives conversation context: the active flow, the last question VAYA asked, and recent turns. This is what lets “yes” mean “confirm my package purchase” in one place and nothing at all in another.

Handling many languages

Rather than training a separate classifier for each language, VAYA treats language as part of the input. The practical result is that an intent works the same on WhatsApp and in the app, in English, Hindi, or a mix.

Confidence and fallbacks

The classifier returns an intent along with a confidence score, and the orchestrator acts on both:

• High confidence. Route straight to the matching flow or agent.
• Low confidence. Ask a short clarifying question, ideally offering the likely options (“Do you want to search for cars or check your packages?”), instead of guessing.
• Out of scope. Say plainly what VAYA can help with, and offer a human handoff when the topic is something VAYA shouldn’t handle.

Intent versus flow state

There’s one subtlety worth explaining to readers. Inside a guided flow, most messages aren’t new intents. They’re answers to the question VAYA just asked, such as a price, a category, or “yes.” So the orchestrator checks the flow state first and decides whether the message is:

1. an answer to the current step,
2. a correction of an earlier answer,
3. an interruption with a new intent, such as a question about packages while posting an ad, or
4. a cancellation.

Only then does the intent classifier’s output decide where the conversation goes next. This stops the bot from misreading a simple “5000” as a brand-new request.

OLX Use Case

OLX is a two-sided marketplace, so VAYA has to be useful to people on both sides: buyers who want to find the right listing quickly, and sellers who want to reach the right buyers and get more from the platform. This section walks through the main journeys VAYA supports. Each one starts with something a user would actually say, and each is handled by the capabilities described earlier: intent classification, orchestrated flows, specialized agents, and structured search.

1. Search Listing

This is the most common journey and the clearest case for natural language. Instead of choosing a category, setting a location, adjusting a price slider, and applying filters, the user just says what they want, in any language or mix.

User: Delhi mein 5 lakh ke around koi achi used car dikhao
VAYA: [Shows a short set of matching listings with key details]
User: Sirf 2018 ke baad ki
VAYA: [Narrows the results to 2018 or newer]

What happens behind the scenes :

The message is classified as a search intent, routed to the search agent, converted to a structured query (category, location, price range, condition), validated against OLX’s catalog and run through the existing search service. The follow-up is treated as a refinement of the same search, so the user never has to repeat the earlier details.

2. Manage Packages

Sellers often don’t know where to find their package details or what the right package for them is. In a traditional app this means hunting through screens. In VAYA it is a single sentence.

User: Show me all my active packages
VAYA: [Lists the user’s active packages with the key details]

Because this is personal account data, VAYA needs to know exactly who is asking. Identity resolution ties the WhatsApp number or app account to the OLX user, and the account agent reads the data through the aggregation layer, never from the model’s memory. Buying or upgrading a package is a good fit for a guided flow, with each step confirmed before anything is charged.

3. Elite Experience Discovery

Features like Elite buyer are easy to miss and users often don’t know what to ask for. A conversation lets VAYA explain the offering in the user’s own words and move naturally into action.

User: [Question about premium or Elite]
VAYA: [Short explanation tailored to the question, with a next step]

4. Leads Search

Sellers want to know who is interested and how to get more attention for their ads.

User: [Seller message about leads or visibility]
VAYA: [Response and suggested next step]

5. Support

Support requests range from simple questions that VAYA can answer to issues that need a human.

User: Connect me to customer care
VAYA: [Confirms and hands over to support, with a summary of the conversation so far]

The support agent handles routine queries directly. When the user asks for a person, or VAYA can’t resolve the issue, the conversation is handed off with context attached so the user doesn’t have to start over.

6. Proactive Nudges

Not every journey starts with the user. VAYA can start the conversation when something relevant happens, such as a reminder for a seller to finish a listing, an update on something a user viewed, or a prompt to come back after some time away. The user’s reply goes through the same orchestrator and agents, so a nudge becomes a completed task inside the chat.

VAYA: [Timely, relevant message from OLX]
User: [Reply]
VAYA: [Continues the conversation and helps the user act]

7. One experience across WhatsApp and the app

All of these journeys work the same way on both channels. A user can start a search in the app and continue it on WhatsApp in the same language and with the same context because the conversation logic and identity are shared.

Future Scope

VAYA today turns natural language into action across WhatsApp and the app in English, Hindi, and a mix of both. The foundation is built to grow: a channel-agnostic orchestrator, a backend-driven design, specialised agents and a proactive engagement pipeline. That means most of what comes next is a matter of adding capabilities to a system that already works, not rebuilding it.

1. More languages and richer language understanding

VAYA already handles English, Hindi, and code-mixed text. The natural next step is deeper coverage of [regional languages, e.g. Marathi, Tamil, Bengali, Telugu], where many OLX users are most comfortable. Because language handling lives in the shared core, each added language improves the app and WhatsApp together. We also want to get better at the hardest cases: heavy code-mixing, regional spellings, and local names for brands, models, and places.

2. Voice and multimodal input

Many users find speaking easier than typing, especially in their own language. [Voice messages on WhatsApp or in the app converted to the same intents and flows already in place.] Images are another opportunity. A seller could share a photo to help create a listing, or a buyer could share a picture of what they’re looking for.

3. Deeper personalization

Today VAYA understands what the user says. Next, it can make better use of what it knows about their journey on OLX: past searches, saved interests, and the kind of listings they engage with. The aim is for “show me something good” to return results that feel chosen for the person asking, not just matched to keywords. Personalization also raises the bar on privacy, so it will be built around clear user control and the minimum data needed.

4. Smarter proactive engagement

The proactive pipeline already supports rules, templates, and multi-channel delivery. Future work is about making those nudges more timely and more useful: better judgment about when and whether to reach out, messages tailored to what each user cares about, and tighter limits so VAYA only speaks up when it adds value. Success here is measured by how often a nudge becomes a completed task, not by how many messages are sent.

5. More agents, more categories, more journeys

The multi-agent design makes it straightforward to add specialists. Possible additions include [seller assistance for pricing and listing quality, deeper support for property or jobs, negotiation or scheduling help between buyers and sellers]. Because new agents plug in through the same orchestrator and aggregation layer, each one inherits the channel, identity, and language support for free.

6. Better intelligence behind the scenes

Several improvements aren’t visible to users but make everything better:

• Sharper intent classification as the taxonomy grows and real conversations teach us where the boundaries are.
• More robust structured search, with better handling of ambiguous or subjective requests.
• Continuous evaluation, using real conversation outcomes to catch regressions and guide improvements.
• Efficiency, matching the right model and approach to each task so responses stay fast and costs stay predictable.

Conclusion

Behind most OLX journeys is a person who knows what they want but not where it lives in the product. VAYA’s goal is to close that gap, so the user speaks and the system finds the way. This post covered the problem, the architecture, and the main building blocks. We’re looking forward to sharing more as VAYA grows.