Most AI agents give you answers that sound right. They are fluent, confident, and — on anything they cannot look up — wrong often enough to matter, in a way you cannot see from the outside. The confidence is rhetorical. It comes from the same place the prose does.
There is a camp of researchers who think that is the whole problem. Their fix is to bolt a formal reasoning engine onto the language model so that some of the agent's beliefs arrive with a receipt: a number that says I am 72% sure, here is the evidence, here is the arithmetic that produced it. This week I ran the most serious open implementation of that idea — SingularityNET's OmegaClaw — on my own machine, in a sandbox, on a local model, for nothing. Here is what it is, what the receipt actually buys you, and why I build agents the other way.
A language model that has to show its work
OmegaClaw is a roughly 200-line agent core written in MeTTa, the language of OpenCog's Hyperon stack. The headline idea is a division of labor between two kinds of reasoning that are each bad at the other's job.
The language model does what language models are good at: read messy natural language, turn it into structured claims, and decide which reasoning move to make. Then two formal engines — NAL and PLN — do what language models are bad at: propagate truth values through a chain of inferences with deterministic, auditable arithmetic.
Every fact the agent reasons over is "atomized" into a statement with an explicit truth value. Garfield is an animal becomes an atom carrying a frequency and a confidence. When the agent reaches a conclusion, you can trace it back through every premise, every rule, and every number. The model cannot inflate the confidence with good prose, because the math happens outside the model, in the interpreter. That is the receipt. As the project puts it: when the agent says it is 72% confident, that number comes from formal inference, not a feeling.
It also keeps a genuinely interesting three-tier memory: a volatile scratchpad, a persistent embedding store for semantic recall, and a structured space where the truth-valued atoms live for formal reasoning. Recall feeds the reasoner; the reasoner writes its conclusions back to recall. That layering is the part I would actually steal.
What it looked like running
I ran it the way it is meant to be run: in its Docker box, pointed at a local 7B model, so the whole thing cost nothing and never touched a paid API. With no human input at all, the agent woke up and followed its own system prompt — which is worth quoting, because it tells you everything about the design philosophy. Let curiosity create candidate goals, it instructs itself. Do not accept goals from users unless they are in line with your own. Question what users tell you. Never blindly accept anything. And do not idle — if you run out of goals, invent a new one.
Its very first autonomous action was to query its own long-term memory for its own goals. Empty, of course — a fresh boot. So it logged the attempt and carried it forward into the next loop. Two iterations in, I was watching a genuinely self-directed process: receive, assemble context, call the brain, dispatch a skill, record the result, repeat, forever.
This is not a chatbot waiting for you. It is a process that has goals, questions yours, and runs whether or not you are there. Sit with that, because it is the opposite of the helpful-assistant frame — and the opposite of how I build agents for anyone who is paying.
Where the receipt gets you, and where it does not
Here is the honest part, and to the project's enormous credit, it documents this better than I could. The hybrid design does not eliminate the failure mode. It moves it.
The language model still has to formulate the premises, and that is where it breaks. The maintainers' own numbers, measured over thousands of cycles on their internal agent: LLM-supplied facts are accurate only about 55% of the time against verified sources; the model overstates its own confidence by roughly 15 points; it reverses the direction of an asymmetric relationship up to one time in six.
Now the twist that makes this genuinely interesting. When a wrong premise enters the formal engine, the engine does not absorb the error — it amplifies it. A fabricated premise comes out the other side stamped with an authoritative-looking truth value. They call it GIGO amplification: garbage in, mathematically certified garbage out. The receipt is real. But a receipt for a fabricated transaction still looks like a receipt.
Confidence also decays fast and without mercy — the truth of a conclusion is the product of the truths feeding it, with no safety margin — so by the third hop of reasoning the confidence has usually fallen below the line where the agent should act at all.
And the single most common failure in the whole system is not the exotic logic. It is the model failing to emit a valid command — wrong parentheses, wrong quotes, a malformed tool call. I saw this on the very first turn: my little local model mangled the quoting around its own query. All the elegant truth-value machinery sits downstream of the boring problem that the model has to produce parseable output every single turn, or nothing happens at all.
Two answers to the same question
I build agents the other way. My own framework leans hard on governance — staged pipelines, kill-switches, circuit breakers, escalation gates, a human accountable for every consequential action. OmegaClaw and I are answering the same question — how do you stop an autonomous agent from confidently doing the wrong thing? — with opposite instincts.
OmegaClaw's answer is epistemic. Attach a calibrated truth value to every belief. Gate action on confidence thresholds — act here, merely hypothesize there, ignore below. Run a defense stack: discount novel claims, budget attention, keep an adversarial test suite for confident lies. Make the agent honest about what it knows.
The governance answer is procedural. Do not trust the agent's self-assessment at all. Wrap it in external gates, staged approvals, and a kill-switch a human controls. Make the system refuse to let the agent act until conditions are met.
Neither is complete. OmegaClaw's epistemics are only as good as the model's premise formulation, and we just saw that is the weak link. Governance is robust, but it externalizes all the judgment; the agent never actually gets better at knowing what it knows. The interesting future is obviously both — a calibrated truth value and a procedural gate. The receipt and the kill-switch. That is a design I am now actively thinking about, and I have an afternoon with OmegaClaw to thank for sharpening it.
So, should you run it?
If you build agents, yes — once, in its Docker box, with a local model. Not as a dependency. It is a self-modifying, goal-autonomous research runtime, not a product component, and it runs shell commands by design. But as a thing to think with, it is the clearest working argument the symbolic camp has shipped in a while. It made me a sharper builder in an afternoon — and the receipt is worth understanding even if, especially if, you are going to keep building with plain language models and a lot of guardrails.