Not built on top of someone else's model
VisorEngine is the probabilistic inference engine underneath MLVisor. It does not predict a next token — it reaches a solution by narrowing a mathematical probability space.
What VisorEngine is not
- An interface layer written on top of a language model
- A call out to OpenAI, Anthropic or anyone else's API
- A router that rewrites the prompt and forwards it outward
- A system that forgets context once a token budget runs out
What VisorEngine is
- A probabilistic inference engine we wrote from scratch
- Branch-and-bound search over a mathematical probability space
- A core that can run on your own infrastructure with no outbound connection
- An inference process whose every step is recorded and can be verified later
From one sentence to a production model, in six steps
Every step is recorded. The average end-to-end run takes around 7 minutes.
- 01
Data & prompt
The user states their goal in natural language and connects their data sources. SQL, files, or an existing Python data stack — the engine reads the source where it sits.
- 02
Intent resolution
The engine determines the real problem behind the sentence: is this a classification, a forecast, an anomaly detection? Solving the wrong problem perfectly is the most expensive failure mode there is.
- 03
Autonomous analysis
The data is analysed against that goal: distributions, missing values, leakage risk, discriminative features. This stage draws the boundary of what a model can possibly learn.
- 04
Probability space
The core step. Candidate solutions are represented in a mathematical probability space and pruned by branch-and-bound search. The engine is not predicting a next token — it is narrowing a solution space.
- 05
Dynamic build
The chosen solution is made concrete: the model is trained, a reproducible code stack is written, and the interface that makes the result usable is constructed automatically.
- 06
Report
Performance metrics, training curves and a live deployment report. How the result was reached stays as visible as the result itself.
What the approach changes in practice
An architectural choice that turns into something concrete at every layer of the product.
No context decay
A language model has to fit data into a window, and accuracy degrades once that window fills. Search over a probability space does not scale with dataset size in the same way.
Traceable inference
Branch-and-bound knows which branch was pruned and why. The result does not fall out of a black box; the steps can be shown, and a re-run follows the same path.
Predictable run time
An average run takes around 7 minutes — a loop that costs a data scientist weeks compressed into the length of a coffee break.
Vendor independence
There is no external model vendor, so a price change, a rate limit or a deprecated API cannot reach you.
On your own infrastructure
The engine is self-contained, so it can be installed next to your data. The hardest question in enterprise procurement is answered by the architecture itself.
Portable output
The generated code and the model are yours. Even if you walked away from the engine, you would keep a working, readable stack.
Today the engine reasons from data. The target at the end of the roadmap is data-independent reasoning: a core that can solve an equation, play a game, and carry a learned structure into a domain it has not seen. Every version in between ships with a public benchmark.
See the full roadmapWant to look at the engine more closely?
For technical documentation, architecture conversations and evaluation deployments, write to the team directly.