A Compositional Framework for Open-ended Intelligence
Abstract: Open-ended intelligence is the capacity to adapt to novel problems and environments that are substantially different from those in training. A mathematics of open-ended intelligence requires two pillars: first, a minimal set of representational primitives (e.g., states, actions) and algorithmic primitives (e.g., nearest neighbor); and second, an acquired compositional grammar for selection, recursion, and branching that produces sequences of operations and recurring motifs. We formalize open-ended intelligence in terms of the compositional closure induced by a finite primitive set $P$ and a set of composition operators $C$. We characterize properties of the induced closure $\mathcal{L}(P,C)$ that support unbounded compositional generation across families of tasks and worlds. The closure of the two pillars yields infinite adaptive responses across a wide range of settings. The mathematics supports complementary research agendas, including evaluation metrics for explanation and interpretability, and novel architectures where compositional generalization is native. We propose next primitive prediction (NPP) as a novel architectural objective, where training encourages the acquisition of reusable algorithmic primitives and their compositional grammar, such that new solutions are generated through recombination. Given such an objective, curriculum learning and self-play can enable lifelong learning, expanding the closure by discovering reusable primitives and transition motifs across settings. We ground the framework through case studies in physics, evolution, and neuroscience.
Summary
- The paper introduces a formal framework for open-ended intelligence by formalizing minimal primitives and compositional operators to generate an infinite, reusable solution space.
- It pioneers the Next Primitive Prediction (NPP) approach, shifting from token-based prediction to compositional reuse and parsimony, enhancing transferability across tasks.
- The work establishes rigorous evaluation metrics, such as the Primitive Reuse Index and Compositional Depth Generalization, to measure systematic generalization in AI systems.
Compositional Foundations for Open-Ended Intelligence
Introduction and Motivation
The paper "A Compositional Framework for Open-ended Intelligence" (2606.15386) formulates a rigorous mathematical and computational approach to open-ended intelligence (OEI) with an explicit focus on compositionality. Unlike prevailing frameworks that emphasize task-centric skill accumulation, behavioral repertoires, or episodic stepping stones, this work focuses on the hierarchical induction and recombination of a minimal set of primitives and compositional operators, formalized as grammar and closure properties. By drawing from mathematical logic, neuroscience, and algorithmic learning, it provides conceptual and architectural foundations for agents that can continually generate diverse solutions across unbounded families of tasks and worlds.
Limitations of Existing Frameworks
Traditional OEI systems, including Novelty Search, Quality Diversity (QD), POET, and XLand, either seek behavioral novelty or optimize skill collections without explicit representational or algorithmic primitive inventories. While these approaches achieve task distributional generalization, their compositional transfer is limited; agents rarely decompose skills into reusable, minimal computational primitives. In frameworks relying on skill or code fragment libraries (e.g., LLM-based program synthesis), recombination occurs, but typically without parsimony pressure or constraints that would guarantee role-flexible transfer across world families. Methods from object-centric learning, options frameworks in HRL, or program synthesis (e.g., DreamCoder) provide partial support but lack formal closure under composition and do not directly support recombinatorial generalization.
The Compositional Framework
The paper proposes that open-ended intelligence is characterized by the acquisition and compositional generalization of a minimal generating set of primitives and composition operators . Endowing agents with the capacity for unbounded exploration and solution production requires the closure induced by and to be infinite and parsimony-optimized. The work formally defines:
- Representational primitives: Ontological building blocks (objects, attributes, fields).
- Algorithmic primitives: Minimal computational operations (comparison, retrieval, recursion, branching).
- Compositional motifs and grammar: Transition motifs (sequences, recurrences, branching) encoded as primitive transition graphs.
- Compositional closure: The set of all computations and solutions reachable by repeated composition.
A crucial assertion is that the locus of open-endedness is not behavior or outcome space, but the compositional structure and its induced closure.
Figure 1: Architecture of compositional open-ended intelligence—primitives and operators form the basis for a compositional grammar with unbounded closure across possible worlds.
Theoretical Properties and Mathematical Structure
The framework defines an open-ended agent as a tuple , where is the closure over compositions. A key proposition establishes that if contains at least one generative or recursive operator and compositions are type-consistent and allow for intermediate reuse, supports unbounded solution generation—even with finite and 0.
The parsimony constraint is central: a minimum description length (MDL)-like pressure prevents library bloat and overfitting to episodic, non-transferable solutions. Motifs—recurring subgraph patterns in primitive transition graphs—are identified via extraction and subgraph mining, further compressed into higher-level primitives, establishing a hierarchy.
Implications for Architecture: Next Primitive Prediction
Fundamentally, the authors propose a paradigm shift in architectural objectives, from next-token/state/latent prediction to Next Primitive Prediction (NPP). In this scheme, the agent predicts the next primitive-operator pair in its primitive transition graph, conditioned on world context. Unlike standard models that prioritize sequence prediction or behavioral imitation, NPP architectures (e.g., transformer-based graph neural networks) are trained for compositional reuse, parsimony, and transfer-as-recomposition, rather than sheer predictive accuracy.
Optimization of the NPP objective—augmented with contrastive or parsimony-regularized loss—promotes reuse and avoids the proliferation of brittle, task-specific black-box routines. As a result, the model induces a compact, stable inventory of primitives and composition rules that remain robust across families of worlds. This architectural focus is distinct from, and claimed to be more favorable than, current JEPA and library learning paradigms in systematic transfer and interpretability.
Systematic Generalization and Evaluation
Open-endedness, in this framework, is operationalized in terms of a primitive and compositional grammar that persists across possible worlds (in the philosophical sense: counterfactuals, world variants, task families). Core evaluation measures include:
- Primitive Reuse Index: Quantifies generality of primitives across tasks.
- Compositional Depth Generalization: Success on graphs deeper than those seen during training.
- Primitive Discovery Yield: Rate at which new primitives improve sample efficiency.
- Transfer-as-Recomposition: Assesses zero-shot re-binding of motifs in new worlds.
Such metrics advance evaluation beyond behavioral success and toward intrinsic mechanistic generalization.
Connections to Neuroscience, Evolution, and Collective Intelligence
The framework is biologically grounded. Case studies in computational neuroscience demonstrate that flexible generalization in PFC and hippocampal systems arises from high-dimensional, mixed-selectivity codes, parallelism, and rapid construction of compositional geometries (e.g., orthogonal coding directions supporting context transfer). Meanwhile, evolutionary biology is presented as a natural realization of open-ended compositional closure (e.g., Hox gene toolkits, V(D)J recombination in immune diversity). The authors also articulate how collective intelligence emerges via exchange and recombination of partial solutions at multiple scales—analogous to motif propagation across multi-agent systems.
Distinctions from Prior Work
The approach diverges from options in HRL (which are environment-bound and not minimal), from program synthesis (which often optimizes compression, not transfer), and from multi-task neural systems (which may discover modules but lack explicit compositional pressure or transition graphs). Notably, claims are made that prior approaches neither formalize compositional closure nor directly induce parsimony or compute transfer metrics relevant at the primitive/motif layer.
Open Challenges and Future Directions
An explicit agenda for future work is outlined:
- Architectural realization: Implementation and empirical testing of NPP at scale, and comparisons against next-latent or joint embedding-predictive backbones.
- Metrics: Development and community adoption of compositionality-based evaluation measures.
- Multi-agent/Collective extensions: Enabling communication, interpolation, and translation of partial solutions across heterogeneous agents.
- Curriculum: Self-play and autocurricula that stress compositional expansion and parsimony.
- Empirical neuroscience/ML bridging: Application of mechanistic neural metrics (parallelism, motif recurrence) for introspection and interpretability of artificial systems.
Conclusion
By shifting the focus of open-ended intelligence from surface behavior to formal compositional structure, the framework in this paper establishes rigorously defined targets for both theoretical inquiry and the engineering of generative AI. The explicit foregrounding of primitives, composition rules, and closure, under parsimony constraints and equipped with transfer-driven objectives, offers a unifying language for interpretability, systematic generalization, and the design of future architectures in both artificial and collective systems. This compositional approach delivers a mechanistically explicit alternative to behavioral and reward-centric paradigms, grounding open-ended intelligence in the mathematics of combinatorial closure and reuse.
Paper Prompts
Sign up for free to create and run prompts on this paper using GPT-5.
Top Community Prompts
Explain it Like I'm 14
Overview: What this paper is about
This paper is about teaching AI to be truly flexible and creative. The authors want AIs that can solve brand-new kinds of problems they’ve never seen before, not just variations of the same task. Their big idea is to give AI a small set of basic building blocks (called “primitives”) and clear rules for combining them (a “grammar”), so the AI can build endless new solutions by mixing and matching these parts—like making many different creations from the same set of LEGO bricks.
Goals and questions in simple terms
The paper asks:
- What are the smallest, most reusable pieces an intelligent system should learn?
- What simple rules for combining those pieces let it solve lots of different kinds of problems?
- How can we train AI to learn these pieces and rules—and to keep reusing them in new situations?
- How do we measure whether the AI is truly recombining what it knows, instead of just memorizing?
Approach and key ideas (with everyday analogies)
Think of three ingredients for intelligence:
- A small toolbox of “primitives”
- Representational primitives: the basic ways an AI describes the world (like “objects,” “locations,” or “relations”).
- Algorithmic primitives: the basic actions in thinking or problem-solving (like “compare two things,” “look up a memory,” “measure a distance,” or “check if something worked”).
- Composition rules (a “grammar” for thinking)
- Just like grammar lets you combine words into sentences, composition rules let the AI combine primitives into bigger plans. Common patterns include:
- Sequencing: do A, then B, then C.
- Branching: if X is true, do A; otherwise do B.
- Recursion/loops: repeat a step inside itself (like dividing a problem into smaller copies of itself).
- Closure: everything you can build
- “Closure” means the complete set of solutions you can make using your toolbox and your rules. A key idea here is that even a small toolbox plus smart rules (especially ones that allow reuse/recursion) can create an unlimited variety of solutions—just like a few LEGO pieces can build countless models.
How the paper formalizes this:
- They write this as a pair (P, C), where P is the set of primitives, C is the set of composition rules.
- The closure L(P, C) is “all the solutions you can build by combining the pieces using the rules.”
- If the rules include ways to reuse results and repeat steps (like recursion), the number of possible solutions can be unbounded (basically unlimited).
Keeping the toolbox small (parsimony):
- The goal is not to collect hundreds of one-off tricks, but to learn a small, powerful set of primitives that can be reused everywhere.
- This is like a chef who prefers a few versatile techniques that work in many recipes instead of memorizing thousands of separate recipes.
Representing solutions as a “Primitive Transition Graph”:
- Imagine drawing a map of the thinking steps (nodes are primitives, arrows show how you move from one step to the next). This map captures repeatable “motifs” (common mini-patterns), like “Measure → Check → Branch,” which can be reused across tasks and even across different worlds.
Training idea: Next Primitive Prediction (NPP)
- Instead of training a model to predict the next word (as in chatbots), they propose training it to predict the next thinking step: which primitive to use next, and how to combine it.
- This encourages learning the grammar of problem-solving, not just memorizing answers.
- They suggest adding a “keep it simple” pressure so the model prefers recombining known primitives over inventing new, complicated shortcuts.
Learning across “possible worlds”
- “Possible worlds” are like different versions of a game with slightly different rules (changed physics, new goals, swapped roles for objects).
- The test of real understanding is whether your primitives and motifs still work after the rules change. If they do, they’re truly general.
- The AI can practice by generating its own worlds (self-play/curriculum), then seeing which primitives and motifs survive across variations.
How to check progress
- They suggest evaluation metrics that focus on reuse: for example, how often a learned primitive shows up across different task families. High reuse means the system is learning real building blocks, not just one-off tricks.
Main findings and why they matter
- A small set of reusable thinking steps plus a few combination rules can, in principle, generate endlessly many useful solutions. This is the core “closure” result: with even one rule that allows repeating or reusing steps, the space of possible solutions can be unbounded.
- Redefining “stepping stones”: Instead of collecting isolated skills, the paper treats stepping stones as reusable primitives and motifs inside a graph of thinking steps. This makes reuse systematic and compositional, not just episodic.
- A training objective (Next Primitive Prediction) can push models to learn a compact, flexible “basis” of thinking steps and a grammar for combining them—leading to better transfer across very different tasks and worlds.
- The framework ties together ideas from machine learning, evolution, physics, and neuroscience, where real systems seem to rely on reusable parts and recombination.
Why this matters:
- It aims to move beyond “good at one game” toward “good at many different kinds of problems.”
- It makes generalization a built-in feature: the AI learns to recombine what it knows rather than start over each time.
- It opens the door to clearer interpretability, since solutions are graphs of understandable steps, not just black-box behaviors.
Implications and potential impact
- For AI design: Models could be built to natively learn and reuse primitives, making them more sample-efficient and better at handling surprises.
- For education/curricula: Self-play and curriculum learning can focus on discovering new primitives and motifs, not just harder tasks.
- For safety and interpretability: If solutions are composed of named, testable steps, it’s easier to inspect, debug, and control AI behavior.
- For teamwork and sharing: Different agents could exchange portable primitives and motifs, speeding up collective problem-solving.
- For science and engineering: A principled “grammar of computation” could help automate discovery of algorithms and strategies that work across many domains.
In short, the paper argues that open-ended intelligence comes from learning a small, reusable toolbox and a grammar for combining its tools. With that, an AI can keep inventing new solutions across endlessly varied worlds—much like a skilled builder who can make anything from the same set of blocks.
Knowledge Gaps
Knowledge gaps, limitations, and open questions
Below is a single, concrete list of what the paper leaves missing, uncertain, or unexplored, phrased to guide actionable future research.
- Formal primitive extraction: Specify an algorithm to extract a discrete, stable inventory of representational and algorithmic primitives from model weights/activations, with robustness across random seeds, training runs, and domains.
- Primitive identifiability and stability: Demonstrate that discovered primitives are identifiable (up to permutation/rotation) and remain consistent under fine-tuning, scaling, and domain shift.
- Operator semantics and typing: Define a rigorous type system and operator semantics for composition (sequencing, branching, recursion), including constraints that guarantee well-typed compositions and safe reuse across tasks.
- Minimal generating set algorithm: Provide an algorithmic procedure (and complexity analysis) to approximate the minimal generating set under an MDL or related criterion, including when multiple minimal sets exist.
- MDL/parsimony objective formalization: Specify a concrete loss/objective that operationalizes minimum description length for NPP, along with tractable estimators, regularizers, and training schedules.
- When to add a new primitive: Define criteria, statistical tests, or triggers that decide when a new primitive should be added versus when an existing composition suffices, including ablation-based evidence thresholds.
- Motif discovery at scale: Detail subgraph-mining algorithms for discovering reusable transition motifs in PTGs, including pruning heuristics, statistical significance testing, and handling combinatorial explosion.
- Linking continuous latents to symbolic PTGs: Provide a mapping between continuous latent operations (e.g., vector directions) and discrete PTG nodes/edges, including a training signal that aligns both representations.
- Operator learning vs. specification: Clarify whether composition operators are hand-specified or learned; if learned, give architectures and training regimes to induce operator sets with desirable closure properties.
- Proofs beyond unboundedness: Extend the theoretical analysis to necessary and sufficient conditions for useful (non-trivial) infinite closures, including guarantees of compositional expressivity, compactness, and generalization.
- Tractability of search in L(P, C): Propose search/planning algorithms over the closure that are computationally tractable (anytime, approximate), with bounds on search cost and solution quality.
- Data and supervision for NPP: Describe how training traces for NPP are obtained/annotated in practice (self-supervised extraction, synthetic generators, or human labeling), and how bootstrapping proceeds from cold start.
- World vector W specification: Define how to construct/learn the “world vector” W, its ontology (physics, reward structure, roles), and how to validate that W captures the invariants needed for transfer-as-recomposition.
- Possible-world neighborhoods: Provide a concrete method to generate controlled counterfactual “nearby worlds,” including protocols for varying dynamics, rewards, and role bindings with measurable distances between worlds.
- Evaluation metrics formalization: Fully define and operationalize proposed metrics (e.g., Primitive Reuse Index, compositional dependency graphs, TaR scores), including estimators, confidence intervals, and public evaluation code.
- Benchmarks and testbeds: Introduce standardized, multi-family benchmarks for compositional transfer (e.g., controlled ARC-style tasks, voxel/control suites with systematic counterfactuals) to evaluate NPP and PTG formation.
- Empirical validation of NPP: Run comparative studies versus next-token, next-state, and JEPA-style objectives on matched compute, reporting sample efficiency, generalization across families, and training cost.
- Library growth and memory control: Develop mechanisms to manage library size (merging, de-duplication, versioning), prevent library bloat, and handle catastrophic forgetting while preserving reusable primitives.
- Detecting and avoiding degenerate closures: Identify pathologies (e.g., trivial recursion, noisy-TV-like primitives) and design safeguards (verification, regularization, epiplexity-like filters) to keep the closure functional.
- Verification primitives in practice: Specify implementations of verification/critique/proof primitives, their interfaces, and how they gate inclusion of new motifs/primitives into the reusable library.
- Integration with RL/control: Clarify how internal primitive composition interacts with external action selection in POMDPs, including planning horizons, partial observability, and continuous control.
- Continuous-to-symbolic generalization: Show how the framework handles continuous domains (robotics, control) with noisy sensors/actuators, including uncertainty-aware primitives and robust verification under stochasticity.
- Multi-agent sharing protocols: Define interfaces, schemas, and negotiation protocols for exchanging primitives/motifs across heterogeneous agents, including functional role descriptions and interoperability guarantees.
- Human interpretability: Provide methods to render learned primitives/motifs legible to humans (naming, documentation, I/O signatures), and user studies or expert audits validating interpretability claims.
- Safety and alignment in self-play: Analyze failure modes of autonomous world generation (specification gaming, harmful curricula) and propose constraints or oversight mechanisms compatible with parsimony-driven expansion.
- Trade-off: parsimony vs. exploration: Develop adaptive schedules or objectives that balance conservative reuse (parsimony) with discovery of genuinely novel primitives, avoiding premature convergence.
- Uniqueness and equivalence classes: Characterize equivalence classes of primitive libraries (non-uniqueness of minimal bases), and propose canonicalization procedures or metrics for library comparison.
- Learning operators across modalities: Demonstrate binding between representational primitives (objects, relations) and algorithmic primitives (compare, retrieve) across modalities (text, vision, control) with shared operators.
- PTG-to-code and back: Specify compilation/decompilation between PTGs and executable code/ASTs, ensuring type-safety, testability, and performance parity across representations.
- Scalability analysis: Quantify compute, memory, and wall-clock requirements of NPP and motif mining at scale; compare to standard pretraining on similar hardware budgets.
- Case studies and real evidence: Provide concrete case studies (physics, evolution, neuroscience) with datasets, methods, and results that substantiate claims about compositional geometry and primitive reuse.
- Reproducibility package: Release reference implementations, diagnostics for primitive discovery, PTG visualizers, and example curricula to enable independent verification and extension of the framework.
Practical Applications
Overview
Based on the paper’s framework of primitives, composition operators, and the induced closure, along with the Next Primitive Prediction (NPP) objective, below are concrete applications that translate the findings into practice. Each item names likely sectors, outlines potential tools/products/workflows, and lists assumptions or dependencies that affect feasibility.
Immediate Applications
These can be piloted or deployed now using existing methods (e.g., trace logging, process mining, activation steering, code analysis, and current LLM/agent infrastructure), with moderate engineering effort.
- Software/ML Engineering — Compositional evaluation suites for models
- What: Adopt Primitive Reuse Index (PRI) and compositional transfer tests to benchmark LLMs and agents on primitive reuse and recomposition across task families.
- Tools/Products/Workflows: Evaluation harnesses that extract step traces; PTG builders from chain-of-thought/tool-use logs; dashboards tracking PRI and cross-world generalization.
- Assumptions/Dependencies: Ability to infer/label primitives from reasoning traces or tool usage; logging support; basic subgraph mining libraries for motif detection.
- Model Interpretability & Steering — Activation/Function vector control at the primitive level
- What: Use vector-based steering to induce/suppress algorithmic primitives (e.g., verify, compare, retrieve) and to bias transition motifs during inference.
- Tools/Products/Workflows: Activation steering toolkits; primitive probes; safety filters tied to “verification-first” motifs.
- Assumptions/Dependencies: Access to model activations or LoRA adapters; validated mappings from directions to primitives; monitoring to avoid distributional drift.
- AI Agents/Tool Orchestration — “Next tool” composer with parsimony
- What: Replace ad-hoc tool selection with an NPP-style component that predicts the next tool (primitive) and operator (e.g., sequence/branch), preferring reuse over bespoke actions.
- Tools/Products/Workflows: Agent runtimes (e.g., LangGraph-like) instrumented to log tool invocations as PTG edges; composer modules trained on tool traces; minimal-basis penalties.
- Assumptions/Dependencies: Sufficient historical traces of successful tool sequences; typed tool interfaces; willingness to tune a small composer model.
- Code Intelligence — Motif mining and refactoring assistants
- What: Mine recurring “algorithmic phrases” in code to recommend reusable functions, verify-before-act patterns, and composable APIs.
- Tools/Products/Workflows: AST/subgraph miners; IDE plugins that auto-suggest function extraction and test scaffolds aligned to motifs; CI rules enforcing motif reuse.
- Assumptions/Dependencies: Large codebases with version history; acceptance of coding standards; integration into CI/CD.
- Robotics (R&D and advanced prototyping) — Transfer-as-Recomposition in simulation
- What: Decompose skill libraries into primitives/motifs and re-bind them across environmental variations (e.g., move_to → swim_to) in sim before sim2real transfer.
- Tools/Products/Workflows: Option/eigenoption discovery for candidate primitives; PTG logging in RL pipelines; domain randomization aligned to “world vectors.”
- Assumptions/Dependencies: High-fidelity simulators; robust subgoal/option discovery; instrumentation for step-wise execution traces.
- Game AI & PCG — Motif-aware content and policy generation
- What: Design agents and generators that reuse verified motifs (e.g., search → interact → verify) across levels/games; score systems by PRI instead of only win rate.
- Tools/Products/Workflows: PCG with motif libraries; agents that learn NPP over task families; compositional generalization leaderboards.
- Assumptions/Dependencies: Level/task families with controllable variations; traceable agent policies; evaluation infrastructure.
- Enterprise Automation & Process Mining — Compositional workflow templates
- What: Convert business event logs into primitives (e.g., verify, approve, execute) and motifs to produce reusable workflow templates across teams.
- Tools/Products/Workflows: Process mining tools extended to extract PTGs; RPA/IPA bots configured with motif-first orchestration; compliance dashboards tracking motif adherence.
- Assumptions/Dependencies: High-quality event logs; mapping between steps and primitive ontology; organizational buy-in for standard motifs.
- Education/EdTech — Teaching and grading for decomposition and reuse
- What: Educators and tutors evaluate students on primitive reuse and compositional transfer; step-by-step solvers teach “verify → act → verify” scaffolds.
- Tools/Products/Workflows: Step-logging in coding/math platforms; rubrics scoring primitive reuse and transfer; curriculum built around minimal basis of problem-solving steps.
- Assumptions/Dependencies: Structured step traces; teacher and platform support for new rubrics; alignment with assessment standards.
- AI Safety & Governance — Compositional audits and model cards
- What: Add compositional generalization metrics (PRI, motif stability across worlds) to model audits and model cards for high-stakes deployments.
- Tools/Products/Workflows: Audit protocols that probe counterfactual task families; red-teaming with “world vector” perturbations; documentation of primitive libraries and verification motifs.
- Assumptions/Dependencies: Consensus on metrics; regulatory acceptance; access to eval-time traces and ablation.
- Data/ML Pipelines — Primitive-first AutoML and DAG reuse
- What: Define a small set of primitive transforms (clean, join, validate, impute) and mine motifs for robust, reusable data workflows across projects.
- Tools/Products/Workflows: Pipeline builders that enforce verification motifs; PTG visualization for DAGs; “next-primitive” advisors in orchestration UIs.
- Assumptions/Dependencies: Typed pipeline components; traceability of step-level outcomes; culture of modular reuse.
- Knowledge Management & Personal Automation — No-code primitive libraries
- What: Package reusable automation primitives (parse, lookup, check, notify) and recommend motif-based flows to users in no-code tools.
- Tools/Products/Workflows: Templates with verify-before-act motifs; “next step” recommenders; motif-level analytics on automation success.
- Assumptions/Dependencies: Clear tool schemas; user consent for telemetry; sufficient historical flows to learn motifs.
Long-Term Applications
These require further research, scaling, or ecosystem development (e.g., robust primitive discovery in latent space, standardized primitive ontologies, NPP architectures at scale, verified compositional reasoning).
- General-Purpose Compositional Agents — NPP-native architectures
- What: Agents trained end-to-end on NPP with MDL/contrastive parsimony to acquire minimal primitive libraries and grammars that transfer across domains.
- Tools/Products/Workflows: Transformer–GNN composers; large-scale self-play in “imagined worlds”; orchestration of “world vectors” for curriculum generation.
- Assumptions/Dependencies: Stable primitive discovery from activations; scalable PTG mining; large compute and standardized training corpora.
- Lifelong Learning Robots — Re-binding primitives in the real world
- What: Home/industrial robots that adapt skills across dynamics changes by re-binding primitives and motifs instead of re-learning from scratch.
- Tools/Products/Workflows: On-device NPP inference; formal typing of sensors/actuators as primitive I/O; verification primitives for safety.
- Assumptions/Dependencies: Reliable sim2real; real-time verification; robust failure detection and safe fallback behaviors.
- Collective Open-Ended Intelligence — Marketplaces for primitives and motifs
- What: Shared repositories of portable primitives/motifs across organizations, enabling interoperability and cumulative innovation.
- Tools/Products/Workflows: Primitive Definition Language (PDL) and typing standards; discovery/indexing platforms; provenance and licensing systems.
- Assumptions/Dependencies: Community standards and governance; IP frameworks; compatibility layers between heterogeneous agents.
- Verified Compositional Reasoning — Built-in verification primitives
- What: Agents that prove/critique steps as part of their primitive library, yielding inspectable, auditable solutions with formal guarantees when possible.
- Tools/Products/Workflows: Integration with proof assistants and SMT solvers; compositional certificates; regulatory-grade audit trails.
- Assumptions/Dependencies: Scalable, practical verification for everyday tasks; human-in-the-loop adjudication; regulator acceptance.
- Science & Algorithm Discovery — Parsimonious algorithmic grammars
- What: Systems that discover general algorithms (e.g., partitioning, dynamic programming motifs) via PTG search under MDL constraints, robust across input regimes.
- Tools/Products/Workflows: Self-play over program/experiment spaces; evaluation in controlled “possible world” families; motif wrapping into higher-order primitives.
- Assumptions/Dependencies: Benchmarks that stress compositional transfer; safeguards against overfitting to world generators; reproducibility infrastructure.
- Healthcare Decision Support — Modular, compositional clinical pathways
- What: Clinical agents that assemble care pathways from verified primitives (triage, test, threshold-check, treat), adapting across settings while preserving safety.
- Tools/Products/Workflows: Clinical PTGs aligned to guidelines; world vectors encoding institutional policies; embedded verification (e.g., dose checks).
- Assumptions/Dependencies: High-quality data and guidelines codified as primitives; rigorous validation; regulatory approval and liability frameworks.
- Finance/Compliance — Compositional explainability mandates
- What: Models and processes must expose primitive-level reasoning and verification motifs for high-risk decisions (credit, trading, AML).
- Tools/Products/Workflows: PTG exports for audits; counterfactual stress tests (world vectors for regimes); compositional risk dashboards.
- Assumptions/Dependencies: Standardized reporting; regulator–industry consensus; model architectures that support trace extraction.
- Education Systems — Assessment of compositional generalization
- What: Standardized tests and digital curricula that measure and foster primitive reuse, branching, and transfer-as-recomposition across problem families.
- Tools/Products/Workflows: Item banks organized by primitives/motifs; analytics on PRI at class and student level; teacher PD on compositional scaffolding.
- Assumptions/Dependencies: Psychometric validation; integration into learning standards; teacher training and tooling.
- Industrial Automation & Industry 4.0 — Motif-portable control recipes
- What: Factory controllers encode verify-balance-redispatch motifs as portable primitives, enabling rapid reconfiguration across lines and plants.
- Tools/Products/Workflows: Typed interfaces for sensors/actuators; PTG-based control policies; changeover assistants grounded in motif reuse.
- Assumptions/Dependencies: Standard device schemas; safety certifications; robust real-time verification primitives.
- Energy/Utilities — Compositional grid operations
- What: Grid management agents that reuse motifs (forecast → verify → redispatch → verify) across contingencies and seasons, improving resilience.
- Tools/Products/Workflows: World vectors for demand/weather regimes; NPP-based dispatch assistants; explainable incident reports via PTGs.
- Assumptions/Dependencies: High-fidelity simulations; regulatory acceptance; integration with SCADA/EMS.
- Advanced Agent Safety — Self-improvement via controlled counterfactuals
- What: Autocurricula based on “imagined worlds” to expand closure without proliferating brittle fragments; safety by enforcing parsimony and verification.
- Tools/Products/Workflows: Curriculum generators parameterized by world vectors; automatic rejection of non-reusable fragments; continuous motif validation.
- Assumptions/Dependencies: Reliable interestingness signals tied to closure expansion; monitoring to prevent reward hacking; governance for self-play loops.
Notes on Cross-Cutting Assumptions and Dependencies
- Primitive discovery and labeling: Feasibility depends on reliably extracting/inducing primitives from model activations, code, or behavior traces; the paper cites emerging evidence but robust toolchains are still maturing.
- Typing and interfaces: Many applications presuppose typed inputs/outputs for primitives and operators to ensure safe composition and reuse.
- Traceability: PTG construction requires step-level logs (reasoning tokens, tool calls, program traces, control steps) and permissions to collect them.
- Standards and governance: Broad impact (policy, marketplaces, audits) requires consensus on primitive ontologies, metrics (PRI, motif stability), and reporting formats.
- Compute and data: NPP-style training, self-play in imagined worlds, and motif mining at scale rely on significant compute resources and carefully designed task families.
- Verification: Integrating verification primitives is critical for safety-critical domains; scalable verification remains an active research and engineering challenge.
Glossary
- Abstract Syntax Trees (ASTs): Tree-structured representations of program syntax that make the compositional structure of code explicit for analysis or execution. "These compositions can be inspected as graphs or Abstract Syntax Trees (ASTs)"
- Algorithmic primitive: A minimal computational operation (e.g., comparison, retrieval) that can be composed with others to form solutions. "Algorithmic primitive refers to a minimal computational operation observed in a reasoning process, such as comparison or retrieval."
- Attribute-conditioned policies: Policies parameterized by high-level attributes that enable planning or control conditioned on desired properties or goals. "Composable Planning with Attributes utilize attribute-conditioned policies for zero-shot pathfinding."
- Autocurricula: Self-generated sequences of increasingly challenging tasks or environments that drive continual learning. "Autocurricula approaches use co-evolution to generate an endless stream of increasingly difficult environments"
- Causal isolation: An interpretability technique that tests the causal role of components by intervening on them in isolation. "a primitive's causal role can be evaluated through causal isolation and induction in the residual stream"
- Compositional closure: The set of all computations reachable by repeatedly applying composition operators to a primitive set. "We formalize open-ended intelligence in terms of the compositional closure induced by a finite primitive set and a set of composition operators ."
- Compositional generalization: The ability to recombine learned parts and rules to solve novel tasks beyond training distributions. "rather than compositional generalization and transfer of capabilities across fundamentally different families of environments."
- Compositional geometry: Structured latent-space patterns corresponding to primitives and their compositions within a model. "Compositional geometry refers to latent weight patterns corresponding to primitives and composition in the underlying model"
- Compositional grammar: Rules (e.g., sequencing, branching, recursion) governing how primitives are combined into larger computations. "compositional grammar captures rules like sequencing and recurrence for recombination and inference"
- Compositional motif: A recurring transition pattern among primitives—an algorithmic “phrase” that can be reused across tasks. "compositional motif captures common transition structures or algorithmic 'phrases' that can be represented as a graph motif"
- Compossibility: Logical co-existence of properties or facts within a given possible world; used to compare families of worlds. "families of possible worlds distinguished by what is compossible"
- Contrastive learning: A self-supervised objective that pulls similar representations together and pushes dissimilar ones apart. "This can be done by contrastive learning."
- Contrastive predictive coding: A contrastive self-supervised method that predicts future representations in latent space. "extended to self-supervised representation learning via contrastive predictive coding"
- Core Knowledge: Innate cognitive priors (e.g., about objects, agents, geometry) that scaffold learning and perception. "the Core Knowledge perspective identifies innate cognitive priors for objects, agents, and geometry."
- Counterfactual: A hypothetical variation of the world used to test whether learned structures generalize across changes. "counterfactual variations of possible worlds"
- Disentangled geometries: Representation spaces where factors of variation are organized along separable axes, aiding generalization. "organize abstract variables in disentangled geometries that enable generalization across contexts"
- Eigenoptions: Intrinsic options derived from spectral properties (eigenvectors) of the environment’s state-transition graph. "eigenoptions utilize the eigenvectors of the graph Laplacian to discover a set of intrinsic options"
- Epiplexity: A measure of how much learnable structure is present for bounded observers, separating structure from noise. "A recently proposed 'epiplexity' measure formalizes the information that bounded observers can extract from data"
- Function vectors: Steerable directions in model latent space that reliably induce specific computational behaviors. "Function vectors show that specific transformations can be reliably induced by applying learned directions"
- Graph Laplacian: A matrix capturing the connectivity of a graph; its eigenvectors reveal structural modes useful for options. "utilizes the eigenvectors of the graph Laplacian to discover a set of intrinsic options"
- Intrinsic Motivation: Internal drives (e.g., curiosity, novelty seeking) that guide exploration without external rewards. "exploration driven by Intrinsic Motivation or curiosity-driven developmental processes"
- JEPA: Joint-Embedding Predictive Architectures that learn by predicting latent representations rather than raw observations. "Unlike JEPA or next-latent prediction"
- MAP-Elites: A quality-diversity algorithm that finds high-performing solutions across a behavioral descriptor space. "MAP-Elites algorithms such as Quality-Diversity (QD)"
- Markov transition process: A stochastic process where transitions between states depend only on the current state, used to model primitive traversals. "modeled as a graph or a Markov transition process."
- Minimum Description Length (MDL): A parsimony principle favoring models that compress data with the shortest combined model-and-data description. "Selection is guided by a Minimum Description Length (MDL) objective."
- Minimum generating set problem: The problem of finding the smallest set of primitives and operators whose closure spans all needed solutions. "The minimal generating set problem is therefore central: what is the smallest set of primitives and operators whose closure supports open-ended intelligence?"
- Mixed selectivity: Neuronal coding where units respond to nonlinear mixtures of features, supporting flexible computation. "mixed selectivity support flexible computation and compositional reuse"
- MONet: An object-centric model that decomposes scenes into components via attention and generative modeling. "Architectures such as Slot Attention, MONet, and IODINE demonstrate the power of factorizing scenes into discrete entities"
- MoCo: A contrastive learning framework using momentum encoders to stabilize representation learning. "SimCLR and MoCo"
- Next Primitive Prediction (NPP): An objective/architecture that predicts the next primitive–operator pair in a composition to learn a grammar of computation. "We propose Next Primitive Prediction (NPP) as a composition-native architectural objective"
- Next-latent prediction: Self-supervised training that predicts future latent states/features rather than raw observations. "Unlike JEPA or next-latent prediction"
- Noisy TV problem: The pitfall where agents mistake unpredictable noise for novelty, harming exploration objectives. "optimizing for novelty alone is prone to the 'noisy TV' problem, or confusing noise with novelty"
- Novelty Search (NS): An evolutionary algorithm that optimizes for behavioral novelty rather than task-specific fitness. "In Novelty Search (NS), the algorithm optimizes for novel, rather than fit, behaviors"
- Object-centric learning: Methods that factor scenes into discrete objects to build structured world models. "representational primitives through object-centric learning."
- PCG (Procedural Content Generation): Algorithmic generation of environments or content, often to expand task diversity. "Procedural Content Generation (PCG)"
- PCGML (PCG via Machine Learning): Learning generative models from human-designed content distributions to produce new content. "PCG via Machine Learning (PCGML)"
- Parsimony constraint: A bias toward compact, reusable bases of primitives and rules rather than task-specific fragments. "The Parsimony Constraint"
- Persona vectors: Latent-space directions that modulate broad behavioral profiles, acting as priors over primitive selection. "Persona vectors extend this to broader behavioral profiles, which can be monitored and steered via latent directions"
- Possible worlds: Formal alternatives to the actual world used to analyze what remains invariant across controlled changes. "possible worlds are a tool for reasoning about necessity and contingency."
- Primitive Transition Graph (PTG): A directed graph where nodes are primitives and edges are composition operators used in a solution. "The Primitive Transition Graph (PTG)"
- Quality Diversity (QD): Algorithms that seek diverse, high-quality solutions across niches in behavior space. "Quality-Diversity (QD)"
- Residual stream: The main signal pathway inside transformer layers where linear combinations of features accumulate. "induction in the residual stream"
- SimCLR: A contrastive learning approach that maximizes agreement between differently augmented views of the same data. "SimCLR and MoCo"
- Slot Attention: An object-centric mechanism that assigns “slots” to entities via iterative attention routing. "Architectures such as Slot Attention, MONet, and IODINE"
- Spectral basis: A set of basis functions derived from graph spectra (eigenvectors) that capture multi-scale structure. "eigenoptions provide a spectral basis for diffusion and exploration"
- Stepping stones: Intermediate behaviors/skills that enable discovery of more complex solutions over time. "The dominant theoretical framing for open-ended discovery centers on the concept of 'stepping stones,'"
- Sub-graph mining: The process of discovering frequently recurring subgraphs (motifs) across solutions. "be discovered via sub-graph mining over PTGs"
- Transfer-as-Recomposition (TaR): Generalization by re-binding existing primitives within learned motifs to new world dynamics. "a mechanism we term Transfer-as-Recomposition (TaR)."
- Type-consistency: The requirement that compositions respect input/output types so primitives can be validly chained. "If compositions under C preserve type-consistency and admit reuse of intermediate outputs"
- Type-safety: Ensuring that only type-compatible primitives are connected by operators during composition. "Operators () are learned as the 'edges' that satisfy type-safety between primitives."
- Vector-based control: Steering model computations by adding learned latent directions corresponding to reusable operations. "Vector-based control offers evidence for primitive-level objects and their compositions as candidate computational objects"
- Wake–sleep library learning: A regime that alternates between constructing and using libraries of reusable parts to encourage compositionality. "in the spirit of wakeâsleep library learning"
- World-model: An internal model of environmental dynamics and entities built from representational primitives. "Here, a world-model is a combination of representational primitives."
Collections
Sign up for free to add this paper to one or more collections.
