Minimal-Core Open Learning for Autonomous Agents: Expanding What, How, and from What to Learn

1. Introduction

Autonomous agents are expected to operate for long periods in environments that cannot be completely specified in advance. As their experience accumulates, they may need to recognize new learning problems, acquire previously unused information, adopt more suitable learning methods, reuse earlier knowledge, and reorganize what has been learned for future tasks. This suggests that long-term autonomy requires more than continual parameter optimization within a fixed architecture. A more fundamental objective is to minimize the amount of task-specific structure that must be permanently predefined, while preserving only the generic mechanisms necessary for observation, action, evaluation, safety, and validated change. Such a design can allow an initially small system to expand its competence through experience instead of relying on an increasingly large set of handcrafted assumptions.

However, most existing solutions still fix substantial parts of the learning process before deployment. Continual and open-ended learning typically assume predefined observation/action interfaces and learning mechanisms; meta-learning and AutoML automate adaptation but operate within manually specified task distributions or search spaces; LLM-based agents introduce reasoning and reflection, but usually within fixed prompting, memory, and tool-use workflows; and long-term memory systems generally commit to a predefined retrieval or organization scheme. As a result, a system may be able to learn new task parameters while still depending on fixed choices about what constitutes a task, which inputs are relevant, which learning family can be used, how previous results are retrieved, and how heterogeneous learned contents are organized. These hidden forms of predefinition can restrict the ability of the system to continue expanding when future learning requirements differ from those anticipated by the designer.

This paper proposes Minimal-Core Open Learning (MCOL), a framework for constructing autonomous learning systems from a small fixed core and a progressively expandable component. The fixed core contains only generic capabilities that are difficult or unsafe to eliminate, including basic observation and action interfaces, primitive evaluation, resource and safety constraints, and a validated mechanism for proposing, testing, retaining, or rejecting changes. All components that can be learned reliably are, in principle, moved into the expandable part. The system is therefore represented as a minimal core together with a learned component that may grow and change over time. Rather than assuming a complete task list, MCOL allows the agent to discover what should be learned, extend the set of useful inputs, select or acquire different learning methods, accumulate heterogeneous learned contents, and revise how these contents are retrieved and organized.

A key mechanism in MCOL is Thinking-Guided Learning. When the outcome of the current learning process is insufficient or ambiguous, a reasoning process can analyze the failure and propose how the learning process itself should change. It may request additional or more targeted training material, investigate whether a new information source is required, recommend a different learning method, or suggest changes to retrieval and organization. Thinking is not treated as the permanent task learner and a particular LLM is not part of the fixed core; instead, it acts as an adaptive control mechanism for the expandable learning process. Importantly, a suggested modification is not accepted simply because it was proposed by the reasoning model. It must pass empirical validation under common acceptance criteria. In this way, MCOL combines open expansion with controlled modification and avoids replacing one set of fixed rules with unverified reasoning outputs.

The main contributions of this work are as follows:

• We introduce MCOL, a system-level learning framework that explicitly separates a small generic fixed core from an expandable learned component, with the principle that reliably learnable task-specific structure should not remain permanently predefined.
• We formulate an expandable learning path in which the system can progressively learn not only task knowledge, but also what should be learned, which information should be used, which learning method is appropriate, and how accumulated knowledge should be retrieved and organized.
• We introduce Thinking-Guided Learning as a feedback mechanism that uses learning outcomes to diagnose insufficient learning, acquire diagnostic evidence when necessary, and revise subsequent learning under empirical validation.

The remainder of this paper is organized as follows. Section 2 reviews continual and open-ended learning, meta-learning and automated learning systems, LLM-based reasoning and reflection, and memory and knowledge organization. The following section presents the MCOL model, including the minimal fixed core, expandable learning path, Thinking-Guided Learning, and learned organization and retrieval mechanisms. Section 4 describes the experimental settings and verifies the major mechanisms of the proposed framework. Finally, the paper concludes with a summary of the findings and directions for further development.

2. Related Work

2.1. Continual, Open-Ended, and Embodied Learning

Continual learning studies how an agent can acquire new knowledge over time while retaining and reusing what has already been learned. In robotics, this objective is particularly important because the data distribution, task requirements, and interaction conditions may change after deployment. Continual World, for example, provides a robotic continual-reinforcement-learning benchmark that emphasizes not only catastrophic forgetting but also forward transfer across a sequence of manipulation tasks [1]. Such work establishes an important foundation for long-lived autonomous agents: past experience should improve future learning instead of being discarded. Its strength is that the learning process is explicitly evaluated over time rather than on isolated tasks. However, the task family, observation interfaces, action spaces, and the learning algorithmic framework are still largely specified in advance. The central problem is therefore how to learn a sequence of known-form tasks more effectively, rather than how to decide which parts of the learning system itself should remain fixed or become expandable.

Open-ended learning goes further by allowing the set of challenges to grow during interaction. POET jointly evolves environments and their solutions, thereby generating increasingly diverse problems and exploiting transfer between solutions as stepping stones [2]. This is a major conceptual advance because the learning problems are no longer all enumerated by a designer. Voyager brings a related open-ended idea to an embodied, language-model-driven agent: it uses an automatic curriculum, an expanding executable skill library, and iterative prompting with environment feedback to continually explore Minecraft and accumulate reusable skills [3]. These systems demonstrate the benefit of allowing the agent’s competence to expand beyond a static task list. At the same time, the mechanisms through which expansion occurs are themselves strongly structured: POET assumes a particular environment–agent co-evolution process, while Voyager prespecifies an automatic curriculum module, a code-based skill library, and a fixed retrieval-and-prompting workflow.

RoboCat represents another important direction: a generalist robotic manipulation agent that can adapt to new tasks and embodiments and then incorporate newly generated experience into later training iterations [4]. Its main advantage is large-scale cross-task and cross-embodiment transfer with a common policy model, which reduces the need to train a completely separate controller for every new manipulation problem. Nevertheless, its self-improvement loop primarily expands task experience within a specified learning architecture. In contrast, the goal of MCOL is not only to accumulate more tasks or skills, but to make multiple parts of the learning process expandable. MCOL therefore asks a complementary question: starting from a small generic core, can the agent progressively learn what should be learned, which information should be used, which learning method is appropriate, and how learned contents should be retrieved and organized? In this sense, continual and open-ended learning provide the motivation for long-term expansion, whereas MCOL focuses on reducing the amount of task-specific learning structure that must be permanently predefined.

