About Hyperon

help edit space_dashboard
Draft — This content has not been approved for publication.

Hyperon is SingularityNET's open-source platform for Artificial General Intelligence, designed to progress from here to AGI and ultimately to beneficial ASI (Artificial Superintelligence). Building on decades of research from the OpenCog project, Hyperon provides a unified neurosymbolic framework where diverse cognitive processes — symbolic reasoning, probabilistic inference, neural learning, evolutionary search, and attention allocation — interoperate over shared memory to produce emergent general intelligence.

Unlike narrow AI systems optimized for individual tasks, Hyperon is designed as a composable infrastructure in which multiple learning and reasoning algorithms collaborate through a principle called cognitive synergy. Each algorithm addresses a fundamental requirement of general intelligence, but it is their interaction — sharing representations, guiding each other's search, and co-evolving within a common knowledge substrate — that is intended to enable the system to tackle problems none could solve alone.

Architecture at a Glance

Hyperon's architecture spans four layers, each documented in detail within this wiki:

  • AtomSpace — A typed, content-addressed metagraph that serves as shared memory and control plane. Atoms represent symbolic data, relationships, truth values, motives, and executable code in a unified structure where code and data are interchangeable. AtomSpace can be implemented on multiple backends, from the high-performance MORK engine (prefix-tree-based, with large speedups over previous implementations) to the DAS (Distributed AtomSpace) for decentralized operation.
  • MeTTa — Meta-Type Talk, a homoiconic programming language that serves as the native "language of thought." MeTTa operates directly over AtomSpace as graph transformations, enabling reflective self-modification, nondeterministic inference, and seamless interoperation between symbolic and neural components. Multiple implementations exist: PeTTa (high-performance Prolog-based), Hyperon Experimental (reference Rust implementation), JeTTa (JVM), MeTTa-Morph (Scheme), and MeTTaTron (F1R3FLY-native).
  • AI Algorithms — A library of cognitive modules authored in MeTTa: PLN for probabilistic reasoning under uncertainty, ECAN for economic attention allocation, MOSES for evolutionary program synthesis, MetaMo for compositional motivation, NARS-based systems for open-ended reasoning, and integration layers for LLMs and neural networks.
  • PRIMUS Cognitive Architecture — The meta-architecture that orchestrates these components into a unified cognitive system. PRIMUS defines how goal-directed and ambient cognitive loops cooperate, how attention and resources flow between modules, and how the system maintains coherence while self-modifying. Recent theoretical advances include weakness-based simplicity priors, geodesic inference control, TransWeave for cross-domain transfer, and WILLIAM for adaptive compression.

The ASI Chain

For decentralized deployment, Hyperon compiles MeTTa into targets running on ASI Chain — a blockchain runtime designed for AGI workloads. ASI Chain provides cryptographically secured execution, content-addressed provenance, and the ability to scale cognitive processes from a single machine to a distributed network. Its F1R3FLY engine renders concurrent process calculi for scalability, while MeTTaCycle orchestrates AGI workloads. The whitepaper describes ASI Chain as targeting "native inference settlement" — verifying cognitive state transitions rather than just token transfers.

Neural-Symbolic Integration

Hyperon bridges symbolic and neural paradigms through two complementary approaches:

  • Outside integration (current) wraps existing neural models (LLMs, vision systems, embedding models) as Spaces within AtomSpace, exposing their outputs for symbolic reasoning and compositional planning. This is implemented via the MeTTa-Motto library.
  • Inside integration (experimental) via QuantiMORK proposes encoding neural network structures — wavelet-structured tensors, weight matrices, activation patterns — directly into the MORK PathMap, enabling predictive-coding-style local learning updates without backpropagation.

From OpenCog to Hyperon

Hyperon is a ground-up redesign of the earlier OpenCog framework, preserving the core cognitive theories (cognitive synergy, CogPrime architecture, patternist philosophy of mind) while incorporating new ideas at every level: a new type system and language (MeTTa replacing Atomese/Scheme), a new high-performance backend (MORK replacing the C++ AtomSpace), new mathematical controls (quantale-based weakness, geodesic effort), and decentralized execution infrastructure. The transition represents not a departure from OpenCog's vision but its maturation into a system engineered for scalability and composability.

