AraAra is a research project at HublinkTech. Its core is cross-lingual entity resolution over a trade ontology we build in-house — deciding whether two descriptions, written in different languages under different naming conventions, refer to the same thing. It is in development.
embedding space
near is not the same
trade ontology
built in-house
exampleHS 7318.15
The problem
A buyer in one country describes a product one way. A supplier in another describes what may be the same product differently, in another language, under a different commercial naming convention. Between them sits a customs code that both are supposed to use — and that the two countries do not use the same way.
Resolving those descriptions to a single entity is the problem underneath both of our trade products. It is not a translation problem. The words can be translated correctly and still fail to meet, because the categories behind them were drawn differently in the first place.
HS codes are the nearest thing to a shared reference, and they are applied inconsistently between jurisdictions: the same good sits under different headings depending on who is classifying it and why. National taxonomies extend the shared part of the code in directions that do not align with one another. So the reference itself is unreliable, the descriptions are in languages that share no script, and the correct answer is sometimes contested between two authorities that are each right within their own jurisdiction.
HS 7318.15
The uncertainty
These are the open questions, written as questions because they are not settled. Each one can be answered negatively, and a negative answer changes what gets built.
Embedding-based matching rests on the assumption that meaning survives the move into a shared vector space. Whether that holds between languages with no common script, no shared commercial vocabulary for the goods in question, and different conventions for naming a product to a customer, is not something we are willing to assume from published results on general text. It has to be measured on trade descriptions, in each language separately.
The ontology is built from the corridors we know. Whether the structure it encodes is general to trade, or specific to those corridors, is unknown until it is tested against a corridor it was not authored from. A structure that only works where it was written is a lookup table wearing an ontology's name.
A matcher that always returns its nearest candidate is useless here, because a confident wrong classification costs more than no classification. Where the boundary sits between a match, a ranked set of candidates and a refusal — and whether that boundary can be derived from the model's own signals rather than a hand-set threshold — is open.
The method
The method is chosen so that a negative result is legible: when something fails, we want to know which part failed.
Descriptions are resolved by meaning rather than by string overlap, so that a product named one way in one market can meet the same product named another way in another. The embedding is the part under test, not the part assumed.
The ontology encodes what the codes leave implicit — how goods relate to one another, and where national extensions diverge. We build it ourselves because we found nothing that covers the corridors we work in at the granularity the problem needs. It is also the component we can inspect when a match is wrong.
Each language is evaluated on its own set rather than assumed to inherit from English, and the baseline is a person doing the same task. Nothing advances on an aggregate score, because an aggregate hides exactly the languages we are least sure about.
Whether the system declines is measured alongside whether it is right. A run that answers everything and a run that answers only what it should are not the same result, and only one of them is usable in a shipment file.
The phases
Each phase has a gate. The gate is not a date and not a score to beat — it is a thing that has to be demonstrable before the following phase is worth beginning.
01 / 04
A stable evaluation set, and a baseline measured the same way for the person and for the system. Without that, every later comparison is against a moving target.
Establish the evaluation set and the human baseline, and show that semantic matching beats string matching inside one language, before any cross-lingual claim is made at all.
02 / 04
The gap against the single-language baseline is attributable. We have to be able to say which failures come from the embedding, which from the ontology, and which from the code system itself. If the failures cannot be attributed, the phase has not closed, however good the aggregate looks.
Run the same resolution task between languages that share no script, and compare against the single-language baseline established in the first phase.
03 / 04
Either the structure holds, or we can state exactly what had to be added — and whether that addition is general or another special case. A list of special cases is the negative result for this phase.
Apply the ontology to a corridor it was not authored from, without extending it first, and record where it breaks.
04 / 04
Refusal correlates with actual error rather than with unfamiliar phrasing. Until it does, the confidence signal is not a confidence signal, and the component cannot be put in front of a shipment.
Decide when the system answers, when it returns a ranked set, and when it declines — and derive that decision from its own signals rather than a tuned threshold.
Where it applies
The resolution engine is not built for Ara alone. Both of our trade products ask a version of the same question, against a different reference.
Whether what one company offers and what another is sourcing are the same thing, described differently by two businesses in two markets. The reference on the other side is another company's catalogue.
Whether a description in plain language resolves to a position in a regulatory reference, so that classification, duties and documentation can be answered from it with sources attached rather than guessed.
It is researched separately from either product for the same reason it is described here as uncertain: a component this open should not be discovered inside something already shipping to customers.
In development
We are developing Ara as part of HublinkTech's applied AI research, in Istanbul. If you trade across corridors where this problem is yours too, we would like to hear how you handle it today.