2.2. Meta-Learning, AutoML, and Self-Improving Learning Systems

Meta-learning aims to improve the learning process itself by exploiting experience across tasks. Model-Agnostic Meta-Learning (MAML), for example, optimizes model parameters so that a small number of gradient updates can rapidly adapt the model to a new task [5]. The major benefit of this line of work is that prior learning changes the efficiency of future learning, which is also an important objective in MCOL. Meta-learning is especially effective when new tasks belong to a task distribution that is sufficiently related to the meta-training distribution. However, the learner class, optimization mechanism, task interface, and usually the form of the task distribution are still selected before meta-training. Consequently, meta-learning normally learns how to adapt within a learning formulation, rather than whether the formulation itself should acquire new information sources, replace the learning method, discover a previously unlisted learning problem, or reorganize accumulated knowledge.

Automated machine learning (AutoML) expands the scope of adaptation from model parameters to parts of the machine-learning pipeline. Existing AutoML systems automate feature engineering, hyperparameter optimization, model selection, and neural architecture search [6]. This reduces expert effort and is directly relevant to MCOL’s idea that learnable decisions should not remain permanently hand-coded. A key advantage of AutoML is that it can search among alternative algorithms and representations rather than assuming that one fixed model is always appropriate. However, most AutoML systems still operate inside a human-defined search space and are commonly applied to a predefined dataset and objective. Even the AutoML literature has identified the manually specified search space, primitive operations, data collection process, and the difficulty of lifelong reuse as continuing limitations [6]. Thus, AutoML makes the learning pipeline more automatic, but does not by itself define a minimal autonomous-agent core in which the boundary between fixed and learnable components can progressively move.

Recent self-improving agent research further broadens this idea. The Darwin Gödel Machine (DGM) iteratively modifies its own agent code, empirically evaluates the modifications, and maintains a diverse archive of improved agents, thereby combining self-modification with open-ended search [7]. Its strength is that the improvement space includes parts of the agent implementation itself, rather than only conventional model parameters. The approach, however, is currently centered on coding agents and relies on benchmark-based empirical validation of generated code changes. MCOL shares the principle that a change should be retained only after validation, but places it in a different system model: a small fixed core provides generic observation, action, evaluation, safety/resource constraints, and validated modification, while the expandable part includes tasks, input representations, learning methods, learned contents, retrieval, and organization. Thus, meta-learning, AutoML, and self-modifying agents each automate important portions of learning, whereas MCOL attempts to integrate these ideas under an explicit minimal-core versus expandable-system distinction.

2.3. LLM Reasoning, Reflection, and Thinking-Guided Adaptation

Large language models have enabled agents to use explicit reasoning as part of interaction and decision making. ReAct interleaves reasoning traces with actions, allowing an agent to update plans while also gathering external information from environments or knowledge sources [8]. This is particularly relevant when a decision cannot be made reliably from the initially available information. The main benefit is that reasoning becomes coupled to information acquisition rather than remaining a purely internal chain of thought. Nevertheless, ReAct is primarily a task-execution framework: reasoning selects actions and information-gathering steps for solving the current problem. It does not explicitly treat failures of the learning process as objects that can trigger changes to training material, input representation, learning method, or long-term knowledge organization.

Reflexion extends language-agent adaptation by using verbal feedback and self-reflection stored in episodic memory to improve subsequent trials [9]. It demonstrates that useful adaptation can occur without modifying the underlying LLM weights, and that textual reflection can convert task feedback into reusable guidance. Generative Agents similarly combine memory, retrieval, reflection, and planning so that accumulated experience influences later behavior [10]. These approaches show an important advantage of language-based reflection: heterogeneous outcomes, errors, and observations can be interpreted in a common representational medium. Their limitation for the present problem is that reflection is mainly used to revise plans, prompts, or episodic guidance. The surrounding learning architecture—what data to collect, what learner to use, how to validate a learning change, and how the learned knowledge system itself should evolve—is still mostly provided by the system designer.

MCOL’s Thinking-Guided Learning mechanism uses LLM reasoning in a narrower but structurally different role. Thinking is not treated as the permanent learning engine and a particular LLM is not part of the minimal fixed core. Instead, reasoning is invoked when learning outcomes indicate insufficiency or ambiguity, and its suggestions may change the learning process itself. For example, thinking may request new training material, test whether an additional information source is needed, propose a different model family, or trigger changes in retrieval or organization. Importantly, the proposed change is not accepted merely because the LLM suggested it; it is subject to empirical validation. This separates reasoning about how learning should change from the learner that ultimately performs the task. Relative to ReAct and Reflexion, the intended contribution is therefore not another general prompting strategy, but an architectural role for thinking as a feedback mechanism that helps an otherwise minimally predefined learning system decide how its expandable components should be revised.

2.4. Memory, Retrieval, and Organization of Learned Knowledge

Long-lived agents require more than parameter learning; they must also preserve and recover useful information accumulated over time. Retrieval-Augmented Generation (RAG) combines parametric generation with an explicit non-parametric memory accessed through retrieval, demonstrating that external knowledge can improve knowledge-intensive generation and make stored information easier to update [11]. MemGPT addresses the related limitation of bounded context by introducing operating-system-inspired management of different memory tiers, allowing an LLM agent to move information between short- and long-term memory [12]. These approaches make memory an explicit system component rather than assuming that all useful knowledge must be embedded permanently in model parameters. Their benefit is modularity: stored knowledge can be expanded without retraining the complete underlying model.

Agent-memory systems also demonstrate that retrieval policy matters. Generative Agents store experiences, derive higher-level reflections, and dynamically retrieve memories for planning [10]; Voyager retrieves previously acquired executable skills from an expanding skill library [3]. Such designs show that memory is not useful merely because information is retained: future performance depends on how stored contents are indexed, selected, summarized, and composed. However, most systems still commit to a predefined memory organization—for example, vector retrieval, a tiered memory hierarchy, episodic text records, or a code-skill library. The retrieval mechanism may contain learned components, but the choice of the overall organization and its structural role is normally fixed by the architecture.

