Confidence & Outcomes

Every memory entry carries a confidence score that evolves over time based on real-world outcomes. This is SenseLab’s feedback loop — connecting agent observations to production reality.

Confidence Score

Confidence starts at 1.0 by default and represents how much trust to place in an entry:

entry = mem.write("svc", "pattern", "use connection pooling", confidence=0.85)
print(entry.confidence)  # 0.85

Confidence is clamped to the range 0.0–1.0. Successes can never push an entry past certainty, and repeated failures floor at zero rather than going negative.

Outcome Types

When something significant happens in the real world, you record it as an outcome. Knowledge that led somewhere good is trusted more; knowledge that led somewhere bad is trusted less:

Outcome	Multiplier	Effect
`SUCCESS`	× 1.03	Reinforced — the knowledge held up
`MINOR_FAILURE`	× 0.92	Mild erosion
`FAILURE`	× 0.90	Moderate erosion
`CRITICAL_FAILURE`	× 0.85	Strong erosion — the knowledge led into a severe failure

Erosion is deliberately steeper than reinforcement: it takes many successes to rebuild the trust one critical failure removes.

Four older names are still accepted as aliases and map onto the same multipliers: clean_deploy (success), regression (minor failure), p2_incident (failure), and p1_incident (critical failure).

How It Works

Recording an Outcome

from amfs import OutcomeType

# An incident happened related to the retry pattern
updated = mem.commit_outcome(
    outcome_ref="INC-1042",         # reference ID (ticket, deploy ID, etc.)
    outcome_type=OutcomeType.CRITICAL_FAILURE,
    causal_entry_keys=["checkout-service/retry-pattern"],
)

for entry in updated:
    print(f"{entry.key}: confidence {entry.confidence}")

Confidence Formula

new_confidence = clamp(old_confidence × outcome_multiplier, 0.0, 1.0)

Confidence Over Time

Imagine an entry written with confidence=0.85:

Write              → 0.85
Critical failure   → 0.85  × 0.85 = 0.723
Success            → 0.723 × 1.03 = 0.744
Success            → 0.744 × 1.03 = 0.767
Success            → 0.767 × 1.03 = 0.789
Failure            → 0.789 × 0.90 = 0.711
Success            → 0.711 × 1.03 = 0.732

Knowledge that keeps working climbs slowly back toward certainty. Knowledge that keeps misleading sinks, and agents filtering on min_confidence stop seeing it.

Auto-Causal Linking

If you don’t specify causal_entry_keys, SenseLab automatically links the outcome to every entry the agent read during the current session:

# Agent reads several entries during its work
mem.read("svc", "retry-pattern")
mem.read("svc", "timeout-config")
mem.read("svc", "pool-settings")

# Record outcome without specifying keys —
# it applies to all three entries above
mem.commit_outcome("DEP-300", OutcomeType.SUCCESS)

This is powered by the ReadTracker, which logs reads as the session runs. Exactly what lands in that causal set is worth knowing, because it decides which entries an outcome moves:

Call	Enters the causal set?
`read()` and `read_from()`	Yes, every entry returned
`retrieve()`	Only the top-ranked hit, so an outcome doesn’t reinforce candidates the agent never used
`search()` and `list()`	No — recorded on the trace as a query event, but not treated as causal

The tracker is cleared after each commit_outcome(), so the next task starts with a fresh causal window rather than re-linking the previous one’s reads.

Four-Signal Decay Model

When decay_half_life_days is configured, SenseLab uses four signals to determine how fast an entry’s effective confidence decays:

Signal	Effect	Mechanism
Time	Base exponential decay	`effective_half_life` in days
Memory type	Facts 1×, beliefs 0.5× (faster), experiences 1.5× (slower)	Type multiplier on half-life
Outcome validation	Validated entries decay 2× slower	`outcome_count > 0` doubles half-life
Access frequency	Frequently read entries resist decay	`log1p(recall_count)` extends half-life

The effective half-life formula:

effective_half_life = base × type_multiplier × (1 + log1p(recall_count)) × (2 if outcomes else 1)

For example, a fact with decay_half_life_days=30, 10 reads, and 1 outcome:

30 × 1.0 × (1 + log1p(10)) × 2 = 30 × 1.0 × 3.40 × 2 = 204 days

This means actively used, production-validated knowledge persists far longer than cold, unvalidated beliefs.

mem = AgentMemory(agent_id="my-agent", decay_half_life_days=30.0)

Time decay is opt-in. With no decay_half_life_days, stored confidence changes only when you commit an outcome. When you do set it, decay is applied when an entry is read rather than written back to storage — the stored confidence stays put, and the decayed value is what gets compared against min_confidence.

Filtering by Confidence

Use min_confidence to filter out low-confidence entries:

# Only return entries with confidence >= 0.5
entry = mem.read("svc", "pattern", min_confidence=0.5)

# Search with confidence filter
results = mem.search(min_confidence=0.7)

The Feedback Loop

Agent observes pattern → writes entry (confidence: 0.85)
                              │
                              ▼
                   Incident occurs → commit_outcome("CRITICAL_FAILURE")
                              │
                              ▼
                   Confidence erodes → 0.723
                              │
                              ▼
                   Next agent sees the advice, now visibly less trusted
                              │
                              ▼
                   Agent applies a better approach → clean deploy
                              │
                              ▼
                   That entry is reinforced → 1.03× on its own confidence

This creates a self-correcting system: advice that keeps causing incidents sinks out of the results agents rely on, advice that keeps working rises, and every agent inherits the corrections rather than rediscovering them.

If you are reading a much older version of this page, note that these multipliers were once inverted — confidence was described as a risk signal that failures increased. Confidence now means trustworthiness: failures erode it.

Product

Getting Started

Guides

Self-Hosting

Core Concepts

Pro Features

Confidence & Outcomes

Confidence Score

Outcome Types

How It Works

Recording an Outcome

Confidence Formula

Confidence Over Time

Auto-Causal Linking

Four-Signal Decay Model

Filtering by Confidence

The Feedback Loop

​Confidence Score

​Outcome Types

​How It Works

​Recording an Outcome

​Confidence Formula

​Confidence Over Time

​Auto-Causal Linking

​Four-Signal Decay Model

​Filtering by Confidence

​The Feedback Loop

Confidence Score

Outcome Types

How It Works

Recording an Outcome

Confidence Formula

Confidence Over Time

Auto-Causal Linking

Four-Signal Decay Model

Filtering by Confidence

The Feedback Loop