Key Resources

Explore Further

help edit space_dashboard
Approved by Ursula Addison on 2026-05-04

Hyperon inherits its conceptual DNA from OpenCog, an open-source AGI framework that evolved through two decades of research and development. Understanding this lineage illuminates why Hyperon is designed the way it is — and what changed in the transition.

Origins: Novamente to OpenCog (1997–2008)

The intellectual roots trace to the late 1990s. Ben Goertzel's work on formalizing general intelligence — defining it as "the ability to achieve complex goals in complex environments" — led to a series of practical systems: the Webmind AI Engine (1997–2001) at Intelligenesis Corp., followed by the Novamente Cognition Engine (2001–2008) at Novamente LLC. In 2008, the Novamente source code was released publicly as OpenCog, establishing an open-source community around the pursuit of AGI.

The conceptual framework was elaborated in several key publications: The Hidden Pattern (2006) on pattern-based philosophy of mind, Probabilistic Logic Networks (2008) on reasoning under uncertainty, and Building Better Minds (2012, with Cassio Pennachin and Nil Geisweiller) detailing the full CogPrime architecture — the specific configuration of cognitive components believed capable of achieving human-level AGI.

OpenCog Classic Architecture

The original OpenCog system, now sometimes called "OpenCog Classic," was built in C++, Scheme, and Python around several core components:

  • AtomSpace — A hypergraph database storing typed atoms (nodes and links) with associated truth values, attention values, and other metadata. Knowledge was represented in Atomese, a Lisp-like language for constructing and querying graph structures.
  • PLN (Probabilistic Logic Networks) — A comprehensive uncertain inference framework supporting deductive, inductive, and abductive reasoning with graded confidence.
  • MOSES (Meta-Optimizing Semantic Evolutionary Search) — An evolutionary program learning system that breeds compact symbolic programs to solve complex optimization problems.
  • ECAN (Economic Attention Allocation Networks) — An attention economy that dynamically allocates computational resources across atoms based on short-term and long-term importance.
  • OpenPsi — A motivational framework implementing PSI theory for drive-based behavior selection, emotional dynamics, and goal management.
  • URE (Unified Rule Engine) — A general-purpose forward and backward chainer for applying inference rules over AtomSpace.
  • Link Grammar & RelEx — Natural language processing components for parsing English into dependency structures and mapping them to Atomese representations.

These components were deployed in virtual agent control (OpenCogBot in virtual worlds), humanoid robotics (Hanson Robotics integration), and biological knowledge exploration.

What Carried Forward

Hyperon preserves the core intellectual commitments of OpenCog:

  • Cognitive synergy — The conviction that AGI requires multiple interoperating cognitive processes, not a single monolithic algorithm.
  • AtomSpace as shared memory — A typed metagraph serving as the common substrate for all cognitive operations.
  • The CogPrime cognitive model — Now evolved into PRIMUS, retaining the same fundamental architecture of interacting memory systems, attention dynamics, and goal-directed reasoning.
  • The same core algorithms — PLN, MOSES, and ECAN remain central to Hyperon, updated with new mathematical foundations.
  • Patternist philosophy — Intelligence understood as pattern recognition and creation across multiple levels of abstraction.

What Changed

Hyperon is not an incremental update but a ground-up redesign motivated by hard-won lessons from a decade of OpenCog development:

  • Language: Atomese and Scheme were replaced by MeTTa — a purpose-built language with a formal type system, homoiconicity (code-as-data), and native support for nondeterministic inference and self-modification. Where Atomese required manual encoding in Scheme, MeTTa operates directly as graph transformations over AtomSpace.
  • Performance: The C++ AtomSpace was complemented (and in high-performance contexts replaced) by MORK, a prefix-tree-based metagraph engine achieving large speedups through radically different data structures and the Zipper Abstract Machine.
  • Mathematics: New unifying mathematical frameworks — quantale-based weakness theory, geodesic inference control, optimal transport for attention — provide principled controls that the original system lacked.
  • Decentralization: OpenCog ran on single machines or small clusters. Hyperon targets decentralized execution via ASI Chain, with cryptographic provenance, capability-secured processes, and blockchain-based governance.
  • Neural integration: OpenCog treated neural networks as external components. Hyperon offers deeper integration through QuantiMORK (proposed: encoding tensors natively in the graph) alongside pragmatic wrapping of existing models via MeTTa-Motto.
  • Motivation: OpenPsi evolved into MetaMo, a mathematically grounded compositional motivation framework with formal stability guarantees.