MCOL treats both retrieval and organization as potentially learnable. The accumulated content set may contain heterogeneous objects such as learned models, rules, experiences, summaries, task relations, or reusable methods. Rather than requiring all of them to fit one predefined knowledge graph, hierarchy, or flat vector store, MCOL permits the organization policy itself to evolve according to later reuse requirements. Retrieval then operates on the current learned organization, and retrieval failures can trigger revision of either the retrieval policy, the organization, or both. This distinction is important for a minimal-core system: if the future form of useful knowledge is not known in advance, permanently fixing its organization can become another hidden source of predefinition. MCOL therefore builds on the strong evidence for external memory and learned retrieval in prior work, but extends the learnability boundary to the organization of heterogeneous learned contents itself.

2.5. Relation of MCOL to Existing Approaches

The above research directions address different parts of the same long-term autonomy problem. Continual and open-ended learning enable competence to grow over time; meta-learning and AutoML improve the efficiency or automation of learning; LLM-based agents introduce reasoning, reflection, and information acquisition; and memory systems allow accumulated knowledge to persist and be reused. Each direction provides mechanisms that are useful to MCOL, and MCOL does not replace these learning algorithms. Instead, these algorithms can appear as candidates inside the expandable part of the system.

The main distinction is the location of predefinition. Existing systems commonly make one or more strong architectural commitments in advance: a fixed task interface, fixed input representation, predefined method family or search space, fixed reflection workflow, fixed memory form, or fixed organization scheme. MCOL explicitly treats these commitments as candidates for removal whenever they can be learned and validated reliably. Its objective is therefore not simply “more continual learning” or “more self-improvement,” but a system-level principle: preserve only the generic mechanisms required for safe observation, action, evaluation, and validated modification, and allow the remaining learning structure to expand through experience.

This perspective also clarifies why the components evaluated in this paper are considered jointly. Discovering a new learning problem without the ability to acquire the required inputs may be insufficient; acquiring new inputs without the ability to change the learning method can still fail; learning many models without retrieval and organization can make prior knowledge difficult to reuse; and reasoning without empirical validation can introduce unreliable modifications. MCOL combines these dependencies into one minimal-core framework and uses Thinking-Guided Learning as an adaptive control mechanism when the current learning process is inadequate. The contribution is therefore primarily architectural: it defines a progressively expandable learning system in which multiple traditionally predefined components can become learned components while a small generic core remains stable.

3. Minimal-Core Open Learning Model

3.1. Design Principle and Overall Structure

The proposed model aims to support long-term learning in an open system while minimizing the amount of task-specific knowledge and processing logic that must be predefined. Its central principle is that only the mechanisms necessary to initiate, evaluate, and constrain learning should remain fixed, whereas components that can be reliably acquired, revised, reorganized, or replaced through experience should remain expandable.

At time t, the whole system is represented as

$${\mathcal{S}}_t={\mathcal{C}}_{min}\cup {\mathcal{E}}_t,$$

(1)

where ${\mathcal{C}}_{min}$ denotes the minimal fixed core and ${\mathcal{E}}_t$ denotes the expandable part of the system. The expandable part may contain the currently discovered learning problems, input representations, learning methods, learned knowledge, the structures used to organize heterogeneous learned contents, and the strategies used to retrieve and reuse them.

The role of the minimal core is not to prescribe how future tasks must be solved. Instead, it provides only the basic capabilities required for learning to continue safely and evaluably. The role of the expandable part is to absorb as much of the learning process as possible, so that the system can progressively reduce its dependence on predefined task-specific logic.

A central mechanism inside the expandable learning process is thinking-guided learning. Minimal-Core Open Learning (MCOL) determines which parts of the learning system remain fixed and which are allowed to change, whereas thinking-guided learning provides a general mechanism for deciding how the expandable parts should be revised when current learning is insufficient. In this sense, thinking-guided learning reduces the need to predefine a large number of adaptation rules for future unknown situations.

The overall learning process can be summarized as

$$\begin{array}{cc}\hfill \mathrm{experience}& \to \mathrm{learning}\mathrm{problem}\hfill \\ \hfill & \to \mathrm{input}\mathrm{construction}\hfill \\ \hfill & \to \mathrm{method}\mathrm{selection}/\mathrm{acquisition}\hfill \\ \hfill & \to \mathrm{learning}\hfill \\ \hfill & \to \mathrm{content}\mathrm{organization}\hfill \\ \hfill & \to \mathrm{retrieval}\mathrm{and}\mathrm{reuse}.\hfill \end{array}$$

(2)

When learning outcomes reveal persistent errors, uncertainty, insufficient data, inappropriate methods, ineffective organization, or poor retrieval, a thinking process analyzes the current learning state and guides the revision of the corresponding expandable component. Therefore, the learning result is not only an output of the current learning process, but can also become feedback for changing how future learning is performed.

The long-term development of the system is expressed as

$${\mathcal{E}}_{t+1}=\mathcal{U}\left({\mathcal{E}}_t,e_t,T({\mathcal{E}}_t,e_t)\right),$$

(3)

where $e_t$ denotes the observed learning outcome, $T(·)$ denotes the thinking process, and $\mathcal{U}$ denotes the validated update of expandable components. The thinking process may be implemented by an LLM, another reasoning model, or a hybrid mechanism. Importantly, it does not directly determine whether a proposed change is accepted; candidate changes must still be evaluated under the utility, resource, and safety criteria of the minimal core.

3.2. Minimal Fixed Core

A fully unconstrained system cannot bootstrap its own learning because some mechanism must already exist to receive information, interact with the environment, evaluate consequences, and preserve useful changes. The proposed model therefore retains only a small fixed core rather than attempting to make every component learnable from the beginning.

The minimal core contains four basic functions.

First, the system requires a basic interaction interface. It must be able to receive observations, generate outputs or actions, and obtain subsequent environmental or internal feedback. These interfaces define only how information enters and leaves the system; they do not prescribe which features are important or how the information should be interpreted.

Second, the system requires a primitive evaluation mechanism. Its role is not to define a complete task-specific reward function, but to provide sufficient evidence for determining whether a newly learned behavior, representation, learning method, organization structure, or retrieval strategy should be retained. Evaluation may be based on task outcomes, prediction errors, environmental feedback, internal states, safety signals, or combinations of these sources.

Third, the system requires a generic modification mechanism that can propose, test, retain, or reject changes. This mechanism enables expandable components to be revised without specifying in advance what the content of those revisions must be.

