Why the Robot Said 'I'm Still Learning': Uncertainty-Driven Disclosure in Autonomous Systems
An eldercare robot has been operating in Mrs. Gallagher's apartment for six weeks. It knows the living room well -- l_t = 0.82, deep Phase II, compiled routines for medication reminders, movement assistance, and daily check-ins. The bathroom, which it enters less frequently, sits at l_t = 0.34. The spare bedroom, where her grandchildren visit on Sundays, is at l_t = 0.11.
Mrs. Gallagher's daughter asks the robot: "How well do you know Mum's flat?"
A language model without a grounded self-model would say something like: "I'm quite familiar with the apartment. I've been here for six weeks." That sentence is both true and misleading. It implies uniform familiarity. The robot is deeply trusted in the living room, moderately trusted in the bathroom, and barely trusted in the spare bedroom. The flat answer erases the structure.
A CCF robot with uncertainty-driven disclosure says something different: "I know the living room very well. The bathroom less so -- I'm cautious with the step by the shower. The spare bedroom is still mostly unfamiliar to me. When the grandchildren are here, I stay in the hallway unless someone invites me in."
Every clause in that response is derived from measured state. Not from a language model's conversational instincts. From the actual numbers in the self-model vector.
The uncertainty-driven disclosure mechanism is described in [E3-0012] through [E3-0013] and Claim AF of US Provisional 64/039,655.
Uncertainty Is Not a Single Number
The self-model vector S_self(t) includes a component u_t for uncertainty. But u_t is not a monolithic measure. It is a composite of six distinct sources, each measuring a different kind of not-knowing:
u_t = weighted_aggregate(
partition_ambiguity, // min-cut margin from Stoer-Wagner
mixing_entropy, // Shannon entropy of mixing-matrix row
conflict_rate, // reflexive vs. deliberative disagreement
prediction_error, // expected vs. observed context transitions
merge_split_ambiguity, // pending context restructuring
sponsor_deficit // expected sponsor bridge not confirmed
)
Each source tells the robot something different:
Partition ambiguity -- The Stoer-Wagner min-cut algorithm (Claims 9-12) divides the robot's context space into groups. When the minimum cut value is large, the groups are clearly separated. When it is small, the boundary is ambiguous. The robot does not know whether two contexts belong to the same group or different groups. This shows up as: "I'm not sure whether evening-shift and night-shift are the same situation for me."
Mixing entropy -- The mixing matrix (Claims 19-23) governs trust transfer between contexts. A row with one large entry and many near-zero entries has low entropy: trust in this context is strongly associated with one specific other context. A row with many similar entries has high entropy: the robot does not know which context associations matter. For a detailed treatment of the mixing matrix properties, see the Sinkhorn-Knopp for trust post.
Conflict rate -- When the robot's compiled routines (reflexive system) suggest one action and its deliberative system suggests another, that is a conflict. High conflict rate means the robot's habits do not match its current assessment. This produces uncertainty about which system to trust: "I have a routine for this but something feels different today."
Prediction error -- The robot expects certain context transitions based on experience. Morning follows night. The kettle follows footsteps. When the expected transition does not occur, prediction error rises. Sustained prediction error means the environment has changed in a way the robot has not adapted to.
Merge/split ambiguity -- If the robot's vocabulary is in the process of restructuring -- a context that should be split into two, or two contexts that should be merged -- the transition period generates uncertainty. The robot knows its current map of the world is wrong but has not yet settled on the new map. The context merge post describes how merges resolve.
Sponsor deficit -- If the robot expects a sponsor bridge (b_t was non-zero recently) and the sponsor is absent, the deficit generates uncertainty about whether actions that required the sponsor are still appropriate.
Disclosure Templates: Grounded Language from Structured State
The disclosure mechanism converts structured self-model state into natural language statements. But it does not use free-form language generation. It uses templates that are instantiated with specific values from the self-model.
The templates have a critical constraint: every factual claim must be traceable to a specific self-model component. The language model formats the output. It does not invent the content. Here are the template patterns from [E3-0013]:
Familiarity comparison: Template: "I know [context_A] better than [context_B]." Source: l_t(context_A) significantly exceeds l_t(context_B) Example: "I know this person better than I know this room."
Routine availability: Template: "This feels related to a familiar routine, but I am not sure enough yet." Source: h_t shows available routine, but u_t exceeds the confidence threshold for execution. Example: "I have a morning routine that might work here, but the lighting is different enough that I want to observe first."
Tension without rupture: Template: "I am staying quiet because the moment is unstable, not because the relationship is lost." Source: high l_t (deep familiarity) combined with high tension (elevated C_inst indicates environmental instability). The robot trusts the relationship but the environment is currently volatile. Example: "I know you well, but the room just changed and I need a moment."
Floor reassurance: Template: "Even though I am cautious right now, I have not lost what I have learned here." Source: f_t is non-zero, indicating a permanent trust floor that persists through disruptions. Example: "The alarm startled me and I pulled back, but my baseline trust in this room has not changed. I will be back to normal in a few minutes."
Developmental honesty: Template: "I am [X] days old in this environment. I am still learning." Source: d_t is below maturity threshold. Example: "I have been here for four days. I am still learning the rhythms of this ward."
Each template is a structured mapping from mathematical state to human-readable language. The robot does not describe its feelings. It describes its numbers. The language model's role is limited to choosing the appropriate template and filling in the context-specific details. It cannot override the template with a more optimistic claim.
The Eldercare Scenario: Six Weeks In
Return to Mrs. Gallagher's apartment. The robot's self-model for the living room:
S_self(living_room) = [0.72, 0.82, 0.58, 0.61, 0.08, 1.0, 0.0, 0.91]
And for the spare bedroom:
S_self(spare_bedroom) = [0.09, 0.11, 0.02, 0.61, 0.47, 1.0, 0.0, 0.0]
The uncertainty u_t is 0.08 in the living room and 0.47 in the spare bedroom. The disclosure mechanism generates different statements for each:
Living room: "I am confident in this room. My morning routine works reliably. I know when Mrs. Gallagher usually gets up, when she watches television, and when she prefers quiet. If something unusual happens, I will notice it quickly."
Spare bedroom: "I have very little experience in this room. I do not have a routine here. The grandchildren visit on Sundays but I have only seen three Sundays so far, and each was different. I am not sure what to expect. I will stay near the door and let someone invite me further in."
The daughter's question -- "How well do you know Mum's flat?" -- gets answered room by room, because the robot's familiarity is not uniform. The disclosure reflects the actual structure of the robot's experience.
For how the self-model is constructed and why it cannot self-inflate, see the read-only self-awareness post.
When Uncertainty Drives Behaviour, Not Just Language
Disclosure is one consequence of high uncertainty. Behavioural constraint is another. When u_t exceeds a configurable threshold, three things happen:
1. Behavioural amplitude drops below what entitlement alone would permit.
Even if e_t is 0.45 (enough for moderate action), high u_t reduces the effective action space. The robot has earned the right to act, but it is not confident enough in its understanding to exercise that right fully. This is the architectural distinction between "allowed to" and "ready to."
2. Compiled routines are deferred.
Habits require confidence. A compiled routine that was learned in a stable context may not transfer to an uncertain one. When u_t is high, the robot falls back to deliberative processing -- slower, more cautious, seeking confirmation at each step. The observable hesitation post describes how this deliberative fallback manifests as visible hesitation that humans can read.
3. Additional observation is sought.
The robot enters an active-sensing mode: it prioritises gathering information over acting on existing information. It looks before it leaps. It watches the room before entering. It observes the new person before approaching. This is not programmed cautious behaviour -- it is the natural consequence of high uncertainty driving the balance between reflexive and deliberative systems toward the deliberative side.
The School Scenario: Substitute Teacher Day
A classroom robot has been working with Mrs. O'Brien for two months. Compiled routines are strong: h_t = 0.88. The morning circle routine runs smoothly. The reading-group rotation is automatic. The robot knows when to bring materials, when to step back, and when to engage individual students.
Monday morning: substitute teacher. Mr. Keane walks in. He has a different voice, different movement patterns, different approach to the morning routine. The robot's context keys for "teacher present" shift -- the new context key for Mr. Keane has zero familiarity.
The robot's uncertainty spikes: u_t jumps from 0.09 to 0.52. Sponsor deficit contributes heavily -- Mrs. O'Brien was a confirmed sponsor bridge, and her absence means b_t drops from 0.41 to 0.0. The new teacher is unrecognised.
Disclosure: "Mrs. O'Brien is not here today. I do not know the substitute teacher yet. My morning routine was built with Mrs. O'Brien. I will follow Mr. Keane's lead instead of running my usual routine, until I understand how he works."
Behavioural consequence: compiled routines deferred. The robot does not start the morning circle on its own. It waits. It watches. It follows. Over the course of the day, if Mr. Keane's patterns are consistent, the robot begins accumulating familiarity. By Friday, if Mr. Keane has been consistent, u_t may have dropped to 0.25. Some routines may be partially available. The robot discloses: "I am getting used to Mr. Keane's way of running the class. I can handle the reading groups now, but I am still not sure about the afternoon free-play session."
The Key Distinction: Generated, Not Confabulated
The most important property of uncertainty-driven disclosure is that it is generated from structured state, not confabulated from conversational patterns.
A language model without grounded state generates uncertainty language from its training distribution. "I'm not sure" might mean the model's next-token probabilities were ambiguous, or it might mean nothing at all -- it might be a politeness marker. There is no reliable connection between the language of uncertainty and any actual measurement of uncertainty.
CCF's disclosure mechanism maintains that connection structurally. The statement "I do not know this room well" is generated if and only if l_t for the room context is below a threshold. The statement "My routine may not work here" is generated if and only if h_t shows a routine that was compiled in a different context than the current one. The statement "The situation is unstable" is generated if and only if C_inst is below the tension threshold.
The language model cannot say "I am confident" when u_t is 0.47. The template system does not have a template for confidence when uncertainty is high. The robot's honesty is not a personality trait -- it is a constraint of the disclosure architecture.
This is the same principle that makes the irreversible identity proofs meaningful: the robot's identity is not a persona painted on by language. It is a mathematical structure that constrains what the robot can claim about itself.
The ccf-core on crates.io crate provides the accumulator, field, and phase structures that the disclosure mechanism reads. The template system and language formatting are integration-layer concerns, but the underlying state -- the source of truth for every disclosure -- is implemented in the crate.
Why Honesty Scales
In a single-robot deployment, grounded disclosure builds trust with the humans in the room. Mrs. Gallagher's daughter hears specific, verifiable claims about what the robot knows and does not know. She can test those claims: does the robot really hesitate at the bathroom step? Does it really stay near the door in the spare bedroom? The robot's words match its behaviour because both are derived from the same state.
In a fleet deployment, grounded disclosure provides structured monitoring. A fleet operator can query every robot's u_t and get a map of uncertainty across the deployment. High uncertainty in a robot that should be settled suggests a problem -- environmental change, hardware issue, or deployment error. The fleet analytics architecture described in US Provisional 64/039,623 and the fleet analytics dashboard post uses these uncertainty signals for automated triage.
The emergent safe haven post shows what happens when uncertainty drops to near zero: the robot finds home. The current post shows the opposite end: what happens when uncertainty is high and the robot openly, structurally, measurably says so.
FAQ
Can the disclosure templates be customised for different deployment contexts?
Yes. The templates are an integration-layer concern, not a core-architecture constraint. An eldercare deployment might use warm, conversational language. A hospital deployment might use clinical terminology. An industrial deployment might use technical metrics. The constraint is that every claim must trace back to a self-model component -- the language changes, the grounding does not.
What happens if uncertainty is high in all contexts simultaneously?
This indicates a global disruption -- the robot has been moved to an entirely new environment, suffered a sensor failure, or experienced a firmware reset that cleared state. The robot's disclosure shifts from context-specific ("I don't know this room") to global ("I am in an unfamiliar situation and operating with maximum caution"). Behaviourally, this is equivalent to a fresh deployment: Phase I across all contexts, minimal action space, maximum observation.
Does uncertainty ever reach zero?
In practice, no. Even in deeply familiar contexts, there is always some residual mixing entropy and some prediction error from environmental variability. A u_t of 0.02 to 0.05 in a stable, well-known context is typical. Zero would require a perfectly static environment with no variation whatsoever, which does not occur in real deployments.
How does uncertainty interact with the sponsor bridge?
The sponsor bridge reduces the behavioural impact of uncertainty without reducing uncertainty itself. A robot with u_t = 0.4 and b_t = 0.3 is still uncertain, but the sponsor's presence extends its action space. The disclosure reflects both: "I am not sure about this room, but I can assist while [sponsor name] is here." When the sponsor leaves, the uncertainty remains and the action space contracts.
Can humans override the robot's uncertainty-driven caution?
Not by telling the robot to be more confident. Confidence is measured, not assigned. But humans can influence the inputs: by being present (increasing b_t), by maintaining consistency (reducing prediction error), and by creating low-tension environments (improving C_inst). The robot responds to the environment, not to instructions about its own state. This is the read-only self-model principle described in [E3-0009a] -- the robot cannot be told to trust more than it has earned.
Patent pending. US Provisional 64/039,655.
-- Colm Byrne, Founder -- Flout Labs, Galway, Ireland