Hyperon AI Algorithms
Within this section, we’ll review the mechanisms that compose the dynamics of thought itself. Each Hyperon algorithm functions as a specialized cognitive process that animates the system, elevating static knowledge into active intelligence. Expressed in MeTTa and executed across the distributed substrate, each algorithm addresses a fundamental requirement of general intelligence, for example handling reasoning under uncertainty, managing attention and economic resource allocation, and driving evolutionary learning and program synthesis.
Crucially, these are not isolated programs but interoperable modules of a unified cognitive cycle. By enabling these distinct modes of cognition to interact concurrently on shared memory (Atomspace), Hyperon enables a form of cognitive synergy. This interplay of diverse cognitive skills empowers AGI systems to tackle complex, multi-stage problems that would be improbable for any individual mechanism to overcome. What matters most is not the isolated strength of any one algorithm, but the recurrent traffic among them: the dynamics by which perceptual embeddings, attentional signals, rewrite processes, symbolic references, and learned structures continually transform one another through shared states.
The neural-symbolic bridge in Hyperon lies not only in the inclusion of different component types, but in the dynamics by which perceptual embeddings, attentional signals, rewrite processes, symbolic inferences, and learned structures continually transform one another through shared state.
ECAN (Economic Attention Networks)
ECAN is the attention-allocation and resource-regulation subsystem of the Hyperon architecture, designed to support cognitive efficiency under conditions of bounded computation and memory. In principle, a Hyperon agent knows everything stored in an Atomspace; in practice, however, attempting to reason over all stored knowledge simultaneously would be computationally intractable. ECAN addresses this problem by continuously regulating which Atoms are actively considered, ensuring that cognitive effort is concentrated on a tractable, context-relevant subset of the knowledge graph at any moment.
This regulation is achieved through two dynamically updated scalar values assigned to each Atom: Short-Term Importance (STI) and Long-Term Importance (LTI). STI captures immediate, context-dependent relevance and is propagated through Hebbian-weighted associative links, enabling attention to shift dynamically as situations, goals, or perceptions change. LTI, by contrast, reflects longer-horizon expected utility — encoding how consistently an Atom has contributed to successful inference, learning, or goal-directed behavior over time. Together, STI and LTI drive a nonlinear, feedback-driven attention dynamic that functions as an internal economy, determining which Atoms remain active, which fade into the background, and which are eventually deprioritized.
At a systems level, ECAN implements an attention protocol that balances short-term responsiveness with long-term coherence. Atoms effectively compete for limited working-memory and processing capacity based on their importance profiles and current context, with those that fail to demonstrate relevance gradually losing activation. By enforcing this dynamic attention economy, ECAN allows Hyperon agents to scale to very large knowledge bases while avoiding exponential blowup in search and inference, preserving real-time deliberative agility under bounded computational resources. In this role, ECAN is a key component of cognitive synergy, enabling systems like PLN and MOSES to operate fluidly by dynamically constraining portions of the knowledge base, addressing one of the key architectural challenges of AGI.
Repositories
Papers & Publications
Continue Reading
MetaMo (Motivational Framework)
MetaMo is a framework for modeling motivation in open-ended intelligent agents, concerned with how goals, priorities, and evaluative signals can be updated over time while preserving coherence, stability, and interpretability. Rather than relying on scalar reward functions or manually engineered drive hierarchies, MetaMo treats motivation itself as a dynamical system, explicitly coupling appraisal processes (which evaluate situations in terms of salience, risk, and opportunity) with decision processes (which select actions and allocate computational and behavioral resources). The objective is not affective realism, but the construction of a principled motivational substrate capable of supporting adaptive behavior, safe self-modification, and long-horizon deliberation.
MetaMo represents motivational state as a structured interaction between goal intensities and modulatory variables. Appraisal updates modulators such as valence, arousal, and risk sensitivity in response to contextual novelty and task relevance, while decision mechanisms score candidate actions relative to active goals under the current modulatory configuration. These processes are designed to commute up to bounded error, ensuring consistency between “appraise-then-decide” and “decide-then-appraise” cycles. System stability is enforced via contractive update dynamics that draw motivational state away from pathological extremes, while goal evolution proceeds incrementally to maintain continuity of self-model during learning and self-modification.
Within the Hyperon ecosystem, MetaMo serves as the motivational backbone linking inference, learning, and attention allocation. It shapes control dynamics in Probabilistic Logic Networks by biasing search and inference toward contextually appropriate goals, regulates exploration–exploitation tradeoffs, and embeds safety and ethical constraints directly within motivational dynamics rather than as externally imposed rules. In practice, this enables agents such as adaptive research assistants or autonomous scientific systems that must balance curiosity, caution, and long-term coherence. MetaMo does not encode specific values; instead, it provides the structural machinery through which an AGI system can form, maintain, and revise its priorities in a controlled and intelligible manner.
Repositories
Papers & Publications
- Lian, R., Goertzel, B. MetaMo: A Robust Motivational Framework for Open-Ended AGI. (AGI 2025)
- Lian, R., Goertzel, B. Embodying Abstract Motivational Principles in Concrete AGI Systems: From MetaMo to Open-Ended OpenPsi. (AGI 2025)
Continue Reading
Semantic Parsing (LLM/NLP)
Semantic Parsing is a neural-symbolic bridge designed to interpret the ambiguity of human language into executable logic within AGI. While natural language is fluid and context-dependent, the Atomspace requires rigorous, deterministic structures to perform reasoning. This subsystem bridges that gap, effectively functioning as a universal translator that ingests language inputs (textbook, web crawl, computer program) and converts it into a structured knowledge graph of distinct, queryable facts.
A key mechanism enabling this process is SENF (Semantic Elegant Normal Form). This framework addresses the fundamental “many-to-one” complexity of language, where the same fact can be phrased in dozens of ways (e.g., “The cat sat on the mat” vs. “The mat was sat upon by the cat”). SENF collapses these idiomatic variations into a single, canonical graph structure, ensuring that diverse inputs map to a unique, minimal representation. By combining the semantic intuition of LLMs with formal rewrite rules, the system strips away linguistic noise to reveal the essential logical relationships underneath.
The result is the creation of grounded atoms, verified logical expressions that serve as the fundamental knowledge representations for the Hyperon ecosystem. Semantic parsing is an essential utility for turning static text into living knowledge. Once parsed, a textbook becomes a dynamic database where facts are cross-referenced, contradictions are flagged, and Hyperon algorithms can cogitate directly on the meaning of the text.
Repositories
Continue Reading
MeTTa-Motto
MeTTa-Motto is an interoperability layer designed to embed LLMs directly into the MeTTa runtime, effectively treating neural models as programmable functions within a symbolic workflow. It allows developers to compose prompts, chain LLM calls, and manage context seamlessly within MeTTa scripts, enabling a bidirectional flow where symbolic logic guides neural generation and neural outputs are parsed back into grounded atoms.
The library operates through a flexible Agent architecture, ranging from stateless model wrappers (e.g., ChatGPT, Claude) to stateful Dialogue Agents and Retrieval Agents (RAG). Crucially, MeTTa-Motto supports functional calling, empowering LLMs to autonomously recognize when to invoke specific MeTTa functions and extract arguments from natural language. With extensive integration for Python and LangChain, it serves as the essential tooling for building systems that combine the fluency of generative AI with the rigorous control of the Hyperon stack.
Repositories
Continue Reading
PLN (Probabilistic Logic Networks)
PLN is Hyperon's primary symbolic reasoning system designed to operate under uncertainty, enabling real-time inference when information is incomplete, noisy, or probabilistic. Unlike classical logic systems that assume binary truth values, PLN represents beliefs with graded confidence and updates them continuously as new evidence arrives. It supports deductive, inductive, and abductive reasoning within a single formal framework, allowing the system not only to apply known rules, but also to generalize from experience, form hypotheses, and revise beliefs over time. Conceptually, PLN can be thought of as a logic-based analogue of statistical learning, with explicit semantics and traceable inference steps.
Technically, PLN operates over an Atomspace, a graph-structured knowledge representation in which concepts, relations, and experiences are linked together with probabilistic truth values. Reasoning proceeds by transforming and combining these links using principled inference rules grounded in probability theory. This allows PLN to perform tasks such as causal reasoning, analogical inference, and abstraction, while maintaining transparency about why a conclusion was reached and how confident the system is in it. Because PLN was designed to handle uncertainty, it degrades gracefully: when evidence is sparse or conflicting, it produces tentative conclusions rather than brittle failures.
To ensure computational tractability within the massive scale of the Atomspace, PLN leverages forward and backward chaining inference control and can also call on ECAN (Economic Attention Allocation) to dynamically filter the knowledge graph into a temporary working memory of high-salience facts. This attention-driven constraint allows the system to perform deep, complex reasoning in real-time without succumbing to the combinatorial explosions inherent in processing the full breadth of stored knowledge.
Repositories
Demos
Papers & Publications
- Probabilistic Logic Networks A Comprehensive Framework for Uncertain Inference. Ben Goertzel, Matthew Ikle, Izabela Freire Goertzel, Ari Heljakka. 2009.
- Grounding Possible Worlds Semantics in Experiential Semantics. Matthew Ikle, Ben Goertzel. 2010.
- Probabilistic Logic Networks for Temporal and Procedural Reasoning. Nil Geisweiller, Hedra Yusuf. 2023.
Continue Reading
MeTTa-NARS (Non-Axiomatic Reasoning System)
MeTTa-NARS is an open-ended uncertainty reasoning engine designed to operate under the Assumption of Insufficient Knowledge and Resources (AIKR). Unlike traditional logical systems that require complete, clean data to function, MeTTa-NARS is built for the open world where information is scarce, inconsistent, and constantly changing. It provides real-time adaptive intelligence capable of learning logical dependencies and making decisions based on incomplete evidence, rather than waiting for absolute certainty.
The system distinguishes itself through its usage of Non-Axiomatic Logic (NAL), which replaces binary truth with a two-dimensional evidence value (frequency and confidence). This allows the agent to distinguish between “I know this is true because I have seen it 100 times” and “I think this is true, but I have only seen it once”—a critical nuance for safe autonomous learning. MeTTa-NARS manages this knowledge via a concept-centric memory and a rigorous inference control mechanism. This controller treats reasoning as a resource allocation problem, dynamically prioritizing relevant thoughts and discarding less useful information to ensure the system remains responsive in real-time without suffering from combinatorial explosions.
MeTTa-NARS drives the active, never-ending learning loop, allowing agents to continually refine their understanding of the world as they encounter new, unexpected phenomena.
Repositories
Papers & Publications
- Isaev, P., & Hammer, P. (2025, August). NARS-GPT: An Integrated Reasoning System for Natural Language Interactions. In Intelligent Systems and Applications: Proceedings of the 2025 Intelligent Systems Conference (IntelliSys) Volume 4 (Vol. 4, p. 404). Springer Nature.
- Hammer, P., Isaev, P., Feng, L., Johansson, R., & Tumova, J. (2024, May). Non-Axiomatic Reasoning for an Autonomous Mobile Robot. In 2024 IEEE International Conference on Robotics and Automation (ICRA) (pp. 17079-17085). IEEE.
Continue Reading
NACE (Non-Axiomatic Causal Explorer)
NACE is an experiential learning agent designed to overcome the extreme data inefficiency of deep reinforcement learning (DRL). While standard DRL agents require millions of trial-and-error samples to approximate correlations, NACE functions as a causal reasoner: it actively constructs a logic-based model of its environment by observing the direct consequences of its interactions. This approach allows it to master complex grid-world environments with remarkable speed, demonstrating a 1000-fold reduction in data requirements—achieving competence in roughly 1,000 steps where state-of-the-art baselines require over 1,000,000.
Functionally, the agent operates on a cycle of curiosity-driven exploration. NACE generates causal rules from local changes in the environment (e.g., “pushing this block opens that door”) and prioritizes its actions based on an intrinsic reward signal geared toward uncertainty reduction. Rather than merely chasing a game score, it plans paths specifically to reach states where its internal model is incomplete, systematically filling knowledge gaps. Grounded in Non-Axiomatic Logic (NAL), the system is robust to noise: it tracks the evidential weight of every rule (balancing positive vs. negative evidence), allowing it to maintain a stable but plastic worldview that adapts to stochastic environments without the brittleness of traditional symbolic AI.
Repositories
Demos
Papers & Publications
- “A Grid World Agent with Favorable Inductive Biases”
Continue Reading
AI-DSL
AI-DSL is the protocol and tooling layer designed to automatically assemble complex AI workflows from the discrete services available on the SingularityNET and Artificial Super Intelligence (ASI) marketplaces. It fulfills the vision of a “network of intelligences” by treating individual AI services not as isolated apps, but as composable functions that can be chained together to solve problems no single service could handle alone (e.g., creating a “Speech-to-Translated-Song” pipeline).
Functionally, the AI-DSL operates as a type-driven program synthesizer. It employs a backward chainer implemented in MeTTa that treats a user’s request as a “theorem” to be proven and the available AI services as “axioms”. To bridge the gap between abstract requirements and concrete code, it utilizes a rich Ontology of dependent types. Unlike standard interface definitions (like Protobuf) which might crudely label an output as a “String,” the AI-DSL ontology distinguishes between semantic concepts—such as TextIn English vs. TextIn Chinese or Audio vs. MIDI. This semantic precision prevents absurd compositions (like feeding audio files into image recognizers) and allows the planner to strictly enforce logical compatibility.
To ensure the synthesis process remains computationally tractable, AI-DSL leverages combinatory logic—specifically “Bluebird” (sequential) and “Phoenix” (parallel) combinators — rather than raw lambda calculus. This approach, combined with aggressive pruning techniques, reduces the search space for valid compositions from days of computation to mere seconds.
Repositories
Papers & Publications
Continue Reading
MOSES
MOSES is an evolutionary program generation engine, designed to breed compact, interpretable computer programs that solve complex problems. Unlike deep neural networks that function as black boxes of opaque weights, MOSES evolves transparent symbolic code (e.g., Lisp-like trees) capable of logical generalization. It treats the search for solutions as a meta-optimization problem, maintaining diverse subpopulations of programs (demes) to avoid local optima while iteratively refining candidates. This allows it to function as an automated data scientist, discovering the explicit causal formulas underlying a dataset rather than merely approximating statistical correlations.
Functionally, MOSES combines probabilistic model-building with evolutionary search to drive programmatic novelty. It operates via two nested loops: an outer loop that explores structural variations (recombining program trees to generate new logic) and an inner loop that tunes numeric parameters (optimizing specific “knobs” within those trees).
A defining characteristic of MOSES is its rigorous use of Elegant Normal Form (ENF) to constrain the search space. Rather than generating random code variations, the system converts every candidate program into a canonical, normalized representation (e.g., ensuring that a + b and b + a are treated as identical structures). By reducing all functionally equivalent programs to a single syntactic form, MOSES eliminates redundancy and drastically shrinks the combinatorial search space. This ensures that the evolutionary process expends its resources solely on meaningful logic changes rather than syntactic variations, resulting in solutions that are computationally efficient by design.
Repositories
Papers & Publications
Continue Reading
AIRIS
AIRIS is a causal machine learning system designed to overcome the opacity and data-inefficiency of traditional deep reinforcement learning. Rather than ingesting massive datasets to approximate statistical correlations, AIRIS functions as a causal reasoner. It actively constructs a deterministic model of its environment through direct interaction. This approach yields exceptional transparency, encoding decision logic in explicit, auditable rules rather than inscrutable neural weights.
The system has proven its capabilities in voxel-based environments like Minecraft, where it operates without pre-training. By observing the direct consequences of its actions (e.g., “walking into lava causes damage,” “dirt blocks can be stacked”), AIRIS builds a dynamic knowledge base of causal rewrite rules. It uses these rules to run internal simulations in its dynamically generated world model to plan complex paths and achieve arbitrary goals. Crucially, the system is self-correcting: when a prediction fails, such as falling into an unseen ravine, AIRIS instantly isolates the error and updates its rule set, effectively applying the scientific method to autonomous navigation.
Within the context of Hyperon, AIRIS serves as a useful mechanism for causal learning. It translates raw sensory data from the virtual world into the structured symbolic knowledge of the Atomspace. These grounded atoms become the raw material for higher-level algorithms like PLN and MOSES, which abstract the learned rules into higher level, generalizable strategies. In this role, AIRIS acts as a sensory-motor cortex in certain contexts, providing the foundational physics of reality upon which AGI can reason across diverse environments.
Repositories
Papers & Publications
- AIRIS Paper
- Paving the Way to AGI: AIRIS's Role in the Bigger Picture
- From 2D to 3D: AIRIS Ventures into Minecraft
- Flexible Thinking: How AIRIS Adjusts to Changing Goals
- Learning from the Unexpected: AIRIS's Rule Creation and Adaptation
- Mapping the Future: The State Graph in AIRIS Explained
- Step-by-Step Breakdown of How AIRIS Works
- How AIRIS Learns: Diving into Autonomous Causal Rule Learning
- Overcoming Traditional AI Limits: The Adaptive Intelligence of AIRIS in Complex Systems
- Understanding AIRIS: A Novel Approach to Artificial Intelligence
- The Future of AI with AIRIS: A Dynamic Approach to Learning and Adaptation
Continue Reading