Thinking-Triggered Aspect Learning for Autonomous Knowledge Acquisition and Transfer in Robots

1. Introduction

Autonomous robots are expected to operate for long periods in dynamic environments, where not every situation can be anticipated during initial training. A robot may repeatedly perform a familiar task automatically, yet occasionally encounter a local condition that deserves additional reasoning. For example, an object may be temporarily placed on a contaminated surface, a heat-sensitive item may contact a hot region, or a previously safe support surface may become wet and slippery. Humans often handle such situations by temporarily increasing attention, identifying the relevant factors, learning how the situation should be handled, and later responding automatically when the same type of concern reappears. An autonomous robot should ideally exhibit a similar transition from routine execution to selective thinking, learning, and subsequent automatization.

Recent progress in large language models (LLMs) has substantially improved the reasoning capability of embodied agents [1,2]. Methods such as ReAct and Inner Monologue combine language-based reasoning with interaction feedback [3], while SayCan, PaLM-E, and RT-2 demonstrate increasingly strong grounding and generalization between language, perception, and robot action [4,5]. These approaches show that explicit reasoning can be valuable when a robot encounters uncertainty or unfamiliar situations. However, repeatedly invoking such reasoning is computationally expensive, and most existing methods focus primarily on how to reason or act for the current task. They provide less explicit support for deciding when thinking should be activated, what reusable local knowledge should be extracted from the reasoning process, and when that knowledge has become reliable enough to replace future reasoning with automatic processing.

Continual and generalist robot-learning methods address another part of this problem by transferring experience across tasks, embodiments, or environments [6,7]. Nevertheless, transfer is commonly realized through a shared task policy, a task-conditioned model, or additional target-domain adaptation. Such representations can provide strong generalization, but the transferred unit is often tied to a task, subtask, or large policy representation. In many practical situations, however, the knowledge that should be transferred is much smaller than the whole task. A cleanliness concern learned while preparing food may also be relevant when preparing laboratory materials; similarly, a low-friction support problem may recur in tasks that are otherwise unrelated. The reusable knowledge is therefore better characterized by the local factors that make a concern applicable than by the identity of the source task.

This paper proposes a thinking-triggered aspect learning framework for autonomous knowledge acquisition and transfer in robots. The central idea is that the robot does not transfer entire tasks; instead, it learns and transfers locally reusable ways of handling recurring concerns. Routine behavior is first handled by existing automatic models. Explicit thinking is activated only when local novelty, uncertainty, abnormality, or periodic heartbeat inspection indicates that the automatic process may be insufficient. Rather than reconsidering the entire task, the thinking process localizes a small unresolved concern and identifies the factors that are relevant to it.

The localized knowledge is represented as a reusable aspect

$$A_k=(n_k,F_k,g_k,d_k,M_k,{\tau }_k),$$

(1)

where $n_k$ denotes the semantic description of the aspect, $F_k$ the relevant local factors, $g_k$ its applicability condition, $d_k$ the handling principle, $M_k$ a compact local automatic model, and ${\tau }_k$ its calibrated activation threshold. Existing aspects are retrieved according to the localized factors and their semantic compatibility rather than task identity. Consequently, an aspect learned in one task can be reused in another task, subtask, or domain whenever the same local concern recurs.

If no existing aspect adequately explains the newly localized concern, the robot initiates autonomous aspect discovery. Candidate knowledge is accumulated from multiple independent observations, refined using positive and contrasting examples, and evaluated on data that are separate from final validation. Only validated aspects are allowed to enter the trusted automatic repertoire. This validation gate is important because recognizing when a concern occurs does not necessarily imply that the proposed handling action is correct. An unreliable candidate therefore remains subject to explicit thinking rather than being automatically executed.

The framework further introduces a transition from thinking to automatization. Once an aspect has been repeatedly observed and independently validated, future instances can be handled directly by its local automatic model. A checkpoint-decay mechanism reduces repeated thinking about already resolved concerns, while a low-frequency heartbeat periodically revisits the environment to detect changes that may otherwise remain unnoticed during routine automatic execution. When a previously learned regime becomes invalid, thinking is reactivated and the robot can either reuse another known aspect or discover a new one. The resulting lifecycle is

$$\begin{array}{cc}\hfill \mathrm{Automatic}\mathrm{Execution}& \to \mathrm{Local}\mathrm{Concern}\mathrm{Detection}\hfill \\ \hfill & \to \mathrm{Thinking}\hfill \\ \hfill & \to \left\{\mathrm{Aspect}\mathrm{Reuse}\mathrm{or}\mathrm{Discovery}\right\}\hfill \\ \hfill & \to \mathrm{Validation}\hfill \\ \hfill & \to \mathrm{Automatic}\mathrm{Consolidation}.\hfill \end{array}$$

(2)

The proposed framework is evaluated through three groups of experiments. First, we examine whether the robot can autonomously identify compact local aspects and their relevant factors from otherwise routine interaction streams. Second, we test whether learned aspects can be reused without target-specific learning when the task, subtask, or application domain changes, and whether the robot can subsequently discover and reuse another genuinely new aspect. Third, we study the temporal transition between thinking and automatic processing, including familiarization, environmental change, heartbeat-based reactivation, novel-aspect validation, and reasoning cost.

