The lingua franca ofbusiness data.

Every software platform speaks its own dialect of "business data." Salesforce's "customer" is not HubSpot's "contact" is not Stripe's "payer" is not your finance system's "account" — and yet they often mean the same person. For thirty years the industry has treated the resulting mess as an integration problem: build a connector between A and B, then another between B and C, then watch them all break the moment either side changes.

Inferrex starts from a different premise. The problem was never moving data between systems. It's that no layer actually understands what the data means. Integration is a comprehension problem — and once you solve comprehension, integration stops being something you build by hand and becomes something that simply follows.

Inferrex is a comprehension layer for business data. It reads the structure of every platform's data, works out what each field actually means, and creates a shared, governed representation that any system can communicate through — without forcing anyone to migrate, rename, or rebuild a thing.

The model for this isn't software. It's language.

Long before computers, humanity had exactly this problem: countless dialects, each perfectly adapted to its speakers, none able to understand the others. Nobody invented a different language to be difficult — each one adapted to its own context, the same way every vendor adapted "customer" to suit its own data model. Nobody was wrong. The problem only appeared when they needed to trade.

The solution that worked wasn't forcing everyone onto one tongue. It was the emergence of a lingua franca — Aramaic, Greek, Latin, Arabic, English in turn — a shared language that sat above the local dialects and let them communicate. Crucially, a lingua franca never replaced the languages beneath it. People kept speaking their own at home. The shared layer was a bridge, not a bulldozer. And it won not by decree but by usefulness: each new speaker made it more valuable to every existing speaker, until the cost of not speaking it was isolation, and adoption became inevitable.

A lingua franca also does something subtler — it absorbs. Latin took in Greek philosophy, Arabic mathematics, Germanic law. English borrowed entrepreneur, tsunami, avatar, algorithm. Each borrowed concept made the language richer for everyone, because no existing word captured that exact nuance. The language didn't dilute as it absorbed; it became more complete.

That is precisely how the Inferrex corpus works. Each provider that enters contributes concepts the others don't have — Stripe's payment-intent states, HubSpot's lifecycle stages, FHIR's clinical observation hierarchies — and the shared model gets richer with every one. The next provider to connect finds more of its own concepts already understood, because something structurally similar arrived before it. It isn't a dictionary that freezes the language in place. It's a living language that grows.

This is the worldview behind everything Inferrex builds: allow everyone to be different, understand the differences, and adapt yourself to bridge them — rather than forcing everyone to adapt to you. It applies to data integration, to how the AI is built, and to how the product is designed.

There's a reason "understanding" has to be taken literally here, and it matters more in the age of AI than ever.

The off-the-shelf AI models are trained on the open internet — the largest collection of unverified interpretations ever assembled. For any claim you want to be true, there's a source that confirms it. These models don't know which sources are authoritative, when something was last true, or whether a "fact" is a primary source or a copy of a copy of a misinterpretation. They generate confident text and move on. The lineage is invisible, so the trust is misplaced.

Inferrex is built the opposite way. Every value in the corpus has explicit provenance: where it came from (a specific provider's specification, a specific version, a specific file — not "somewhere online"), how it was classified and with what confidence, when it changed, and what validated it against real data. When a business asks "what does this customer look like across all our systems?", the answer isn't "the AI thinks so." It's traceable: this system says X, last updated then, authoritative for this field; that system says Y, not authoritative; here's which one wins and why.

This is also why AI cannot be a shortcut around the hard work. Point a model at fragmented, duplicated, unreconciled data and it doesn't fix anything — it amplifies the mess, faster and more confidently, and the business trusts the output more precisely because it came from an AI. The comprehension layer has to come first. Build the reconciled, governed, provenance-tracked view of your data — then let AI work on top of it. Get that order right and AI becomes genuinely powerful. Get it wrong and you've automated your worst data.

The same principle that governs the data governs the engineering. Inferrex doesn't hand-build integrations, and it doesn't hand-write the code that runs the platform either.

Everything that follows a pattern is declared once in a manifest and generated from it — service definitions, deployment configuration, database schemas, API routes, SDK methods, the connection logic between providers. If something needs to change, the manifest changes and the platform regenerates. Handwritten code is reserved for genuinely bespoke logic; everything else is produced from a single declared source of truth. There is no drift between what's specified and what's running, because the specification is what's running.

This is the architecture living out the philosophy. A lingua franca is a governed layer that everything else is generated and reconciled against. So is a manifest. The corpus comprehends external data from one canonical model; the codegen builds the platform from one canonical definition. Same idea, applied in two directions: understand the structure, hold it in one authoritative place, and let everything else follow from it rather than being maintained by hand.

The result is a platform that auto-generates integrations across a vast and growing corpus of API providers, normalises many schema formats into a shared semantic model, and improves itself through a self-contained learning loop — without distillation from external frontier models, so the improvement stays sovereign to the data it's trained on.

Because the entire stack — comprehension, inference, and reconciliation — can run with no external dependencies, Inferrex isn't limited to the cloud. It's offered across three tiers: a managed SaaS platform; an enterprise deployment inside a customer's own cloud environment; and a sovereign, air-gapped, on-premise deployment for organisations whose data legally or operationally cannot leave their perimeter — regulated industries, critical national infrastructure, government, and defence-adjacent settings.

In the sovereign tier, the self-improving loop runs entirely within the customer's security boundary: the system gets better at understanding their data without a single byte of that data ever leaving. The comprehension layer comes to the data, rather than the data being forced out to it. That, again, is the lingua franca principle — adapt yourself to meet the other party where they are.

Inferrex was founded by Aaron Gammon, who built it drawing on roughly two decades in enterprise software — selling and implementing data protection, marketing automation, and integration platforms into large, complex organisations, and seeing the same comprehension failure repeat in every one of them. The recurring pattern he watched go unsolved for eighteen years is the thing Inferrex exists to fix. (More on Aaron's background and the story behind the company is on the Founder page.)

Live platform figures — provider counts, schema coverage, model accuracy, and more — are published and kept current at inferrex.com/claims.