Technical Deep Dive: OpenCog Legacy Full — complete timeline, 11-row architectural bridge map, five motivations for transition, component maturity analysis, CogServer criticisms, anti-CYC philosophy, pattern mining evolution, and maintained vs. archived repos.

Key References

  • Hart, D. and Goertzel, B. (2008). OpenCog: A Software Framework for Integrative Artificial General Intelligence — Proceedings of the First Conference on AGI, IOS Press
  • Goertzel, B. (2012). Building Better Minds — comprehensive CogPrime design
  • Goertzel, B. et al. (2023). OpenCog Hyperon: A Framework for AGI at the Human Level and Beyond
  • Goertzel, B. (2025). Hyperon for AGI⇒ASI: Whitepaper 2025
  • OpenCog Wiki — historical documentation

 



Discussion

 

help edit space_dashboard
Approved by Anna on 2026-05-02

Cognitive synergy is the foundational design principle of Hyperon: the idea that general intelligence emerges not from any single algorithm but from the cooperative interaction of multiple specialized cognitive processes sharing a common knowledge substrate. It is both a theory of how minds work and an engineering methodology for building AGI systems.

The Core Insight

Human cognition integrates perception, reasoning, memory, attention, motivation, language, and learning into a unified system where each process continuously informs and strengthens the others. A purely logical reasoner struggles with grounding; a purely statistical learner struggles with compositionality; a purely evolutionary system struggles with directed search. But when these approaches operate over shared representations and guide each other's processing, capabilities emerge that none could achieve independently.

In Goertzel's formulation from Building Better Minds: cognitive synergy occurs when multiple cognitive processes — each handling a different aspect of intelligence — cooperate in a way that their combined capability exceeds the sum of their individual contributions. This is not mere parallelism. It is deep interoperation: one process generating hypotheses that another evaluates, one process identifying attention-worthy patterns that another reasons about, one process learning representations that another uses to plan.

How Synergy Is Designed Into Hyperon

