Skip to content
HublinkTech
In development
Ara

The same product, described in languages that share no script.

Ara is the trade intelligence engine HublinkTech is developing. Its core decides whether two descriptions, written in different languages under different naming conventions and customs codes, refer to the same thing. Everything else Ara does is built on that decision. It runs inside our own platforms first and is designed to be licensed to others as an API. It is in development.

The resolution problem
paslanmaz çelik vida M8 × 40 mm
不锈钢螺栓 M8 × 40 毫米

embedding space

near is not the same

trade ontology

built in-house

exampleHS 7318.15

same entity
different entity
refuse to answer
two descriptions · one decision · three admissible answers

The engine

Three layers, one decision underneath.

  1. Ara Core — resolution

    In development

    Product, company and HS code, resolved across languages, with a confidence level and the option to refuse. This is the research, and it is in development.

  2. Ara capabilities — built on Core

    • Matching between buyers and suppliers, with the reason for each match

    • Reading requests for quotation into structured specifications

    • Building company profiles from websites and catalogues

    • HS classification with the source of each decision

    • Screening of parties and goods

    • Reading trade documents: invoices, packing lists, certificates of origin

    • Route risk by origin, destination and product

    • A trade assistant that works in the user's language

    • Demand signals by product and market

  3. Ara API — for other platforms

    The same capabilities, for trade platforms, logistics providers, chambers of commerce and banks serving exporters. Designed, not yet available.

Some capabilities already run inside Hublinkly on established language models. Each one moves onto Ara Core when Core passes the gate that capability depends on.

The problem

What has to be decided.

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.

example

HS 7318.15

The uncertainty

What we do not know yet.

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.

01

Does semantic matching survive a change of script?

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.

02

Does an ontology built for one corridor generalise to another?

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.

03

How does the system know it should not answer?

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

How we are testing it.

The method is chosen so that a negative result is legible: when something fails, we want to know which part failed.

[01]

Embedding-based semantic matching

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.

[02]

A trade ontology, built in-house

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.

[03]

Evaluation per language, against a human baseline

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.

[04]

Refusal scored as an outcome

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

What has to hold before the next one starts.

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.

  1. 01 / 04

    Baseline within a single language

    Gate

    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.

  2. 02 / 04

    Across scripts

    Gate

    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.

  3. 03 / 04

    Transfer to an unfamiliar corridor

    Gate

    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.

  4. 04 / 04

    Refusal and confidence

    Gate

    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 Ara runs

One engine, several customers.

Hublinkly — the first platform

Hublinkly is the company network for global trade, and the first platform Ara runs in. Every match a member accepts, rejects or corrects becomes evidence for the next version of the engine.

Clavix360

Clavix360 is an AI CRM and ERP. Ara is designed to run inside it, so that products, suppliers and customers recorded in one language can be read in another.

The API

For organisations that need the same decision inside their own systems. Designed, not yet available.

Why the engine is separate

Ara is developed apart from the platforms it runs in. Hublinkly is a customer of Ara, not its owner. A component this open should be tested on its own terms before anything depends on it.

In development

Ara is in development.

If you trade across markets where descriptions and customs codes do not line up, we would like to know how you handle it today. Real product descriptions from your trade, in the languages you receive them, are the most useful thing you can send us.