Research · Universal resolver

A natural-language question, the right engine to answer it

A manager asks a question the way they would ask a colleague. The VVL universal resolver recognises what kind of problem it is, then hands it to the specialised engine able to solve it exactly: calculation, optimization, logic, expert system or extraction. It returns an answer together with its assumptions and its level of confidence.

How it works

The resolver is written in one line, in its long form or with its alias. It goes through four steps.

[resolve "Combien font 15% de 240 ?"]
[§§ "Combien font 15% de 240 ?"]          # même chose, forme courte

Classify the question
Check the confidence
Hand over to the specialist
Return an approximation

Classification is done by Jev when Jev mode is active, by the language model otherwise. If confidence is too low, below 0.55, no engine is run: the resolver asks for clarification instead of guessing. Otherwise the question goes to one of eight families of specialists.

Family	Engine used	Example question
Calculation	VVL code generated, then executed	Loan repayment, margin, ratio
Optimization	Constraint solver	Schedule eight tasks on three machines
Relational query	Prolog-style logic engine	Which customers depend on this supplier?
Rule induction	Rule learning	Which rule identifies loyal customers?
Factual retrieval	Language model and document base	What does our quality procedure say?
Extraction	Structured extraction, missing fields reported	Name, amount and due date of an invoice
Expert system	Expert registered in the session	Assess a credit application
Compound	Two to four chained sub-tasks	Extract a headcount, then calculate teams

The answer is never a bare value: it is an approximation that carries the value, a confidence that depends on how much came from the language model, a range, and the list of assumptions with their source. Each assumption can be replaced by a known value to replay the calculation.

Business examples

Finance: the monthly payment of a loan

The finance director asks the question as it is. The resolver classifies it as a calculation, has the amortisation formula written, then runs it.

$r = [§§? "Calcule la mensualité d'un crédit de 250000 EUR sur 20 ans à 3,5% taux fixe."]
$r.value           # 1449.90
$r.confidence      # "moderate" : la formule a été choisie par le modèle de langage
[approximation:trace $r]

Documented result: €1,449.90 per month, with the full trace of the calculation.

Human resources: a two-step question

The question mixes an extraction and a calculation. The resolver splits it into sub-tasks, runs them in order and combines the results.

$r = [§§? "Extrais le nombre d'employés de 'Acme Corp compte 87 employés', puis calcule combien d'équipes de 5 personnes on peut former."]
$r.value           # "17 équipes de 5"

Credit: the question is handed to the expert system

Once an expert system is registered in the session, the resolver recognises the questions that fall within its domain and passes them on. The decision is made by the expert's rules, not by the language model.

[expert "Domaine evaluation risque credit. Dossier client : nom, revenu,
 score_credit (eleve/moyen/faible), anciennete (longue/moyenne/recente),
 decision. ..." "Scoring"]
$r = [§§? "Évalue le dossier de Alice Dubois, revenu 4500, score élevé, ancienneté longue"]
$r.value           # {..., 'decision': 'approuve'}

Once the expert is built, each question costs a single language-model call, to extract the data from the application; inference uses none.

Investment: replaying the calculation with your own figures

A holiday-rental project is assessed from assumptions supplied by the language model. The manager replaces these assumptions with actual figures and the calculation is replayed, with no new call to the model.

$q = [resolve "Grange achetée 320 000 EUR, à rénover en gîte : en combien d'années est-elle rentabilisée ?"]
$q.value           # 35.55 ans (hypothèses : 50 nuits par an à 180 EUR)
$a = [approximation:revise $q [JSON '{"cout_renovation": 250000}']]
$a.value           # 27.78
$b = [approximation:revise $q [JSON '{"cout_renovation": 280000, "Grange.tarif_moyen_nuit": 220}']]
$b.value           # 25.45

When every assumption coming from the language model is replaced by a known value, the confidence becomes exact.

Control: checking the routing before trusting the answer

Before using an answer, you can ask the resolver how it classified the question, or get the full trace of the routing and of the generated code.

[resolve:classify "Combien font 15% de 240 ?"]   # {family, sub_kind, confidence, reasoning}
[resolve "Combien font 15% de 240 ?"]            # 36.0
[resolve:trace "Combien font 15% de 240 ?"]      # trace complète au format JSON

What it guarantees, and its limits

An ambiguous question is not guessed: below the confidence threshold, the resolver asks for clarification.
An extraction never fills in a field that is absent from the text: missing fields are reported.
Every answer carries its assumptions, their source and a level of confidence; it can be replayed with other values.
The resolver is not a chat assistant: it is used to solve questions that belong to a specific engine. It always uses at least one language-model call to classify the question.

Apply this work to your processes?

The diagnosis starts from how you actually work and identifies the decisions that can be entrusted to AI.

Get my assessment