Hyperon's architecture is engineered to enable cognitive synergy through three mechanisms:

  • Shared AtomSpace: All cognitive processes read from and write to the same typed metagraph. When PLN derives a new inference, it becomes available to MOSES for program synthesis, to ECAN for attention reallocation, and to pattern mining for structural analysis. Co-location in shared memory reduces the integration overhead that plagues systems where components communicate through narrow APIs or message buses.
  • Common representational language: MeTTa provides a single language in which reasoning rules, evolutionary fitness functions, attention policies, and motivational goals can all be expressed, examined, and combined. Because code is data in MeTTa, one cognitive process can inspect and modify the programs of another.
  • PRIMUS orchestration: The PRIMUS cognitive architecture defines how cognitive processes cooperate within two meta-dynamics: goal-directed loops (where specific objectives drive coordinated processing) and ambient loops (where background maintenance — attention spreading, pattern discovery, memory consolidation — keeps the system's knowledge fresh and well-organized).

Critical Synergies

Some of the most important synergistic interactions designed into Hyperon include:

  • PLN + MOSES: Logical inference generates candidate hypotheses; evolutionary search breeds programs to test them. PLN can evaluate the logical consistency of MOSES-generated programs, while MOSES can evolve inference control strategies for PLN.
  • ECAN + PLN: Attention allocation guides which inferences are worth pursuing (avoiding combinatorial explosion), while inference results inform which atoms deserve increased attention.
  • Pattern Mining + Neural Networks: Mined patterns from AtomSpace can serve as structural priors for neural architectures, while neural embeddings can guide the pattern mining search.
  • MetaMo + All Processes: The motivational framework evaluates which cognitive goals are most urgent and allocates resources accordingly, creating a self-regulating economy of cognitive effort.

Why Cognitive Synergy Is "Tricky"

As discussed in Building Better Minds (Chapter 8), cognitive synergy may explain a puzzling feature of AGI research: the difficulty of measuring partial progress. If intelligence emerges primarily from the interaction between cognitive processes rather than from any individual process, then a system with three out of five components may show dramatically less capability than one with all five — even though it is only "two components away." This creates a perception of sudden capability jumps that are actually the result of crossing synergy thresholds.

This insight has practical consequences for Hyperon development: the system's true capabilities may only become apparent when enough components are integrated and interoperating, not when individual components are benchmarked in isolation.

Key References

  • Goertzel, B. et al. (2012). Building Better Minds, Chapter 8: Cognitive Synergy
  • Goertzel, B. (2009). OpenCogPrime: A Cognitive Synergy Based Architecture for Embodied AGI
  • Goertzel, B. (2025). Hyperon for AGI⇒ASI Whitepaper, §4: The PRIMUS Cognitive Architecture



Discussion

help edit space_dashboard
Approved by Ursula Addison on 2026-05-04

AtomSpace is the foundational data structure at the heart of Hyperon — a typed, content-addressed metagraph that serves as both shared memory and control plane for all cognitive processes. It is the substrate in which knowledge, code, inference results, attention values, motivational states, and neural representations all coexist and interoperate.

Status: The AtomSpace concept and Space API abstraction are current — implemented in the reference Hyperon codebase (hyperon-experimental) and in MORK. The reference AtomSpace, MORK, and DAS backends are operational. Neural Spaces are experimental; blockchain-backed Spaces via F1R3FLY are proposed.

What Is a Metagraph?

An AtomSpace is a generalization of a hypergraph. Where a traditional graph connects pairs of nodes with edges, and a hypergraph allows edges to connect arbitrary sets of nodes, a metagraph goes further: edges (Links) can themselves be members of other edges, and both nodes and links carry typed values. This recursive structure naturally represents the nested, multi-relational knowledge structures required for general intelligence — logical implications, probabilistic dependencies, procedural programs, and attention metadata can all be expressed as atoms within the same graph.

Every atom in AtomSpace is typed. The type system encodes data categories (symbols, numbers, expressions), function types, and logical connectives. The scope and enforcement of type constraints varies across backends — the reference implementation and MORK each handle types somewhat differently. MeTTa programs can introspect and manipulate the type structure itself.

Code Is Data

A defining feature of AtomSpace is that programs and data share the same representation. A MeTTa function definition, a PLN inference rule, a MOSES-generated program, and a factual knowledge assertion are all atoms in the metagraph. This homoiconicity enables:

  • Reflective self-modification: Programs can inspect, analyze, and rewrite themselves and each other at runtime.
  • Cognitive synergy: Different cognitive processes naturally share representations because they all operate on the same substrate.
  • Inference over code: PLN can reason about the properties of programs just as it reasons about factual knowledge.

The Space API

AtomSpace is accessed through a universal Space API that abstracts over multiple possible backends. A Space supports operations for adding, removing, querying, and pattern-matching atoms. Current and planned backends:

  • Reference AtomSpace (current) — The Rust implementation in hyperon-experimental, providing the canonical semantics for MeTTa execution.
  • MORK (current) — The high-performance core. A prefix-tree (trie-map) based engine achieving large speedups over previous implementations. MORK stores S-expressions as paths in a radix tree, enabling near-constant-time content-addressed lookup. Its Zipper Abstract Machine (ZAM) supports multi-threaded parallel execution. (See MORK for details.)
  • DAS (Distributed AtomSpace) (current) — A distributed backend that decouples persistence (Long-Term Importance) from immediate dynamics (Short-Term Importance via an Attention Broker). DAS enables AtomSpaces spanning multiple machines with Hebbian learning-based resource allocation. (See DAS for details.)
  • Neural Spaces (experimental) — Wrappers that expose neural network models (LLMs, embedding models, vision systems) as queryable Spaces, enabling symbolic processes to interact with neural outputs through the same API.
  • Blockchain-backed Spaces (proposed) — AtomSpaces persisted on ASI Chain via F1R3FLY's RSpaces, providing cryptographic provenance and decentralized access.

Content Addressing

Atoms in AtomSpace are content-addressed — identified by what they contain rather than where they are stored. In MORK, this is implemented through content identifiers (CIDs) derived from the atom's path in the trie structure, enabling efficient verification and deduplication. Content addressing is what makes distributed and decentralized AtomSpaces practical: the same atom resolves to the same identifier regardless of which node stores it.

Truth Values and Metadata

Atoms carry associated values beyond their structural content:

  • Truth Values: Probabilistic confidence measures used by PLN for uncertain reasoning. Hyperon supports multiple truth value types including simple (strength, confidence), distributional, and indefinite truth values.
  • Attention Values: Short-Term Importance (STI) and Long-Term Importance (LTI) scalars managed by ECAN to regulate which atoms receive computational resources.
  • Custom Values: Arbitrary typed metadata can be attached to atoms, including tensors, timestamps, provenance records, and motivational annotations.

Historical Context

The AtomSpace concept originated in the OpenCog project as a C++/Scheme hypergraph database. The original implementation stored atoms in an in-memory graph with optional PostgreSQL persistence. In Hyperon, the concept has been generalized: AtomSpace is now an abstract interface (the Space API) that can be implemented on different backends — from MORK's prefix trees to DAS's distributed storage — while preserving consistent semantics for cognitive processes built on top of it.

Technical Deep Dive: AtomSpace Full — metagraph formal definition, Atom/Value distinction, TruthValue-to-FloatValue transition, Space API abstraction, classical C++ vs. Rust implementations, performance architecture, and historical design decisions.

Key References

  • Goertzel, B. (2025). Hyperon for AGI⇒ASI Whitepaper, §2: Hyperon System Design
  • Goertzel, B. (2012). Building Better Minds, Ch. 19–20: OpenCog Framework and Knowledge Representation
  • opencog/atomspace — Original C++ AtomSpace implementation
  • trueagi-io/hyperon-experimental — Reference Rust AtomSpace in Hyperon

 



Discussion

 

help edit space_dashboard
Approved by Anna on 2026-04-27

A central challenge of AGI is unifying the complementary strengths of neural networks (pattern recognition, generalization from data, continuous optimization) with symbolic systems (compositional reasoning, interpretability, knowledge representation). Hyperon's design addresses this through a dual-path architecture offering both pragmatic interoperability and deep structural unification.

Status: Outside integration is current (implemented via MeTTa-Motto). Inside integration (QuantiMORK) and the advanced techniques below are proposed — described in the 2025 whitepaper as research directions.

Two Paths to Integration

Hyperon provides two complementary modes of neural-symbolic integration, suited to different stages of system maturity:

Outside Integration: Pragmatic Wrapping (Current)

In outside mode, existing neural models — large language models, vision transformers, embedding models, reinforcement learning agents — are wrapped as Spaces within Hyperon's Space API. Symbolic processes can query neural models through the same interface they use to query the AtomSpace:

  • An LLM can be queried for semantic parsing, translating natural language into MeTTa expressions that PLN can reason about.
  • An embedding model can provide similarity-based retrieval, enabling pattern mining to discover structural regularities in neural representations.
  • A vision system can populate AtomSpace with perceived objects and relationships, grounding symbolic reasoning in perceptual data.

The MeTTa-Motto library implements this approach, embedding LLMs (ChatGPT, Claude, open-source models) as programmable MeTTa functions with support for stateless wrappers, stateful dialogue agents, retrieval-augmented generation, and functional calling. (See MeTTa-Motto for details.)

The whitepaper also describes Symbolic Transformer Heads as part of outside integration: mined patterns from AtomSpace serve as structured templates augmenting standard transformer attention heads, using contrastive symbolic alignment to ensure patterns survive memory compression in compressive transformer architectures.

Inside Integration: QuantiMORK (Proposed)

The 2025 whitepaper proposes a more radical inside mode called QuantiMORK, in which neural network structures would be natively encoded within the MORK metagraph rather than wrapped. This would represent neural network components — weight matrices, activation patterns, wavelet-structured tensors — directly as paths and values in MORK's prefix-tree database.

Proposed properties of QuantiMORK:

  • Neural networks as native graph operations: Forward passes, weight updates, and activation propagation expressed as graph traversals within MORK, making them amenable to the same attention allocation and reasoning processes that operate on symbolic content.
  • Predictive coding without backpropagation: Local updates where each layer adjusts based on prediction errors from adjacent layers, compatible with Hyperon's distributed, asynchronous execution model.
  • Unified attention: Neural activations and symbolic knowledge would share the same graph, allowing ECAN's attention allocation to operate uniformly across both.

Weakness-Based Stability (Proposed)

To address the risk that neural learning updates could destabilize symbolic knowledge (and vice versa), the whitepaper explores weakness-based regularization: a quantale-valued simplicity metric applying uniformly to both neural weight updates and symbolic inference steps. The whitepaper investigates conditions under which combined updates would approximately commute — a desirable property for reliable integration, though the extent of this commutativity in practice remains an open research question.

Key References

  • Goertzel, B. (2025). Hyperon for AGI⇒ASI Whitepaper, §7: Neural-Symbolic Synergy in Hyperon
  • Goertzel, B. et al. (2023). OpenCog Hyperon, §3.2: Hyperon's Position in the Era of LLMs



Discussion

help edit space_dashboard
Approved by Anna on 2026-04-27

A system capable of general intelligence must eventually be capable of reflecting on and improving its own cognitive processes. Hyperon's design treats self-modification as a first-class capability governed by formal mathematical guarantees — aiming to ensure that a system improving itself remains aligned with its intended goals and values.

Status: Proposed. The self-modification pipeline described here is a research design from the 2025 whitepaper (§8). It has not yet been implemented end-to-end. The mathematical foundations (weakness theory, geodesic control) are under active development; the deployment pipeline and governance mechanisms remain architectural proposals.

The Challenge

Self-modifying AGI presents a fundamental tension: the same capability that enables a system to improve itself could allow it to alter its goals, remove its safety constraints, or destabilize its own reasoning. Hyperon's proposed approach is to make self-modification transparent, auditable, and mathematically bounded.

The Proposed Five-Stage Self-Modification Pipeline

The whitepaper describes a disciplined pipeline for self-modification:

  1. Proposal: A modification is expressed as a typed metamorphism — a formal transformation with explicit pre-conditions, post-conditions, and type signatures. Because MeTTa is homoiconic (code is data), modifications to cognitive processes would be represented as atoms in AtomSpace, subject to the same reasoning and analysis as any other knowledge.
  2. Analysis: PLN and other reasoning processes would analyze the proposed modification for logical consistency, potential side effects, and alignment with current goal structures. The weakness metric would provide a quantitative bound on how much complexity the modification introduces.
  3. Simulation: The modification would be tested in a twin simulation — a sandboxed copy of the relevant AtomSpace subgraph where the modification can be applied and its effects observed without affecting the running system.
  4. Certification: Formal admission certificates would validate that the modification satisfies safety properties, verified using the same inference machinery (PLN over quantale-annotated factor graphs) that powers general reasoning.
  5. Deployment: Certified modifications would be deployed through staged rollout: shadow mode (running alongside the original), dual-run (both versions active with output comparison), and finally elevation to primary status — with rollback capability at every stage.

Goal Stability (Proposed)

The whitepaper proposes addressing goal stability through supermartingale potentials — Lyapunov-like mathematical functions that provably do not increase under permitted modifications. If a proposed change would increase the potential (indicating goal drift), it would be flagged for additional review or rejected. The aim is to transform goal stability from a philosophical concern into a tractable mathematical problem.

Global Regulators (Proposed)

The design envisions certain principles enforced globally across all cognitive processes:

  • Weakness bounds: All updates must satisfy quantale-valued simplicity constraints.
  • Geodesic effort: All control flow follows cost-aware geodesic paths balancing accuracy against simplicity.
  • Transparency: All modifications are logged with full provenance in content-addressed storage.

Decentralized Governance (Proposed)

When Hyperon operates on ASI Chain, self-modifications could become subject to multi-party governance — requiring approval from multiple stakeholders, community voting, or smart contract constraints encoding organizational policies.

Technical Deep Dive: Self-Modification and Safety Full — typed metamorphism formalism, supermartingale goal stability, five-stage pipeline details, lens laws, drift bounds, and decentralized governance.

Key References

  • Goertzel, B. (2025). Hyperon for AGI⇒ASI Whitepaper, §8: Planning for the AGI→ASI Transition
  • Goertzel, B. (2012). Building Better Minds, Ch. 18: Advanced Self-Modification



Discussion



Discussion