The main contributions of this work are as follows:

• We formulate autonomous robot learning around local reusable aspects rather than whole-task transfer, enabling knowledge to be retrieved according to relevant factors and applicability conditions instead of task identity.
• We introduce a selective thinking mechanism in which routine behavior remains automatic, while novelty, uncertainty, abnormality, and heartbeat inspection trigger localized reasoning only when necessary.
• We propose an autonomous aspect-discovery and validation process that separates candidate acquisition, semantic/model refinement, threshold calibration, and final validation, preventing unreliable knowledge from being directly consolidated into automatic behavior.
• We integrate learned aspects with compact local automatic models, calibrated aspect-specific thresholds, checkpoint decay, and environmental reactivation, forming a complete lifecycle from explicit thinking to automatic processing and back to thinking when conditions change.

The remainder of this paper is organized as follows. Section II reviews related work on embodied reasoning, continual robot learning, and reusable knowledge representations. Section III presents the proposed thinking-triggered aspect learning framework, including local concern detection, aspect representation, reuse, discovery, validation, automatization, and reactivation. Section IV describes the experimental setup and evaluates autonomous aspect learning, cross-task reuse, and thinking-to-automatic adaptation. Finally, Section V concludes the paper and discusses future directions.

2. Related Work

2.1. Embodied LLM Reasoning and Selective Deliberation

Large language models have increasingly been used as high-level reasoning components for interactive and embodied agents. ReAct interleaves verbal reasoning with environment-facing actions, allowing an agent to update plans and gather additional information during execution [3]. Inner Monologue similarly closes the planning loop by feeding success signals, scene descriptions, and other environment feedback back into an LLM [8]. These methods demonstrate an important advantage over purely reactive policies: explicit reasoning can improve robustness when the current observation is insufficient or when an earlier plan must be revised. However, reasoning is still primarily organized around solving the current task or recovering from execution feedback, rather than learning a compact, reusable local concern that can later be handled without repeated deliberation.

A complementary line of work focuses on grounding language reasoning in robot perception and action. SayCan combines language-model priors with learned skill affordances so that high-level instructions are constrained by what the robot can actually execute [4], while Code as Policies generates executable robot programs from natural-language instructions [9]. Embodied foundation models such as PaLM-E incorporate continuous perceptual inputs into a multimodal language model [5], and RT-2 maps visual-language representations directly to robot actions while benefiting from large-scale vision-language pretraining [10]. Their main strength is broad semantic generalization: knowledge acquired from language, vision, or heterogeneous robot data can improve performance on previously unseen objects, instructions, or tasks.

Nevertheless, these approaches mainly address how to reason or act given a task, whereas our concern is also when explicit reasoning is necessary and what should be extracted from that reasoning for future automatic use. Re-running a large model whenever a decision is uncertain can provide flexibility, but it incurs repeated inference cost and does not by itself identify which local factors constitute reusable knowledge. Our method therefore treats LLM reasoning as an intermittent resource triggered by novelty, uncertainty, or heartbeat inspection. Thinking localizes an unresolved concern and constructs an aspect containing its relevant factors, applicability condition, handling principle, and a compact local automatic model. Once independently validated, this aspect can replace repeated LLM reasoning; if environmental evidence later violates the learned regime, thinking is reactivated. This explicit transition from selective deliberation to validated automatic processing distinguishes our framework from LLM-centered embodied planners.

2.2. Continual Robot Learning and Cross-Task Knowledge Transfer

Continual and lifelong robot learning seek to let an embodied agent accumulate knowledge across a sequence of experiences rather than training every task independently. Modern continual-learning research studies adaptation under changing data distributions while retaining previously acquired capabilities [6], and benchmarks such as LIBERO explicitly evaluate transfer of declarative and procedural knowledge across robot-manipulation task sequences [11]. These methods provide principled tools for measuring forward transfer, retention, and adaptation, and they establish that knowledge reuse across time is central to scalable robot learning.

Recent generalist robot models push this idea further through large and heterogeneous training corpora. RoboCat learns across multiple tasks and robot embodiments and can adapt to new tasks from additional target demonstrations [7]. Open X-Embodiment and RT-X aggregate experience from many robots and tasks in a common format, showing that cross-robot data can produce positive transfer to multiple embodiments [12]. Such systems offer strong evidence that broad shared representations can reduce the amount of target-specific robot data needed for new tasks. Their limitation, however, is that transfer is typically realized through a large shared policy or subsequent adaptation of that policy, making it difficult to identify the precise local condition that is being transferred and to determine whether that knowledge should be activated independently of the source task identity.

Our work targets a finer level of transfer. Instead of transferring a whole task policy, subtask label, or globally shared representation, the robot transfers a locally learned way of handling a recurring concern. An aspect is indexed by the factors that make the knowledge applicable rather than by the task in which it was first observed. Consequently, the same aspect can be reused when the surrounding task, subtask, or domain changes but the local condition reappears. This distinction is important for autonomous learning because the robot need not know in advance which source and target tasks should share knowledge. Moreover, new aspects can be added when existing ones fail to explain a changed environment, and each candidate must pass independent validation before being consolidated. Thus, the proposed framework complements continual robot learning by focusing on autonomous discovery, validation, and cross-task reuse of compact local knowledge rather than only continual adaptation of a task-level policy.

