Sequena sits between a shopper and a catalog, converting how people actually speak — regional words, mixed languages, use-cases, problems — into structured commerce intent that retrieval systems can act on.
Traditional search matches strings against catalog titles. If the shopper's words aren't the catalog's words, it returns noise — or nothing.
Sequena resolves the underlying commerce concept, extracts requirements and constraints, and searches evidence across descriptions, specs and reviews.
"domala bat" maps to mosquito control → electric racket as a commerce concept — not a word-for-word translation that still misses the catalog.
A backpack titled "Travel Laptop Backpack" still matches "shoe compartment" because the requirement lives in its description.
Every result answers "Why this product?" with the exact catalog surface — title, description, spec or review — that satisfied the intent.
The benchmark corpus is real — every query was tested by hand on live marketplace apps and the results recorded as observed. The product catalog here is synthetic, built to demonstrate retrieval behaviour without scraping anyone's inventory. The engine is a rule-based baseline, not a trained model — you can see exactly how far that gets on the Benchmark tab, failures included.
This is the layer itself — no catalog, no products. Type a query the way a real shopper would say it and see the structured intent object Sequena emits. This object is exactly what the API returns to a marketplace, and what its existing search stack consumes.
Understanding the query is step one. Next: does it actually retrieve better products than keyword search?
Step 1 showed what Sequena understands. This shows what that understanding is worth: the same query run through traditional keyword matching (left) and through Sequena's intent-aware retrieval (right), against the identical catalog. The difference between the two columns is the entire product.
These are live-tested queries run against real marketplace apps and recorded by hand. The statistics below measure how existing platforms performed. To see how Sequena itself scores on this same corpus, use the self-evaluation panel — it grades the engine honestly, failures included.
Evaluates the intent engine on all 199 real queries and reports how many it resolves to the expected product concept. This is Sequena grading itself — honestly, including the failures.
How the 199 tested queries actually landed.
Share of queries returning a wrong result, per platform tested.
What actually goes wrong, grouped by the error type recorded during testing.
Not all languages are neglected equally — this is the clearest signal in the corpus.
Both input modes were tested by hand on the same platforms.
On voice queries the platform first has to transcribe what was said. When that transcription is wrong, search is answering a question the user never asked — and no amount of retrieval quality can recover it.
| # | Query | Language | Platform | Expected | Actual Result | Status | Error Type |
|---|
Every number below is computed from the test corpus, not estimated. Where a sample is too small to support a claim, it says so rather than quietly rounding it into a headline.
The failures are not random. They concentrate exactly where a shopper has given the platform no English to hold onto — a bare Telugu noun, spoken aloud, with no brand or number attached. Add an English word and the failure rate drops from 60% to 43%. Say it out loud instead of typing and the transcription is wrong more than half the time. Those are the same shoppers, on the same apps, asking for the same products. What changes is only whether the platform happens to recognise the surface form of the words.
That is the case for an intent layer rather than better keyword matching: the shopper's meaning is intact and unambiguous every time. It is being lost in transcription and in string matching, not in the request itself.
Every product here carries a full description, specification block and review text — not just a title. That's deliberate: it's what makes multi-surface matching demonstrable. A shopper asking for a "shoe compartment" finds the right bag because the requirement lives in the description, never in the product name. A title-only catalog couldn't show that difference.
Sequena does not own the catalog. It sits between the shopper and whatever retrieval system a marketplace already runs, emitting a structured intent object that existing search infrastructure can consume.
{
"query": "domala bat",
"language": "auto"
}
{
"intent_type": "local_vocabulary_to_product",
"product_concept": "electric mosquito racket",
"category_hint": "Home Care",
"attributes": {},
"constraints": {},
"language": "English/Romanized",
"confidence": 0.9
}
POST /search → intent object + ranked products + evidence POST /benchmark/evaluate → run a benchmark corpus through the engine GET /catalog → demo catalog listing
Python engine (intent parsing, IDF-weighted multi-surface retrieval, explainable reranking) with a provider-agnostic AI abstraction — a rule-based parser ships as the zero-dependency default, and an LLM parser can be enabled via environment variables without touching the rest of the system. This browser build embeds the same engine logic so the demo runs with no server and no API key.
Sequena is being built as an intent intelligence layer for Indian commerce — where the gap between how people speak and how catalogs are indexed is widest.
Shoppers use regional languages, Romanized script, local product names, mixed languages, use-case descriptions and problem statements. Catalogs are indexed in formal English product terminology. Every query that crosses that gap is a lost transaction.
An API layer for e-commerce, grocery, fashion, food delivery, pharmacy and travel platforms — starting with the languages and vocabulary that global search vendors underserve, then generalizing outward.
This is a demo, not an MVP — it runs on a synthetic catalog, does not connect to any live marketplace, and does not scrape marketplace data. Its job is to make the problem and the approach tangible, nothing more. The benchmark section documents how existing platforms performed on real tested queries, and the self-evaluation panel there scores Sequena's own rule-based engine against that same corpus, publishing the failures alongside the wins. That baseline is deliberately unflattering: it exists to be beaten by a trained model, not to be quoted as a finished result.