a letter, before anything else
The pursuit of intelligence has not been solved. It has only just begun.
In the last few years, neural networks, what most people now call large language models, came online and changed the world, and changed what we believe artificial intelligence might one day do. Next-token prediction has produced genuinely astonishing results. These systems have mastered the medium we use to express our thoughts: language itself.
But mastering the medium is not the same as the reasoning beneath it. When a person speaks fluently, the fluency is the surface of something deeper: understanding, meaning, intent. That's exactly why fluent machines are so convincing: they produce the surface, and we assume the depth is there too. In any exchange with one of these systems, we know for certain that one side is intelligent: us. Whether the other side is, in the way we mean the word, is still an open question.
That question is where we began.
What we built.
We took a different path. We call it structural intelligence.
Instead of predicting the next likely word, or following the rigid, brittle rule-based systems that an earlier generation tried and abandoned, we built architectures that give a digital system an environment to reason in, and to reason in a way a person like you can actually follow, inspect, and understand. Not a black box that emits an answer. A system whose reasoning you can see.
We don't subscribe to the idea that predicting language is the same as understanding it. We don't subscribe to brittle systems that have to be rebuilt every time the problem changes. And we don't believe the only path forward is more optimization, more probability, more reward and penalty. We've spent a long time with a difficult question: can a machine reason structurally: legibly, repeatably, in terms a human can check?
The work is still evolving, daily, with real surprises. But it has reached the point where it is ready to do useful work in the world, and the difference shows the moment you see it run.
Your data is yours.
We believe this plainly. We do not train our systems on scraped data, and we do not need yours to make ours work. When you bring your data to our system, the data stays yours, and so does the reasoning we help you draw from it. Both remain with you, in your environment, now and always. The engine is built to run as a lightweight local sidecar over native IPC. Nothing has to leave your walls for this to work.
Why this matters right now.
Organizations of every size are under pressure to adopt AI, to keep up or risk falling behind. The newest wave is agentic AI: systems that don't just answer, but act: they move money, change records, send messages, run code.
That changes the stakes entirely. When a chatbot gives a wrong answer, someone catches it. When an agent takes a wrong action, the damage is already done.
And right now, the standard answer to "is the agent doing what it should?" is to place another probabilistic system next to it: one more next-token predictor, watching the first. We think that's the wrong answer. You can't get certainty by stacking one guess on top of another.
What we're bringing to market first.
Our first capability is agent action tracking, measurement, and enforcement. You don't have to take the philosophy on faith. As you'll see on the receipts, each of these runs, with the raw output shown:
It renders a verdict in microseconds, fast enough to judge an agent's proposed action before it executes, not after the damage is done.
It keeps a deterministic record of what the agent actually did, not the agent's own account of what it did, but a true, reproducible log of the committed action. The same record, every time.
And when an action crosses a policy you've declared off-limits, it renders a block verdict before that action commits.
Not guesses. Verdicts. The same input yields the same verdict, every time, because the system doing the watching is an invariant logic engine, not another probabilistic model. It's a deterministic one. Point it at your agents and the difference isn't something you have to be argued into. You watch it happen.
Where each of those stands, plainly. The witnessing, the record of what an agent did, captured deterministically at the moment it did it, is solid, and we'll say so without hedging. The enforcement is newer. Every figure behind it was measured on the real engine against an independent source of truth built to disagree if we're wrong, and before we put it in front of a live production system we intend to stress-test it considerably harder than we already have.
Some of those runs are against real public agent traces we didn't author. Some are synthetic, modeled on real telemetry with the test condition planted. The receipts label which is which, run by run, and print the cases the engine can't resolve rather than guessing at them.
One more thing. The part that matters most.
The entire field has bet on one approach to intelligence. Every major player now selling you tools to govern AI agents is built on the very thing they're protecting you from: they wrap it, they watch it, they score it, but underneath, it's the same probabilistic machine.
We didn't make that bet. We went a different way, on purpose, years ago.
As the models grow more capable, the deeper question only gets more worth asking: what is intelligence, and how do we build it? We don't claim to have finished answering it. We're still working. But this, watching an agent act with certainty and keeping what's yours yours, is the first piece we're ready to put in your hands.
If that's a problem you're wrestling with, I'd welcome a conversation.
Rob