2.3. Reusable Abstractions, Memory, and Automatization

Reusable abstractions have a long history in reinforcement learning and agent architectures. The options framework formalizes temporally extended actions through reusable policies with initiation and termination conditions [13]. This abstraction is valuable because it separates high-level decision making from low-level execution and permits previously learned behavior to be invoked as a single unit. In robotics, similar hierarchical or skill-library ideas reduce planning depth and enable composition of known behaviors. However, an option usually represents what sequence of actions to execute, whereas the aspect in this work represents what local concern is present, which factors make it applicable, and how that concern should influence behavior. The two abstractions are therefore complementary rather than equivalent.

LLM agents have recently introduced more semantic forms of reusable memory. Voyager maintains an expanding library of executable skills and retrieves previously generated code to solve new embodied tasks [14]. Reflexion stores linguistic reflections derived from feedback and reuses them to improve later decisions without modifying the underlying language-model weights [15]. These approaches show that explicit memories and reusable modules can reduce repeated problem solving and support lifelong improvement. Their advantage is interpretability and rapid reuse, but the stored unit is typically a task skill, program, or textual reflection; the frameworks do not explicitly learn a local applicability model that decides when the stored knowledge should operate automatically and when renewed reasoning is required.

The proposed method combines reusable memory with an explicit thinking-to-automatic lifecycle. A learned aspect contains semantic knowledge $(n_k,F_k,g_k,d_k)$ together with a local automatic model $M_k$ and its calibrated activation threshold ${\tau }_k$. Reuse therefore requires both semantic/factor matching and evidence that the local applicability condition holds. More importantly, thinking itself is not permanently active: repeated successful experience causes the validated aspect to be handled automatically, while anomaly or periodic heartbeat evidence can reactivate thinking when the environment changes. This produces a closed loop from automatic execution to local concern detection, aspect discovery or reuse, independent validation, and finally automatic consolidation. The closest prior lines address parts of this loop—reasoning, lifelong transfer, reusable skills, or reflective memory—but do not jointly formulate selective thinking, autonomous local-aspect discovery, cross-task applicability, validation-gated consolidation, and later reactivation within one robot-learning framework.

3. Model

3.1. Overview

We consider an autonomous robot that continuously interacts with changing environments while executing most familiar behaviors through previously trained automatic models. The central assumption of this work is that the robot should not repeatedly reason about an entire task once most of the task has already become routine. Instead, explicit thinking is invoked only when a local part of the ongoing interaction remains unresolved, uncertain, abnormal, or otherwise important.

Accordingly, the robot maintains two complementary model sets:

$${\mathcal{M}}_t={\mathcal{M}}_{\mathrm{routine}}\cup {\mathcal{M}}_{\mathrm{aspect},t},$$

(3)

where ${\mathcal{M}}_{\mathrm{routine}}$ contains previously learned automatic models for familiar behaviors such as navigation, grasping, opening, placing, and pouring, while ${\mathcal{M}}_{\mathrm{aspect},t}$ contains independently learned models for reusable local concerns discovered during interaction.

The robot also maintains a dynamically growing aspect repertoire

$${\mathcal{A}}_t=\left\{A_1,A_2,\dots ,A_{K_t}\right\},$$

(4)

where $K_t$ is not fixed. Each aspect represents a task-independent concern that was discovered because some local part of an otherwise familiar behavior required additional reasoning. An aspect is represented as

$$A_k=\left(n_k,F_k,d_k,M_k\right),$$

(5)

where $n_k$ is a semantic description generated from the robot’s experience, $F_k$ is the set of locally relevant factors, $d_k$ is the learned handling principle or corrective rule, and $M_k$ is the automatic model trained from accumulated examples of that aspect.

Importantly, the aspect repertoire is not assumed to be predefined. The robot is not given a fixed catalog describing which aspects should be learned or in which tasks they should later be reused. Instead, aspects are created, validated, stored, retrieved, and expanded online as interaction continues.

The resulting process can be summarized as