Fourth, the system retains necessary resource and safety constraints. A candidate change c is accepted only when

$$U\left(c\right)>{\tau }_u,\mathrm{Cost}\left(c\right)<B,\mathrm{Risk}\left(c\right)<{\tau }_r,$$

(4)

where $U\left(c\right)$ is the measured utility of the change, B is the available resource budget, and ${\tau }_u$ and ${\tau }_r$ are the minimum utility and maximum acceptable risk thresholds, respectively.

Thinking itself is not treated as additional task-specific knowledge that must be permanently fixed in the core. The fixed requirement is only that the system can invoke a reasoning process when needed, expose the relevant learning state to it, and evaluate the resulting guidance using the same acceptance mechanism. Thus, one implementation may use an LLM as the thinking mechanism, while another reasoning model or a subsequently acquired mechanism may replace it later.

The distinction between fixed and learnable components is therefore dynamic rather than purely architectural. A component should remain in ${\mathcal{C}}_{min}$ only when it is required for bootstrapping, safety, reliable evaluation, or when no dependable learning process is yet available for acquiring it. Once a component becomes reliably learnable, it can in principle be moved into ${\mathcal{E}}_t$. This principle provides a systematic basis for reducing predefined structure over time.

3.3. Expandable Learning Path

The main innovation of the proposed model is that learning is not restricted to parameter optimization inside a fixed task and feature space. Instead, multiple stages of the learning path are themselves expandable. The system can progressively learn what should be processed, which information should be used, and how the corresponding input–output relation should be learned. Expansion may arise directly from accumulated experience or be triggered by thinking when the current learning process exposes persistent errors, uncertainty, insufficient material, or method mismatch.

Learning what should be learned.

The system is not required to receive a complete predefined task list. Repeated, consequential, or predictable relations discovered during interaction may be promoted into explicit learning problems. Let

$${\mathcal{P}}_t=\{P_1,\dots ,P_{N_t}\}$$

denote the set of currently known learning patterns. A pattern $P_i$ represents a useful relation between observations or internal states and a target output, prediction, decision, or action. When a previously unknown relation repeatedly contributes to successful prediction or action, a new pattern can be added to ${\mathcal{P}}_t$. Thus, the set of learning problems itself can expand.

Learning the input representation.

For a learning problem $P_i$, the useful inputs are not assumed to be known in advance. The system may initially use only a limited subset of observations and later introduce new sensor channels, derived variables, temporal histories, or externally obtained information. The input used at time t is represented as

$$z_t={\varphi }_t\left(o_{1:t}\right),$$

(5)

where $o_{1:t}$ denotes the available observation history and ${\varphi }_t$ is the current input-construction process.

The function ${\varphi }_t$ is broader than conventional feature selection over a fixed vector. It may select existing variables, construct derived features, introduce temporal context, combine multiple modalities, or acquire a previously unused information source. For example, a manipulation task may initially depend only on visual position, but repeated failures may reveal that object orientation, force history, or surface properties are also relevant. The input representation can then be expanded without manually redesigning the task.

Learning or acquiring the processing method.

The model also avoids fixing a single learning algorithm for all discovered problems. For each problem, the system may select among currently available methods, compose several methods, or search for a new method when existing ones are insufficient. Let

$${\mathcal{M}}_t=\{m_1,\dots ,m_{K_t}\}$$

denote the currently available method set. It may include statistical models, machine-learning models, deep neural networks, LLM-based reasoning procedures, programmatic rules, external tools, or newly acquired algorithms.

If the best available method does not provide sufficient utility,

$$\underset{m\in {\mathcal{M}}_t}{max}U(m\mid P_i)<{\tau }_m,$$

(6)

the system initiates method expansion. Expansion may involve model replacement, method composition, external search, LLM-assisted proposal generation, or the integration of a newly implemented algorithm. A new method is retained only after empirical evaluation. Therefore, the model does not require all learning methods to be built from scratch; rather, it treats the selection, acquisition, and reuse of learning mechanisms as part of the open learning process.

3.4. Thinking-Guided Learning

A central mechanism for maintaining open learning with a small fixed core is thinking-guided learning. Its purpose is to replace part of the predefined adaptation logic that would otherwise have to specify in advance how the system should respond to every future learning failure. Instead of encoding many rules such as “collect more data when accuracy drops” or “use a sequence model when temporal dependence appears,” the system can reason about the cause of insufficient learning and decide which expandable component should be revised.

Let the current learning state contain the active problem, available materials, current methods, accumulated knowledge, current organization structure, retrieval strategy, and recent learning outcome. The thinking process analyzes this state and generates guidance

$$g_t=T\left({\xi }_t\right),$$

(7)

where ${\xi }_t$ denotes the current learning state and $g_t$ specifies a candidate revision to the subsequent learning process.

Thinking-guided material reacquisition.

When the available training materials are insufficient, biased, ambiguous, or unable to explain repeated failures, thinking may guide the system to obtain better material instead of repeatedly training on the same data. Possible actions include observing the environment from another viewpoint, activating a previously unused sensor, collecting additional samples near uncertain regions, retrieving similar historical failures, or constructing additional training cases. The resulting material set is expanded before learning continues.

Thinking-guided method expansion.

When existing methods repeatedly fail or their performance saturates, thinking may analyze the failure pattern and propose a more appropriate learning mechanism. For example, it may infer that temporal dependence requires a recurrent or sequence model, that a symbolic relation is better handled by rule induction, or that an external method should be searched and incorporated. The proposed method is not accepted merely because it is suggested by the thinking process; it must still be trained or instantiated and evaluated through Eq. 4.

Thinking-guided organization and reuse.

Thinking may also operate on already learned contents and methods. As the number and diversity of learned contents grow, the current organization may become inefficient. Thinking can then analyze reuse patterns and decide whether contents should remain unstructured, be grouped hierarchically, be connected as a graph, or be reorganized into a hybrid structure. Similarly, several learned methods that repeatedly solve related problems may be grouped into a method family or organized as a reusable processing sequence. Repeated retrieval failures can also trigger a revision of the relations emphasized during retrieval.

The key role of thinking is therefore not to replace learning, but to guide learning. Its effect can be summarized as

