Software Research Lab
We build reasoning engines.
Every intelligent product has a part that does the thinking — the part that gathers what is known, weighs it, checks it, and decides when an answer is good enough to act on. That part is the hardest to build well, and most teams rebuild it from scratch for every product.
Framework Labs builds it as a system in its own right. One hard problem, solved once, built to be relied on.
A lab, not a product company.
A reasoning core solves one general problem in machine reasoning, and it has to be right in general — not right once, on a good day, for a single use. So we build it as a standalone system, designed for the cases that only show up at the edges: bad inputs, conflicting sources, the conditions that appear under load.
The core is the work. The products built on it — the interfaces, the domains, the deployments — change on a faster timescale and are a separate concern. Keeping that line clean is what lets one core hold up across many domains, and improve every time it meets a new one.
Two cores are in production today, and a third is in development.
Three engines.
A portfolio of cores · the registry is built to hold N
Concordia
consensus engine
A defensible answer from sources that disagree — drawn from multiple independent sources, reconciled where they conflict, and checked against a fixed standard before it returns anything.
IN PRODUCTION
AT CHIRON'S FORGE
Continuum
crystallization engine
Spoken knowledge, turned into structure — hours of unstructured human conversation converted into organized, queryable knowledge, with every result traceable to the words that produced it.
IN PRODUCTION
AT TENURE SYSTEMS
Praxis
statutory computation engine
Praxis interprets a conditional rule of law, traces it through the chain of modifiers that govern it, applies the facts of a specific case, and produces a defensible, citable computation.
IN DEVELOPMENT
Read more →How we work.
Build for the edges.
A core that works on the easy case is not finished. The hard part is the input that is malformed, the sources that disagree, the moment the system is wrong and has to notice. That is where a reasoning core earns its keep, so that is what the design is organized around.
Verify before returning.
Each core holds its output to a standard before it returns anything. A result that cannot meet the standard is not returned as though it had. The check is part of the core, not a step left to whoever builds on it.
Prove it, then publish it.
Our cores are built for measurable results, and measurement is underway. We are preparing those results for independent review, and we will publish them once they have been reviewed — not before. Until then, the architecture and the method are what we put forward.
Validation is underway.
The two cores in production are under active measurement, and the results are being prepared for independent peer review ahead of publication.
We have held back the figures on purpose. A core that verifies its own output before returning it should hold its own claims to the same standard — measured, checked, and defensible before they are stated.
A small lab in Buffalo, New York.
Framework Labs is a two-person lab. We decide deliberately, write down what we decide and why, and hold what we build to a standard before our name goes on it.
Licensing
Build on one of our engines.
If you are building a product whose core depends on machine reasoning, the engines can be licensed.
Licensing