$$\begin{array}{cc}\hfill & \mathrm{Automatic}\mathrm{Execution}\hfill \\ \hfill & \to \mathrm{Local}\mathrm{Concern}\mathrm{Detection}\hfill \\ \hfill & \to \mathrm{Concern}\mathrm{Localization}\hfill \\ \hfill & \to \left\{\begin{array}{cc}\mathrm{Aspect}\mathrm{Reuse},\hfill & \mathrm{if}\mathrm{a}\mathrm{known}\mathrm{aspect}\mathrm{matches},\hfill \\ \mathrm{Aspect}\mathrm{Discovery},\hfill & \mathrm{otherwise},\hfill \end{array}\right.\hfill \\ \hfill & \to \mathrm{Automatic}\mathrm{Consolidation}.\hfill \end{array}$$

(6)

This formulation differs from task-level transfer. The robot does not search for a previously seen task that globally resembles the current task. Instead, it first suppresses task components that are already handled automatically, identifies the unresolved local concern, and then searches for previously learned knowledge that matches that concern.

3.2. Thinking-Triggered Local Concern Localization

At time t, let the complete observable interaction state be

$$X_t=\left[x_t^1,x_t^2,\dots ,x_t^D\right].$$

(7)

Most dimensions of $X_t$ may describe routine information that is already handled by ${\mathcal{M}}_{\mathrm{routine}}$. Reconsidering all of this information at every step would unnecessarily couple reasoning to the entire task and repeatedly consume computational resources.

The robot therefore maintains a lightweight trigger that determines whether the current interaction requires additional reasoning. Let $u_t$ denote uncertainty, $e_t$ denote an observed abnormality or unexpected outcome, and $q_t$ denote other local evidence that the current automatic behavior may be insufficient. A trigger score is computed as

$$z_t=\alpha u_t+\beta e_t+\gamma q_t,h_t=\mathbb{I}\left[z_t>{\tau }_h\right],$$

(8)

where $h_t=1$ activates explicit thinking.

When thinking is activated, the objective is not to reinterpret the complete task. Instead, the thinking module localizes the small subset of information that explains the unresolved event:

$$F_t^{\mathrm{key}}={\Phi }_{\mathrm{think}}\left(X_{t-L:t},O_t\right),$$

(9)

where $O_t$ denotes the observed outcome and $F_t^{\mathrm{key}}$ contains only the factors judged relevant to the current concern.

A structured thinking record is then formed as

$$R_t=\left(C_t,F_t^{\mathrm{key}},P_t,D_t,A_t^{\mathrm{exec}},O_t\right),$$

(10)

where $C_t$ is the local context, $P_t$ describes the identified problem, $D_t$ is the proposed handling principle, $A_t^{\mathrm{exec}}$ is the action that was executed, and $O_t$ is the resulting outcome.

This localization step is important because the same local concern may appear inside globally different tasks. For example, contamination before later sensitive contact may first appear while placing a pan lid during cooking and later appear while handling a laboratory container cover. The two tasks are globally dissimilar, but their localized unresolved information can still be nearly identical.

3.3. Aspect Retrieval and Cross-Task Reuse

After the local concern has been identified, the robot determines whether it has encountered a similar concern before. Retrieval is therefore performed using the localized key information rather than the complete task context.

For each stored aspect $A_k$, a relevance score is computed as

$$S_t\left(A_k\right)=\lambda S_{\mathrm{sem}}\left(F_t^{\mathrm{key}},n_k,d_k\right)+(1-\lambda )S_{\mathrm{fac}}\left(F_t^{\mathrm{key}},F_k\right),$$

(11)

where $S_{\mathrm{sem}}$ measures semantic compatibility between the current concern and the stored aspect description, and $S_{\mathrm{fac}}$ measures the overlap or consistency of relevant factors.

The best candidate is

$$k^{*}=arg\underset{A_k\in {\mathcal{A}}_t}{max}{S}_t\left(A_k\right).$$

(12)

If

$$S_t\left(A_{k^{*}}\right)\ge {\tau }_r,$$

(13)

the robot reuses the existing aspect rather than reasoning about the full task again. The corresponding local model operates only on the factors associated with that aspect:

$$M_{k^{*}}:X_{t-L:t}^{F_{k^{*}}}\to \left({\widehat{y}}_t,{\widehat{a}}_t\right),$$

(14)

where ${\widehat{y}}_t$ denotes the predicted local risk or condition and ${\widehat{a}}_t$ denotes the local adjustment implied by the aspect.

This mechanism makes cross-task reuse a direct consequence of decoupling. Task identity, object identity, and subtask name are not required to match the source experience. Two interactions may therefore share an aspect even when

$$T_{\mathrm{source}}\ne T_{\mathrm{target}},B_{\mathrm{source}}\ne B_{\mathrm{target}},$$

(15)

as long as their localized unresolved concerns are sufficiently similar.

In other words, the proposed method does not transfer whole tasks. It transfers locally learned ways of handling recurring concerns. This also explains why knowledge can be reused across different subtasks and even different domains: the retrieval key is the underlying local concern, not the surface form of the task in which the knowledge was first acquired.

3.4. Discovery and Independent Learning of New Aspects

If no stored aspect sufficiently matches the localized concern,

$$\underset{A_k\in {\mathcal{A}}_t}{max}{S}_t\left(A_k\right)<{\tau }_r,$$

(16)

the current problem is treated as potentially novel. Explicit thinking then analyzes accumulated local records and proposes a new candidate aspect

$${\widehat{A}}_{K_t+1}=\left(\widehat{n},\widehat{F},\widehat{d}\right),$$

(17)

where $\widehat{n}$ is an automatically generated semantic description, $\widehat{F}$ contains the factors that repeatedly explain the concern, and $\widehat{d}$ describes the handling principle inferred from experience.

A single thinking event is not immediately accepted as transferable knowledge. Instead, multiple related records are accumulated and consolidated. Candidate records are grouped according to semantic and factor consistency, allowing fragmented observations of the same underlying concern to be merged before learning.

The candidate aspect is then validated using held-out interaction cases. Let ${\mathcal{V}}_k$ denote the validation set associated with candidate k. The candidate is accepted only if its factor consistency and prediction quality satisfy predefined reliability conditions:

$$\mathrm{Stability}\left(F_k\right)\ge {\tau }_F,\mathrm{F}1(M_k,{\mathcal{V}}_k)\ge {\tau }_V.$$

(18)

After validation, the new aspect is inserted into the repertoire:

$${\mathcal{A}}_{t+1}={\mathcal{A}}_t\cup \left\{A_{K_t+1}\right\}.$$

(19)

The corresponding local automatic model is trained only from the relevant factors:

$$M_{K_t+1}:X_{t-L:t}^{F_{K_t+1}}\to \left({\widehat{y}}_t,{\widehat{a}}_t\right).$$

(20)

This design prevents the learned knowledge from being unnecessarily coupled to the complete source task. For example, if a contamination-related concern is first discovered while cooking, the model is trained from contamination, temporary contact, and future sensitive contact rather than from the entire cooking state. Consequently, the same model can later be retrieved in a different task whenever the same concern reappears.

The repertoire therefore grows through experience:

$${\mathcal{A}}_0\subseteq {\mathcal{A}}_1\subseteq \cdots \subseteq {\mathcal{A}}_t,$$

(21)

enabling continued acquisition of new task-independent knowledge without requiring a manually specified catalog of reusable aspects.

3.5. From Explicit Thinking to Automatic Processing

A newly discovered aspect initially requires explicit reasoning because the robot has insufficient evidence to handle it automatically. As more examples are accumulated and $M_k$ becomes reliable, explicit thinking should gradually disappear.

For each aspect-related local checkpoint j, the robot maintains a utility value

$$v_j^{(n+1)}=\rho v_j^{\left(n\right)}+(1-\rho )I_j^{\left(n\right)},$$

(22)

where $I_j^{\left(n\right)}$ indicates whether explicit thinking produced useful new information during the n-th activation.

If repeated activations provide no meaningful new information, $v_j$ decreases. Once

$$v_j<{\tau }_d,$$

(23)

the local thinking checkpoint is suppressed, and the corresponding situation is handled directly by the learned automatic aspect model.

This produces a transition

$$\mathrm{Think}\to \mathrm{Collect}\to \mathrm{Learn}\to \mathrm{Reuse}\to \mathrm{Automatic}.$$

(24)

However, suppressing local thinking does not imply that the robot stops monitoring the environment. A low-frequency heartbeat mechanism periodically checks for changes that may invalidate existing automatic knowledge. If a new condition leads to a large mismatch, abnormal outcome, or unexplained uncertainty, the corresponding thinking trigger is reactivated.

Hence, the robot can return from automatic processing to explicit thinking:

$$\begin{array}{cc}\hfill \mathrm{Automatic}& \to \mathrm{Novel}\mathrm{Change}\to \mathrm{Thinking}\hfill \\ \hfill & \to \mathrm{New}\mathrm{or}\mathrm{Updated}\mathrm{Aspect}\to \mathrm{Automatic}\hfill \end{array}$$

(25)

The complete framework therefore supports continual autonomous knowledge development. Familiar parts of behavior are executed automatically, unresolved local concerns are isolated and matched against previously learned aspects, known concerns are reused across tasks without reconsidering the complete task, and genuinely novel concerns trigger the discovery of new aspects that can later become reusable automatic knowledge.

4. Verification

We evaluate whether the proposed framework can (i) autonomously identify reusable local aspects from otherwise routine experience, (ii) reuse the learned aspects across task, subtask, and domain boundaries, and (iii) gradually replace explicit thinking with automatic processing while reactivating thinking when the environment changes. Unless otherwise stated, all reported values are the mean and standard deviation over nine independent runs, obtained from three random seeds and three rounds per seed.

4.1. Experimental Environment and Protocol

4.1.1. Scenarios

The experiments use controlled long-horizon robotic interaction streams so that the ground-truth local concern, relevant factors, and required corrective action can be known by the evaluator while remaining unavailable to the proposed decision path. Each episode contains 15 routine action steps and a local temporal sensor window of length six over 14 candidate factors, including surface contamination, future sensitive contact, temporary placement, surface temperature, heat sensitivity, surface stability, support ratio, object geometry, surface wetness, surface friction, fragility, grasp force, vibration, and object mass. Benchmark aspect names, ground-truth factor sets, and correct source-to-target mappings are used only by the simulator/evaluator; they are not provided to the proposed scheduler, localizer, aspect retrieval process, or LLM prompts.

• Experiment 1: autonomous aspect discovery.

The first experiment tests whether the robot can determine what should be learned from a stream of otherwise familiar kitchen activities. Each run contains 36 acquisition episodes from two routine tasks, prepare meal and prepare drink. A local concern is present with probability 0.72 and is drawn from three qualitatively different cases: contaminated temporary placement before a future sensitive contact, placement of a heat-sensitive object on a hot surface, and geometrically unstable placement with insufficient support. Routine episodes contain none of these concerns. After acquisition, each concern is evaluated using independent refinement, final-validation, and held-out evaluation splits. Each split contains eight cases per concern and includes positive, hard-negative, and clean-negative instances. Thus, the experiment tests not only whether an aspect is discovered, but also whether its relevant factors, applicability condition, and handling principle generalize beyond the acquisition stream.

• Experiment 2: cross-task reuse and continual expansion.

The second experiment tests whether a locally learned aspect remains reusable when the surrounding task identity changes. The source stream contains 60 cooking episodes in Kitchen-A and teaches a cleanliness-related temporary-placement concern through positive, hard-negative, and clean-negative experience. The candidate is refined on 24 independent cases and accepted for transfer only after another 24-case final-validation split.

Zero-shot transfer is then evaluated in three target settings: (1) a different task with the same temporary-placement subtask while preparing drinking water, (2) a different subtask while serving food, and (3) a different domain while preparing a sterile laboratory sample. At every target checkpoint, six positive cases are tested per setting, together with nine irrelevant hard-negative cases. A further 48 target training examples are available only for measuring how much target-specific relearning is required, with evaluation checkpoints at 0, 6, 12, 24, 36, and 48 samples.

To test continual knowledge expansion rather than one-time transfer, the robot then encounters a genuinely new force-sensitive handling concern for 48 episodes. The new aspect is independently refined and validated on 24 cases each and is finally tested, without further learning, in an unseen optical-assembly task containing both positive and hard-negative cases.

• Experiment 3: thinking, automatization, and environmental change.

The third experiment contains 180 service-table episodes. Before episode 120, the robot repeatedly encounters a familiar cleanliness concern; its occurrence probability is 0.45 in the first 40 episodes and 0.18 thereafter. The familiar candidate is consolidated after the initial acquisition period and is refined and validated on independent 24-case splits. At episode 120, the environment changes: wet, low-friction placement becomes the relevant new concern, occurring with probability 0.42. Routine processing initially masks this novel slippery cue, forcing the system to rely on local anomaly evidence and thinking to discover it.

A heartbeat is executed every 10 episodes. For the novel concern, at least two strongly consistent local observations are required to establish a concern anchor, and a candidate must accumulate at least three independent support records before it can enter validation. Pre-anchor thinking evidence is temporarily buffered and backfilled only when it matches the autonomously inferred anchor. Acquisition is evidence-driven and remains open for at most 45 post-change episodes.

For the novel aspect, model update, threshold calibration, and final validation use three disjoint datasets. Twelve cases update the local model and support semantic refinement, another 12 cases calibrate the aspect-specific automatic threshold ${\tau }_k$, and 24 untouched cases are used only for final validation. Thresholds are searched over $[0.30,0.75]$ with step 0.01 while requiring calibration precision and recall of at least 0.70. This separation prevents the final validation set from being used for training, checkpoint selection, or threshold tuning.

4.1.2. Implementation and Configuration

The thinking component uses the deepseek-v4-flash model through an OpenAI-compatible API with temperature 0.0 and a maximum output length of 1200 tokens. Local aspect monitors are compact temporal Transformers operating on the six-step local window. Each Transformer uses $d_{\mathrm{model}}=32$, four attention heads, two encoder layers, a feed-forward dimension of 64, dropout 0.1, and is trained for eight epochs with AdamW at learning rate ${10}^{-3}$ and weight decay ${10}^{-4}$. Candidate aspects require at least three independent supporting episodes and both positive and negative local examples before validation. A transferable aspect must reach validation precision and recall of at least 0.70, F1 of at least 0.75, and handling success of at least 0.90.

For the proposed scheduler, the thinking threshold is 0.52 and the local aspect reuse threshold is 0.58. Applicability conditions must match at least 0.80. Existing uncalibrated aspect models use an automatic threshold of 0.62; in Experiment 3, the new aspect learns an aspect-specific threshold ${\tau }_k$ from the independent calibration split.

4.1.3. Compared Methods

The following comparisons are used where applicable. Task-Level RF uses an online Random Forest bank indexed by the whole task, while Fixed-Subtask RF uses the same supervised learner indexed by the current subtask/action type. Both use 120 trees, maximum depth 10, minimum leaf size 2, and a decision threshold of 0.50. Full-Context LLM re-reasons from the complete task trajectory and sensor context whenever a decision is required and does not consolidate a local automatic aspect model.

Experiment 2 additionally uses Proposed-No-Transfer, which is identical to the proposed method during source learning but clears the learned aspect memory before target evaluation. This provides a causal test of whether zero-shot target performance comes from transferred aspect knowledge. Experiment 3 additionally uses No Checkpoint Decay, No Heartbeat, and Always Think. They respectively disable decay of already-resolved thinking checkpoints, disable periodic heartbeat inspection, and force explicit thinking at every episode.

4.1.4. Metrics

Standard precision, recall, and F1 are used for aspect and factor identification. For Experiment 1, the irrelevant-factor ratio measures the fraction of selected factors that are not part of the evaluator’s relevant-factor set,

$$R_{\mathrm{irr}}={\displaystyle \frac{{\sum }_t|{\widehat{F}}_t\setminus F_t^{\mathrm{gt}}|}{{\sum }_t\left|{\widehat{F}}_t\right|}},$$

(26)

and the stored-experience ratio measures the fraction of the 15-step episode history retained as learning material. Safe success measures whether the required correction was executed without introducing an unsafe action. Validation handling success is reported separately from aspect-model F1 so that identifying when a concern applies is not confused with selecting how it should be handled.

For Experiment 2, zero-shot automatic success requires the target case to be handled by the learned automatic aspect without a thinking call. We separately report same-subtask, cross-subtask, and cross-domain transfer. The number of target samples required to reach 0.80 automatic success and the area under the target adaptation curve quantify target-specific relearning. The second novel-aspect stage reports discovery recall and zero-shot reuse in another unseen task.

For Experiment 3, thinking rate is measured in the early familiar period, late familiar period, first 20 episodes after the environmental change, and final 20 episodes. Novel-detection delay measures the number of episodes from the environment change to the first correct identification of the new concern. We also report automatic-processing rate, novel-aspect validation, and LLM calls/tokens. Because post-validation behavior is undefined when a candidate is rejected, conditional post-validation detection, handling, and automatic rates are reported over the runs in which the novel aspect actually passed independent validation.

4.2. Experiment 1: Autonomous Identification and Learning of Local Aspects

Table 1 summarizes the acquisition and held-out results. The proposed method achieves an aspect F1 of $0.975\pm 0.029$ and factor F1 of $0.965\pm 0.057$, substantially above Full-Context LLM ($0.380\pm 0.121$ and $0.378\pm 0.054$) and the two RF baselines during acquisition. Its irrelevant-factor ratio is only $0.041\pm 0.039$, compared with $0.572\pm 0.080$ for Fixed-Subtask RF and $0.713\pm 0.050$ for Full-Context LLM. This indicates that local concern localization removes most task-level context that is unrelated to the learned aspect.

All three intended local aspects are independently validated in every proposed run: the validated-aspect count is $3.0\pm 0.0$, validation handling success is $1.000\pm 0.000$, and mean validation F1 is $0.944\pm 0.110$. On the held-out split, the proposed method maintains factor F1 $0.893\pm 0.036$ and safe success 1.000 while calling thinking on only $0.130\pm 0.014$ of the cases. Fixed-Subtask RF obtains a higher held-out aspect F1 ($0.951\pm 0.096$ versus $0.908\pm 0.060$), but this result is coupled to the known subtask index: its held-out factor F1 is only $0.434\pm 0.016$ and its irrelevant-factor ratio rises to $0.722\pm 0.010$. The proposed method therefore better captures the task-independent local factors needed for subsequent transfer rather than merely predicting a concern within a fixed subtask.

The proposed method stores only $0.304\pm 0.025$ of the full episode history, compared with 1.0 for Task-Level RF and Full-Context LLM. It also uses $32.0\pm 2.4$ LLM calls per run, versus $64.6\pm 8.8$ for Full-Context LLM, while achieving higher safe success. Figure 1 visualizes the main quality metrics. Overall, Experiment 1 demonstrates that thinking can identify what local knowledge is worth learning, validate its handling principle, and discard most irrelevant task-level context.

4.3. Experiment 2: Cross-Task Reuse and Continual Aspect Expansion

Table 2 reports the zero-shot target results. Across all nine runs, the proposed method obtains automatic success $0.889\pm 0.333$ in the same-subtask, cross-subtask, and cross-domain settings. The identical value in all three settings is not caused by partial success within each run: the source aspect passes final validation in eight of nine runs, and in all eight successful source-validation runs, zero-shot automatic success is exactly 1.0 in all three target settings. In those eight runs, no target-specific training sample is required to reach 0.80 automatic success and the target adaptation AUC is 1.0. The remaining run correctly rejects the source candidate during validation, producing the overall mean of 0.889 rather than transferring unvalidated knowledge.

The ablations establish that the improvement is specifically due to transferable local knowledge. Proposed-No-Transfer learns and validates the same source candidate but clears the aspect memory before target evaluation; consequently, all three zero-shot automatic rates fall from 0.889 to 0.0 and the target sample requirement increases from $4.0\pm 12.0$ to $37.3\pm 4.0$. Fixed-Subtask RF reaches 1.0 only when the target retains the same subtask, but falls to 0 in both cross-subtask and cross-domain cases. This contrast is important: it shows that the proposed reuse is not explained by memorizing the action/subtask identity, but follows the recurring local concern.

Figure 2 shows the same result visually. The proposed method is the only trainable method that retains high zero-shot automatic performance after both the subtask and domain identity change. Full-Context LLM remains safe in many zero-shot cases ($0.988\pm 0.024$ safe success) but has zero automatic reuse because it reasons explicitly at every target case.

The continual-learning stage provides a second test that is not tied to the original cleanliness example. The force-sensitive concern is genuinely novel, so its first positive occurrence is not handled automatically (zero-shot automatic success 0), but it is discovered in every run (discovery recall 1.0). After learning and independent validation, the second aspect is reused in the unseen optical-assembly task with zero-shot automatic success $0.972\pm 0.083$ and zero thinking on positive reuse cases. This closes the loop from discovery to independent learning and then to reuse of newly acquired knowledge.

Transfer also reduces repeated reasoning. The proposed method uses $110.7\pm 35.9$ LLM calls and $96.0\mathrm{k}\pm 29.8\mathrm{k}$ tokens per run, compared with $191.1\pm 10.8$ calls and $168.0\mathrm{k}\pm 7.0\mathrm{k}$ tokens for Proposed-No-Transfer, reductions of 42.1% and 42.9%, respectively. Relative to Full-Context LLM, the reductions are 50.3% in calls and 58.0% in tokens. These results demonstrate that task-independent local aspects support both zero-shot transfer and lower future learning/reasoning cost.

4.4. Experiment 3: From Explicit Thinking to Automatic Processing

Figure 3 and Table 3 evaluate whether thinking is used selectively rather than permanently. For the proposed method, thinking decreases from $0.508\pm 0.087$ in the early familiar stage to exactly $0.100\pm 0.000$ after familiarization, an 80.3% reduction. When the environment changes at episode 120, the rate increases to $0.256\pm 0.063$, a 155.6% increase relative to the familiar stage, and then falls again to $0.139\pm 0.070$ in the final stage. The resulting pattern

$$0.508\to 0.100\to 0.256\to 0.139$$

directly supports the intended transition from thinking to automatic processing, reactivation under novelty, and subsequent re-automatization.

The checkpoint-decay ablation explains the final decrease. Without decay, final thinking remains $0.394\pm 0.129$, whereas the proposed method reaches $0.139\pm 0.070$, a 64.8% reduction. At the same time, automatic processing rises from $0.666\pm 0.045$ to $0.773\pm 0.037$, while safe success remains similar ($0.928\pm 0.038$ versus $0.936\pm 0.033$). Thus, checkpoint decay primarily removes unnecessary repeated reasoning rather than trading away safety.

Heartbeat has a different role. Removing heartbeat gives a higher apparent automatic rate ($0.858\pm 0.022$) because the robot inspects less often, but novel-concern detection delay increases from $11.0\pm 5.45$ to $23.56\pm 10.37$ episodes. Novel detection recall decreases from $0.494\pm 0.273$ to $0.050\pm 0.018$, and safe success falls from $0.936\pm 0.033$ to $0.882\pm 0.024$. Therefore, the higher automatic rate of No Heartbeat reflects missed opportunities to reconsider a changed environment, not better adaptation.

The novel concern itself is localized consistently: the proposed method establishes a concern anchor in all nine runs, and all nine anchors contain the same two local factors, surface friction and surface wetness. All nine candidates accumulate the required three independent support records and enter validation. Aspect-specific automatic thresholds are then calibrated to ${\tau }_k=0.573\pm 0.080$, ranging from 0.44 to 0.71, rather than using a fixed threshold for every learned model. Calibration precision, recall, and F1 are 1.0 in all nine runs. On the untouched final-validation set, mean aspect-model F1 is $0.923\pm 0.106$ and seven of the nine novel candidates satisfy the complete validation criteria.

The two rejected runs are informative rather than being silently automated: both identify the correct friction/wetness concern, but their selected handling action does not satisfy the independent handling-success requirement. The validation gate therefore prevents an incorrectly grounded action from becoming trusted automatic knowledge. Conditional on the seven runs that pass validation, post-validation novel detection is 0.976, handling success is 0.976, and automatic handling is 0.845, while the final thinking rate falls to 0.107. These results demonstrate that validated local knowledge can reliably replace repeated explicit thinking, while unreliable knowledge remains subject to further reasoning rather than being automated blindly.

Finally, Always Think provides a useful upper-cost reference. It obtains safe success $0.975\pm 0.048$, somewhat above the proposed method, but requires $181.9\pm 1.5$ LLM calls and $142.9\mathrm{k}\pm 9.3\mathrm{k}$ tokens per run. The proposed scheduler requires only $43.0\pm 8.0$ calls and $38.9\mathrm{k}\pm 10.4\mathrm{k}$ tokens, reducing calls by 76.4% and tokens by 72.8%. Thus, continuous reasoning can improve safety modestly in this controlled setting, but it prevents automatization and incurs substantially higher reasoning cost.

4.5. Overall Findings

Across the three experiments, the results support the three central claims of the framework. First, the robot can autonomously isolate compact local aspects from long-horizon routine experience: Experiment 1 reaches factor F1 0.965 with only 0.041 irrelevant-factor ratio and validates all three learned concerns. Second, the learned knowledge is not bound to the source task: Experiment 2 achieves perfect same-subtask, cross-subtask, and cross-domain automatic transfer in every run where the source aspect passes independent validation, and a second newly discovered force-sensitive aspect is later reused with 0.972 zero-shot automatic success. Third, thinking is neither permanently active nor permanently disabled: Experiment 3 reduces thinking from 0.508 to 0.100 after familiarization, raises it again after an environmental change, and returns toward automatic processing after new knowledge has been validated.

The experiments also expose a remaining limitation. Independent validation rejects two of nine newly learned slippery-surface candidates because the LLM-selected handling action is not sufficiently reliable even though the local concern is correctly identified. Rather than weakening the validation threshold, the current framework leaves such knowledge unautomated. This suggests that future work should improve semantic grounding between the learned handling principle and the available low-level action primitives, while preserving the separation between discovery, calibration, and final validation.

5. Conclusions

This paper presented a thinking-triggered aspect learning framework that enables robots to selectively activate reasoning, autonomously identify reusable local concerns, validate newly acquired knowledge, and gradually replace repeated thinking with automatic processing. Rather than transferring whole tasks, the framework represents task-independent aspects through relevant factors, applicability conditions, handling principles, local automatic models, and calibrated activation thresholds. Experiments showed that the method accurately discovers compact aspects, transfers validated knowledge across task and domain boundaries, and reactivates thinking when environmental conditions change. The proposed scheduler also substantially reduces unnecessary LLM reasoning while preserving strong post-validation detection and handling performance. Future work will focus on improving the grounding of learned handling principles to low-level actions and extending the framework to more complex physical robots and open-ended environments.