A different kind of AI

Why we are building a different kind of AI

Most AI is, at its core, autocomplete.

Given enough data, a model learns to predict what comes next. Feed it years of market prices and it learns correlations. Feed it text and it learns to complete sentences. The mechanism is the same regardless of domain: find the patterns, compress them into a fixed set of weights, reproduce them when asked.

This is genuinely impressive. But pattern matching is not understanding. And the difference matters enormously when conditions change.

When the patterns change

Markets shift. Biology surprises us. Physical systems evolve. When they do, the correlations a model spent months learning stop holding, and the model fails. Not because it was poorly trained. Because it was trained to find patterns rather than causes.

A model that has learned that A tends to follow B has no idea whether A causes B, whether both are caused by something else, or whether the relationship only held during training. Ask it what happens if you intervene and change A, and it has no honest answer, because it has only ever seen what did happen, never what would happen. When conditions change, it has nothing to fall back on.

There is a second problem underneath the first. Every AI model in production today stopped learning the moment training ended. Whatever it knows, it knew on the day it shipped. Every observation after that is invisible unless someone retrains it, at enormous cost, with the risk of forgetting what it already knew. The workarounds are familiar: retrieval layers, fine-tuning runs, longer context windows. They are machinery built around a model to compensate for the fact that the model itself cannot learn.

These are not product limitations to patch with clever prompting. They are consequences of the architecture. Every one of those models is a transformer, and both problems, frozen after training and correlational by construction, follow from what a transformer is.

What we built instead

We did not build a transformer. We built a different architecture, from first principles, around a different set of commitments.

The first is that a model should keep learning. In our architecture, knowledge is not compiled into frozen weights and then locked. It accumulates as a log. The model learns from every new observation, permanently, with no retraining run, and its active memory stays bounded no matter how much it has seen. Continuous learning is not a feature we added. It is what the architecture does.

The second is that a model should learn cause, not correlation. Our models learn from interventions and transitions, what a system looked like before an action, what was done, what it looked like after, so that causal structure is part of what the model represents rather than a statistical lens applied afterwards. That is what lets it answer the question autocomplete cannot: what would happen if this changed.

The third is that intelligence should not require a datacentre. Our models run inference on ordinary CPUs. A GPU is used for heavy initial training, never to run the model. That means it can live where the data is, on a device, inside a private environment, at a cost that does not depend on renting scarce hardware.

And one thing followed from these that we did not set out to build: two models trained separately, on different data, can be merged into a single model that knows what both learned, exactly and losslessly, with no retraining and no raw data exchanged. This is not possible with transformers. We think it matters more than it first appears, and we will write about it separately.

What we have seen

The architecture has now been validated across eleven heterogeneous domains, physical dynamics, biological networks, market behaviour, and others, running as a single model with no regression between them. In counterfactual tasks, the hardest test of whether a model has learned causes rather than patterns, it substantially outperforms standard baselines across every random seed. One result we found no published precedent for: adding a language domain to the model improved its performance on physics. Causal structure appears to transfer across fields in ways we did not predict.

We are deliberately not reproducing the numbers here without their baselines named beside them. That belongs in a proper technical write-up, which is coming. What we can offer now is something you can run: a live causal forecast of when quantum computing breaks today's encryption, built on the architecture, which you can intervene on and watch recompute. https://quantum.causisresearch.com/

Where we are honest about the edge

Our proven ground is numeric and structured data: systems with real, checkable dynamics, where causal reasoning is both testable and valuable. We have not built a language model, and we are not claiming to have. Extending the architecture toward language and more general reasoning is the direction we are working in, and it is genuinely in progress. We would rather tell you exactly where our results end than imply a capability we cannot yet demonstrate.

Where it is going

The model at the core of Causis Research began in 2024 as an independent research project, out of curiosity rather than a commercial brief. It kept passing tests it was not designed to pass. Two years and several hundred experiments later, it became impossible to ignore, and in April 2026 it became a company.

Our first product is Anna: an AI that sets up and runs an organisation by conversation. You describe what you need, it builds the team, and the team keeps learning, because the architecture underneath it does. It is in testing now.

We will publish findings here as they develop, when something is worth saying. If you are working on a problem where the pattern-matching ceiling is not theoretical, we would like to hear from you.