Confidence scores are a lie until you make them cost something

Every agent demo ships with a confidence score. You'll see it in the logs, in the UI, in the pitch deck. A tidy number like 0.92. It looks rigorous. It implies the agent knows what it doesn't know.

Then watch what happens when that number is 0.61. The agent does the same thing.

That's not a confidence score. That's a label.

The difference between a number and a control

A confidence score is only real if it gates behavior. If your agent acts identically at 0.4 and 0.95, the number is theater. You've added the vocabulary of uncertainty without any of the discipline.

A number you never act on is decoration. A number that can stop an action is a control.

This is the distinction that matters. Most production systems don't make it. They compute confidence downstream of the LLM call, log it somewhere, maybe surface it in a dashboard — and then proceed as if it were 1.0 regardless.

How ARIA treats confidence as a gate, not a label

ARIA runs 54 agents overnight and delivers a verified morning digest. "Verified" is the operative word. Every task needs a verified_at timestamp before it ships to the digest. Low confidence can hold work back. The score has consequences, so the score has meaning.

Confidence is wired into memory at the write level, not just the read level. When an agent stores a semantic fact — a durable claim about a customer, a market condition, a strategic decision — it goes in at 0.7 by default. Not 1.0. Not "high." A deliberate 0.7 that says: a stated fact is not gospel. We heard it, we recorded it, but we do not treat it as certain.

That number affects what happens next. Confidence interacts with retrieval. It interacts with conflict resolution. When a new fact contradicts an old one, the newer, higher-confidence claim wins retrieval while the old one decays — not instantly deleted, but steadily losing ground. The agent is not choosing between two facts blindly. It is choosing based on the accumulated evidence weight each one carries.

Why 0.7 and not 1.0

This is the question worth sitting with.

Most systems default semantic memory to full confidence because it's simpler. You either store a fact or you don't. If you stored it, you trust it.

That assumption is how you get an agent confidently emailing a customer with last quarter's pricing. Or surfacing a competitor claim that was refuted in a follow-up article. Or acting on a preference a user stated once, off-handedly, in a context they've since abandoned.

A stated fact is not the same as a verified fact. The 0.7 default is an honest acknowledgment of that gap. It's also a forcing function: if you want confidence to rise, you need corroboration. More signals from more sources. The system rewards verification, not mere assertion.

The four memory types have different confidence profiles

Not all memory works the same way:

• Working memory — ephemeral, scoped to tonight's run. Confidence matters less because it expires anyway.
• Episodic — event-anchored. A thing happened on a date. These carry their own temporal weight; recency is part of the confidence signal.
• Semantic — durable facts. This is where 0.7 lives. These persist, but they aren't treated as permanent truth.
• Procedural — learned behaviors, agent workflows. The slowest to change and the highest-consequence if wrong.

Each type decays differently. Each type has different stakes. Applying uniform confidence across all four would be like treating a meeting note and a verified contract as equally reliable sources.

Honest uncertainty beats confident hallucination

This is the thesis. It sounds obvious. It is almost universally ignored in production systems.

Agents that hallucinate with high confidence are more dangerous than agents that flag uncertainty. The hallucinating agent gets trusted. It books the wrong meeting. It sends the wrong email. It marks the wrong task done.

An agent that says "I'm not sure enough to act on this" is doing something valuable. It's preserving the human's ability to catch the error before it propagates.

The uncomfortable part is that honest uncertainty requires you to build a system where uncertainty has consequences. Where a low score can stop an action. Where confidence has to be earned through corroboration rather than assumed by default.

That system is harder to build. It surfaces more edge cases. It ships fewer things with false confidence.

That's exactly why it works.