$$\begin{array}{cc}\hfill \mathrm{learning}& \mathrm{outcome}\to \hfill \\ \hfill & \mathrm{thinking}\to \left\{\begin{array}{c}\mathrm{new}\mathrm{or}\mathrm{revised}\mathrm{material},\hfill \\ \mathrm{new}\mathrm{or}\mathrm{revised}\mathrm{input}\mathrm{representation},\hfill \\ \mathrm{new}\mathrm{learning}\mathrm{method},\hfill \\ \mathrm{new}\mathrm{or}\mathrm{revised}\mathrm{organization}\mathrm{structure},\hfill \\ \mathrm{revised}\mathrm{retrieval}\mathrm{strategy}\hfill \end{array}\right.\hfill \\ \hfill & \to \mathrm{future}\mathrm{learning}.\hfill \end{array}$$

(8)

This feedback loop is the main connection between thinking-guided learning and the minimal-core principle. By reasoning about future unknown situations instead of predefining a large number of adaptation rules, the system can retain a smaller fixed core while still responding flexibly to learning failures and new requirements.

3.5. Learned Organization, Retrieval, and Recursive Reuse

Open learning does not produce only one model or one kind of knowledge. Over long-term operation, the system may accumulate heterogeneous learned contents, including task models, reusable skills, discovered input features, temporal patterns, learned methods, experience sequences, summaries, and relations among previously learned components. Therefore, merely storing learned contents in a fixed memory structure is insufficient. The structure used to organize these contents must itself be allowed to evolve.

Let

$${\mathcal{K}}_t=\{k_1,\dots ,k_{L_t}\}$$

denote the set of accumulated learned contents. At an early stage, when only a small number of elements have been learned, the system may use a simple unstructured collection. As ${\mathcal{K}}_t$ grows, however, different structural organizations may become advantageous. For example, a hierarchical organization may be suitable when learned contents naturally form general-to-specific relations, whereas a graph may be more appropriate when one learned component is related to multiple tasks, methods, contexts, or other contents. In other situations, maintaining part of the contents as a flat collection may remain preferable because imposing additional structure would introduce unnecessary cost.

The organization process is represented as

$${\mathcal{G}}_t={\mathcal{O}}_t\left({\mathcal{K}}_t\right),$$

(9)

where ${\mathcal{O}}_t$ is the current organization policy and ${\mathcal{G}}_t$ is the resulting structure. Importantly, ${\mathcal{O}}_t$ is not restricted to choosing among a permanently predefined flat, tree, or graph representation. It may retain an unstructured collection, construct a hierarchy, establish a graph, combine different structures into a hybrid organization, or introduce another organization scheme when it proves more useful.

Learning the organization therefore includes more than assigning contents to existing categories. The system may learn whether structure is needed, which contents should be grouped, which parent–child relations should be established, which cross-links should be added, and when previously formed groups should be split, merged, or reorganized. The organization structure is retained only when it improves subsequent learning, retrieval, decision making, or resource efficiency. Thus, the structure of learned contents becomes another object of learning rather than fixed infrastructure.

Retrieval is learned over the current organization. Given a current learning issue $q_t$, the system uses a retrieval policy

$$K_t^{*}=R_t(q_t,{\mathcal{G}}_t),$$

(10)

where $K_t^{*}$ is the retrieved subset of learned contents and $R_t$ is the current retrieval strategy. The retrieval strategy may exploit semantic similarity, hierarchical proximity, graph relations, causal relevance, temporal context, prior failures, task similarity, or learned combinations of these criteria. The usefulness of the retrieved contents is then evaluated through their downstream effect.

Organization and retrieval are therefore coupled but distinct. A poor retrieval result may indicate that the retrieval policy is inappropriate, that the underlying organization structure is unsuitable, or both. Direct reuse outcomes and thinking-guided analysis can be used to distinguish these cases and revise the corresponding component. For example, a tree may initially organize manipulation knowledge adequately, but later become insufficient when one skill is repeatedly shared by several task categories. The system may then convert the relevant local region into a graph while retaining other parts as a hierarchy, producing a hybrid structure rather than forcing all learned contents into one predefined representation.

This process also applies to learned methods themselves. Methods may initially be stored independently, but repeated use can reveal families of related methods, preferred methods for particular classes of problems, or useful multi-stage combinations. These relations can be incorporated into ${\mathcal{G}}_t$, allowing future learning to retrieve not only knowledge about a task but also previously successful ways of learning similar tasks.

The resulting system therefore learns at multiple levels: it learns task-related contents, learns how to acquire them, learns how to organize the heterogeneous results, and learns how to retrieve and reuse them. Previously learned contents can subsequently affect problem discovery, input construction, method selection, organization, retrieval, and further thinking. This creates a recursive learning process in which the results of earlier learning progressively reshape the conditions of later learning.

The proposed model therefore differs from a fixed learning pipeline in an essential way. Its long-term development is characterized by continual expansion of ${\mathcal{E}}_t$, where expansion may occur in the problem set, input representation, method set, learned contents, organization structure, or retrieval strategy. Such expansion can be produced either directly by experience-driven learning or by thinking-guided revision of the learning process. The minimal fixed core remains responsible only for keeping this expansion operational, evaluable, and bounded. This separation between a small invariant core and a continuously expandable, thinking-guided learning process constitutes the central mechanism of the proposed Minimal-Core Open Learning model.

4. Verification

4.1. Experimental Setup

The experiments are designed to verify whether the proposed Minimal-Core Open Learning (MCOL) framework can progressively move task-specific decisions from predefinition into learning. Seven controlled experiments are used because the main mechanisms address different questions: whether useful inputs can be discovered, whether a learning method can be changed, whether accumulated knowledge can be retrieved and reused, whether new learning problems can be discovered, whether thinking can revise an insufficient learning process, and whether the organization of learned contents can itself be learned. The experiments therefore isolate these mechanisms instead of changing all of them simultaneously.

All reported results use ten random seeds (20260927–20261006) and are reported as mean ± standard deviation unless otherwise stated. For Exp. 1–5, the main tabular training/validation/test sets contain 2600/700/1200 samples. The candidate tabular learners are Random Forest (RF; 400 trees, maximum depth 16), HistGradientBoosting (HGB; 260 boosting iterations), and a three-hidden-layer MLP (192–96–48 units, 40 epochs). Sequence tasks use a two-layer LSTM with 128 hidden units and 36 epochs. Exp. 6 uses experiment-specific data sizes described below because its purpose is to create four distinct learning failure states. Exp. 7 uses 480 stored knowledge items and 1100/450/800 train/validation/test queries. Each successfully completed seed–method run is saved independently, allowing interrupted experiments to resume without changing completed results.

Table 1 summarizes the role of each experiment. “Oracle” denotes an upper-bound method that is deliberately given information or search capability that a deployable agent would not normally have. “Fixed” methods retain the corresponding component as predefined, whereas “proposed” methods allow it to be learned or expanded.

4.2. Reducing Predefinition and Expanding the Learning Path

Experiment 1: learning with fewer predefined components.

The first experiment uses an 18-dimensional binary-classification problem. In the final stage, the label depends on nine useful inputs: four basic variables, one additional linear variable, two further linear variables, and two variables participating in nonlinear interaction and sinusoidal terms. The remaining inputs are distractors. This creates a setting in which a designer can obtain a strong solution by explicitly specifying the useful variables and model family, but an open learner must identify them from data.

The fixed-minimal baseline is given only the first four features and RF. The feature-learning baseline may discover additional useful inputs but still uses RF. The oracle receives the exact useful feature set and chooses among RF, HGB, and MLP. The proposed learner must discover useful features and select the learning method. The number of task-specific predefinitions counts the choices that must be supplied by the designer; consequently, the oracle has the most task-specific information, while the proposed method retains only the generic learning mechanism.

As shown in Table 2, the proposed method achieved $0.8234\pm 0.0161$ F1 using only 1 task-specific predefinition, compared with $0.8292\pm 0.0115$ F1 and 11 predefinitions for the oracle. Thus, reducing the task-specific definitions from 11 to 1 decreases F1 by only approximately 0.006. By contrast, the fixed-minimal system reaches only $0.6452\pm 0.0253$. The proposed learner recovers $0.9333\pm 0.0777$ of the useful features. Figure 1 therefore shows that most of the task-specific specification can be removed without a comparable performance loss.

Experiment 2: expanding inputs and learning methods.

The second experiment makes the expansion process explicit over time. At stage 0, the target depends on $x_0$–$x_3$. Stage 1 introduces $x_4$; stage 2 additionally introduces $x_5$ and $x_6$; and stage 3 adds nonlinear terms involving $x_7{x}_0$ and $sin\left(1.7x_8\right)$. Eighteen candidate variables are available in every stage, but only a changing subset is useful. The fixed pipeline continues to use its initial inputs, while feature-expanding methods can add variables that improve validation performance. When RF validation F1 falls below the method-utility threshold (0.79), method-expanding variants may select a stronger learner from the candidate set.

A separate temporal task tests whether “method expansion” means more than switching among tabular models. Each example is a 36-step, six-channel sequence. Its class is determined by the relative order of two strong events on channels 0 and 1. During training, the first event occurs mainly at positions 2–9 and the second at positions 24–32; validation/test move them to positions 10–16 and 18–24. Four nuisance bursts are also inserted on other channels. Both flattened HGB and LSTM receive the complete raw sequence, so the comparison is not caused by withholding information. Instead, flattened HGB can overfit absolute locations, whereas LSTM can learn the position-invariant order relation.

The proposed method recovers all required features on average ($1.0000\pm 0.0000$) and reaches $0.8055\pm 0.0193$ final-stage F1, compared with $0.6417\pm 0.0247$ for the fixed pipeline. On the temporal task, flattened HGB obtains $0.5319\pm 0.1951$ F1, whereas the acquired LSTM reaches $0.9550\pm 0.0224$, an average gain of $0.4231\pm 0.1976$ (Figure 2). These results distinguish two complementary forms of openness: acquiring missing inputs and acquiring a more appropriate learning method.

4.3. Learning Retrieval, Reuse, and New Learning Problems

Experiment 3: learning how to retrieve prior knowledge.

Exp. 3 creates a memory-reuse problem in which semantic similarity alone is insufficient. The memory contains 720 knowledge items. Every item has a 24-dimensional semantic embedding, one of six task identities, one of five failure/context modes, an age value, and a binary action label. A latent task–failure policy defines the correct binary action, while stored labels are intentionally noisy. Query embeddings mainly encode task/topic information and only weakly encode failure mode; they do not directly encode the correct action. Consequently, retrieving the nearest semantic neighbors can return items about the correct topic but with an inappropriate failure context or action.

For each of 360 test queries, the retriever returns the top seven items. An item is considered helpful only when its task and failure mode both match the query and its stored action agrees with the successful action for that query. We therefore report

$$\mathrm{Precision}@7={\displaystyle \frac{\mathrm{number}\mathrm{of}\mathrm{helpful}\mathrm{items}\mathrm{among}\mathrm{the}\mathrm{top}7}{7}},$$

and the helpful-hit rate, i.e., the fraction of queries whose top-7 set contains at least one helpful item. The retrieved items then vote for the downstream binary action; hence downstream F1 measures whether retrieval actually improves decision making rather than only a retrieval proxy.

Recent-only retrieval ranks by age, cosine retrieval uses semantic similarity, and task-filtered retrieval additionally favors the same task. The learned retriever is trained from previous successful outcomes using similarity, task-match, failure-match, their interactions, and recency. It reaches $0.7698\pm 0.0218$ Precision@7 and a helpful-hit rate of 1.0000. More importantly, downstream F1 rises to $0.9427\pm 0.0230$, compared with $0.6301\pm 0.0838$ for task filtering and $0.5689\pm 0.0855$ for semantic cosine. Thus, accumulated knowledge becomes useful only when the system also learns how to retrieve it under the current context.

Experiment 4: long-term reuse reduces repeated learning effort.

Exp. 4 uses a 24-episode stream in which the four classification stages from Exp. 2 recur according to a fixed mixed schedule. Each episode uses fresh samples, so the agent cannot memorize examples. The important recurrence is at the problem type level: when a previously encountered stage returns, its previously discovered features and selected learning method may be useful again. This setting tests whether learning in earlier episodes changes the cost of later learning.

The fixed system always uses its predefined RF. The partial-open baseline rediscovers features and searches RF/HGB again in every episode, even when an equivalent stage has already appeared. The proposed system also discovers features, but when a stage is encountered for the first time it searches RF/HGB/MLP and stores the selected method. On later occurrences of the same stage, that method is reused instead of being searched again. Candidate evaluation is counted as a nominal search-cost unit; it is used to compare repeated decision effort rather than wall-clock time.

The partial-open and proposed systems obtain almost identical mean F1 (0.7889 versus 0.7899) and final F1 (0.8074 versus 0.8073), showing that the main advantage is not artificially increased accuracy. Instead, cumulative candidate-evaluation cost falls from 72 to 56 (22.2%), method-reuse rate reaches 0.8333, and new method searches fall from 24 to 4. The result directly supports recursive reuse: previously learned method knowledge changes how a later learning episode is carried out.

Experiment 5: discovering what should be learned.

Exp. 5 tests a more basic form of openness: the learning targets themselves are not all fixed in advance. Each stage contains 12 input variables and six candidate binary output patterns. Pattern $p_0$ is predictable from $x_0$ and $x_1$ from the beginning. At stage 1, $p_1$ becomes predictable from $x_2$ and $x_3$. At stage 2, $p_2$ becomes predictable from a nonlinear combination of $x_4{x}_5$ and $sin\left(x_6\right)$. Patterns $p_3$–$p_5$ remain random noise throughout. Thus, the useful task set grows from one to two and finally three learnable relations.

The fixed-task method is told only about $p_0$ and never expands its task list. The oracle is given every currently useful target. The proposed discovery method evaluates all candidate targets with HGB and promotes a target only when held-out validation F1 reaches at least 0.68. This design tests whether the system can distinguish a newly learnable relation from noise rather than simply adding every possible target.

The proposed method achieves precision 1.0000, showing that noise targets are not promoted, while mean recall is $0.9333\pm 0.0574$ and final-stage recall is $0.8000\pm 0.1721$. The fixed task list has final recall only 0.3333 because it retains one of the three useful final-stage patterns. The proposed system discovers $2.4000\pm 0.5164$ useful patterns on average, demonstrating expansion of what is learned, rather than only parameter learning for a permanently fixed task list.

Table 3. Exp. 3–5: learned retrieval, long-term reuse, and problem discovery.

Exp.	Method	Primary F1	Retrieval/Pattern metric	Cost/Recall	Reuse/Search
3	Recent only	$0.4994\pm 0.2602$	Precision@7=0.0262	hit=0.1806	–
3	Semantic cosine	$0.5689\pm 0.0855$	Precision@7=0.0728	hit=0.4017	–
3	Task filter	$0.6301\pm 0.0838$	Precision@7=0.1680	hit=0.7150	–
3	Learned retrieval	$0.9427\pm 0.0230$	Precision@7=0.7698	hit=1.0000	–
4	Fixed system	mean=0.6819	final=0.6441	cost=24	reuse=0.0000
4	Partial open	mean=0.7889	final=0.8074	cost=72	searches=24
4	Proposed open	mean=0.7899	final=0.8073	cost=56	reuse=0.8333, searches=4
5	Fixed task list	F1=0.7420	precision=1.0000	final recall=0.3333	patterns=1.0000
5	Oracle task list	F1=0.7330	precision=1.0000	final recall=1.0000	patterns=3.0000
5	Proposed discovery	F1=0.7367	precision=1.0000	final recall=0.8000	patterns=2.4000

Table 3. Exp. 3–5: learned retrieval, long-term reuse, and problem discovery.

Exp.	Method	Primary F1	Retrieval/Pattern metric	Cost/Recall	Reuse/Search
3	Recent only	$0.4994\pm 0.2602$	Precision@7=0.0262	hit=0.1806	–
3	Semantic cosine	$0.5689\pm 0.0855$	Precision@7=0.0728	hit=0.4017	–
3	Task filter	$0.6301\pm 0.0838$	Precision@7=0.1680	hit=0.7150	–
3	Learned retrieval	$0.9427\pm 0.0230$	Precision@7=0.7698	hit=1.0000	–
4	Fixed system	mean=0.6819	final=0.6441	cost=24	reuse=0.0000
4	Partial open	mean=0.7889	final=0.8074	cost=72	searches=24
4	Proposed open	mean=0.7899	final=0.8073	cost=56	reuse=0.8333, searches=4
5	Fixed task list	F1=0.7420	precision=1.0000	final recall=0.3333	patterns=1.0000
5	Oracle task list	F1=0.7330	precision=1.0000	final recall=1.0000	patterns=3.0000
5	Proposed discovery	F1=0.7367	precision=1.0000	final recall=0.8000	patterns=2.4000

4.4. Thinking-Guided Learning

Exp. 6 tests whether learning outcomes can trigger reasoning about how the learning process itself should change. Four deliberately different states are constructed so that simply applying one universal repair cannot solve all of them.

Coverage insufficiency uses eight generated variables and a difficult region defined by $x_0>0.25$. The initial training set contains 1650 examples outside this region but only 70 examples inside it, whereas validation and test sets contain the natural distribution. The existing observed variables are sufficient; therefore the appropriate repair is to acquire targeted examples from the underrepresented region. Missing information instead uses a region in which the target depends strongly on an initially unavailable variable $x_6$. Collecting more examples with the same four observed variables cannot fully remove this ambiguity; testing and acquiring the candidate information source is the appropriate response.

Temporal mismatch uses 40-step, three-channel sequences. Training places the two class-defining events mainly at positions 3–11, whereas validation and test move them to positions 20–28. Their relative order remains the class signal, making a sequence learner more suitable than flattened HGB. Finally, the well-specified state uses a target fully determined by the four currently observed variables and provides sufficient training coverage. It is a negative control: a correct learning system should avoid unnecessary change.

Thinking is implemented with the DeepSeek online model deepseek-chat. The LLM receives observable diagnostics rather than the hidden scenario name. Thinking-direct immediately proposes one of five actions: add targeted material, acquire the candidate information source, switch to HGB, switch to LSTM, or take no action. Thinking-always-probe first tests diagnostic evidence when the current learner is inadequate. Thinking-ambiguity-probe additionally asks whether the current evidence is sufficient; low confidence or an explicit NEED_PROBE decision triggers at most two material, sensor, or method probes. A probe must show at least 0.02 validation improvement, and a full adaptation is retained only if it improves validation F1 by at least 0.015. The adequacy threshold is 0.90. Exhaustive adaptation evaluates the available candidate interventions and serves as an upper bound.

Diagnosis match is the fraction of the four states for which the effective accepted action equals the action selected by exhaustive validation. Regret is the difference between the final test F1 of exhaustive adaptation and that of the evaluated method. Decision cost counts diagnostic probes and adaptation candidate evaluations; it is not wall-clock time or FLOPs.

As reported in Table 4, no adaptation achieves $0.7555\pm 0.0415$ F1. Direct thinking increases this to $0.8531\pm 0.0326$ with a diagnosis-match rate of 0.7500. Adding diagnostic evidence raises final F1 to $0.9098\pm 0.0331$ and diagnosis match to $0.9750\pm 0.0791$. Its mean regret relative to exhaustive adaptation is only 0.0037, while exhaustive adaptation reaches $0.9135\pm 0.0309$. The ambiguity-probe method therefore improves direct thinking by 0.0567 F1 while using 7.1 candidate evaluations on average versus 12 for exhaustive adaptation, a 40.8% reduction in this nominal evaluation count.

The case-wise decisions explain the gain. The ambiguity-probe method matches the exhaustive action in 10/10 coverage-insufficiency cases, 10/10 missing-information cases, 9/10 temporal-mismatch cases, and 10/10 well-specified cases. In particular, the missing-information state cannot be reliably distinguished from insufficient data merely by collecting more of the same observations; diagnostic probing provides evidence that the new information source is useful. The results therefore support the intended role of thinking as a controller of learning revision rather than merely a direct task predictor.

Figure 3. Exp. 6 final F1. Diagnostic evidence closes most of the gap between direct thinking and exhaustive candidate evaluation.

Figure 3. Exp. 6 final F1. Diagnostic evidence closes most of the gap between direct thinking and exhaustive candidate evaluation.

4.5. Learning the Organization of Heterogeneous Contents

Exp. 7 asks whether a long-lived agent should be forced to store all learned contents in one predefined organization. The synthetic knowledge world contains 480 items represented by 24-dimensional embeddings. Items belong to six domains, each with four subgroups. In addition to semantic similarity, items have graph edges: local edges connect items within a subgroup, while 36 reusable-method links connect selected items across three different domains. This produces several simultaneously valid notions of relatedness.

Test queries are sampled from three types: 30% semantic, 35% hierarchical, and 35% cross-link. For a semantic query, the relevant set is defined by the 16 embedding-nearest items and may cross hierarchical boundaries. For a hierarchical query, relevant items share the anchor’s domain and subgroup. For a cross-link query, relevant items share a cross-domain reusable-method tag. Thus no single structure is optimal for every query type.

The flat organization searches all stored items by semantic similarity. The tree first restricts candidates to the same subgroup (or domain when needed). The graph searches direct and second-hop graph neighbors before falling back to other items. All methods return the top seven items. Precision@7 is therefore the fraction of these seven that belong to the query-specific relevant set. To balance retrieval quality and search scope, organization utility is defined as

$$U=\mathrm{Precision}@7-0.00015N_{\mathrm{cand}},$$

where $N_{\mathrm{cand}}$ is the number of candidates examined.

The learned organization policy is an HGB classifier trained from observable meta-features such as similarity concentration, domain/subgroup concentration, graph degree, and the fraction of graph neighbors among semantically close items. It selects flat, tree, or graph for each query. The oracle evaluates all three structures and selects the one with the largest utility. Structure-selection accuracy measures how often the learned selection equals this oracle choice.

Table 5 shows that no fixed organization dominates: flat/tree/graph utilities are $0.4633\pm 0.0204$, $0.3731\pm 0.0184$, and $0.4164\pm 0.0161$, respectively. Learned organization raises utility to $0.6590\pm 0.0171$ and Precision@7 to $0.6820\pm 0.0174$, approaching the oracle utility of $0.6887\pm 0.0166$. Its structure-selection accuracy reaches $0.7645\pm 0.0139$. These results show why organization should belong to the expandable part of MCOL: future queries may require semantic, hierarchical, or cross-domain reuse, and the appropriate organization can itself be learned.

Figure 4. Exp. 7 organization utility. The learned policy selects among flat, tree, and graph structures according to the query and approaches the per-query oracle.

Figure 4. Exp. 7 organization utility. The learned policy selects among flat, tree, and graph structures according to the query and approaches the per-query oracle.

4.6. Summary of Findings

Taken together, the experiments support the model at three levels. First, Exp. 1–2 show that task-specific inputs and learning methods need not remain permanently predefined: useful variables can be acquired as the environment changes, and a sequence learner can be adopted when a tabular method no longer matches the problem structure. Second, Exp. 3–5 show that expansion continues after individual models have been learned: the agent can learn how to retrieve previous knowledge, reuse earlier method choices to reduce repeated search, and discover new learnable input–output relations that were not in the initial task list. Third, Exp. 6–7 show that higher-level parts of the learning system can also adapt: thinking can acquire diagnostic evidence and revise an insufficient learning process, while the organization used to store and reuse heterogeneous learned contents can itself be selected from experience.

These results support the central MCOL hypothesis that a small fixed core can coexist with a learning system whose problems, inputs, methods, retrieval, reuse, and organization progressively expand. Equally importantly, the experiments separate performance improvement from unnecessary expansion: well-specified learning in Exp. 6 is left unchanged, noise patterns in Exp. 5 are not promoted, and learned structures in Exp. 7 are evaluated against both retrieval quality and candidate-search scope.

5. Conclusion

This paper presented Minimal-Core Open Learning (MCOL), a framework for autonomous agents that minimizes permanently predefined task-specific structure while allowing the learning system itself to expand over time. MCOL separates a small generic fixed core from an expandable learned component and enables the agent to progressively discover what should be learned, extend useful inputs, acquire or switch learning methods, retrieve and reuse prior knowledge, and reorganize heterogeneous learned contents. Thinking-Guided Learning further allows learning outcomes to trigger diagnostic reasoning and validated revision of the learning process itself.

Experiments across seven aspects of the framework showed that the proposed approach can substantially reduce task-specific predefinition while maintaining strong performance, improve learning through input and method expansion, increase the effectiveness of knowledge reuse and retrieval, discover new learning problems, and approach exhaustive adaptation with fewer candidate evaluations. These results support the central hypothesis that long-term autonomous learning can be built around a small stable core while progressively moving more system structure into validated learned components. Future work will investigate longer-term real-world deployment, richer physical-agent settings, and further reduction of the remaining predefined elements.