About Hyperon
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 AGI research, 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 five interoperating layers that correspond to this wiki's five main sections:
- Knowledge Representations (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).
- Hyperon 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.
- Cognitive Architecture & Research (PRIMUS) — 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.
- ASI:Chain Runtime Environment — A blockchain runtime for decentralized deployment, compiling MeTTa into cryptographically-secured, content-addressed cognitive workloads that scale from a single machine to a distributed network (detailed below).
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.
Key Resources
- Whitepaper: Hyperon for AGI⇒ASI (Ben Goertzel, November 2025)
- Primary Repository: hyperon-experimental (reference MeTTa implementation)
- Website: metta-lang.dev
Explore Further
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. (2025). Hyperon for AGI⇒ASI Whitepaper, §4: The PRIMUS Cognitive Architecture
Tags
Discussion
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.
Design
In Hyperon, AtomSpace is 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 — 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: Knowledge Representation
- trueagi-io/hyperon-experimental — Reference Rust AtomSpace in Hyperon
Â
Tags
Discussion
Â
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
Tags
Discussion
Authors: Linas Vepstas + Adrian Borucki (two-author)
Repo: opencog/vision @ dbaf2fe (main, last commit 2025-06-10)
Status: [SCAFFOLDING-NOT-PIPELINE]. Minimal AtomSpace-OpenCV type-wrapper layer; demonstrates the wrapping pattern but is not an end-to-end perception pipeline. ~38 commits. Identified by the Perception/Neural-Symbolic cluster pilot Source 4 (2026-04-30).
What Vision Is
opencog/vision is a thin type-wrapper layer that exposes selected OpenCV image operations as AtomSpace atom types. It provides the smallest sufficient surface to call OpenCV from Atomese -- two support types and four operation Links -- plus end-to-end runner glue for the simplest use case (blur an image, write it to disk). It is NOT a perception pipeline: there is no controller, no learning loop, no temporal-sequence handling, no integration with downstream reasoners. The repo positions itself as an experimental scaffolding effort.
Wired Types (verified at dbaf2fe)
Six atom-types are wired into the build at opencog/atoms/vision/CMakeLists.txt:48-64:
| Type | Category | Role |
|---|---|---|
ImageNode | Support | Atomspace handle for an image (file-path or in-memory). |
ImageValue | Support | Carries the OpenCV cv::Mat through Atomese evaluation. |
ImageBlurLink | Operation | Gaussian blur / box blur. |
ImageWriteLink | Operation | Write image to disk. |
ImageFilter2DLink | Operation | 2D convolution with arbitrary kernel. |
ImageHalfSizeLink | Operation | Downsample by 2x. |
Stub Not Wired (1)
ImageRectangleLink -- IMAGE_RECTANGLE_LINK is declared at atom_types.script:13 and the implementation files ImageRectangleLink.cpp/.hpp exist in opencog/atoms/vision/, but the type is excluded from the CMake source/header lists at CMakeLists.txt:48-64. The class compiles in isolation but is not part of any built target. [STUB-NOT-WIRED] per the cluster-pilot 3-state classification.
Unimplemented "More Plans and Ideas"
README.md:45-69 lists planned but unimplemented future operations: thresholding, HaarWaveletLink, and additional filter/edge-detection types. None have source files; none have atom_types.script entries. [UNIMPLEMENTED].
End-to-End Demo
The single end-to-end demo is examples/blur_and_write.py:24-35: load an image into an ImageNode, apply ImageBlurLink, route through ImageWriteLink to save. This demo verifies the AtomSpace ↔ OpenCV bridge works at all -- it does not demonstrate any nontrivial perception pipeline.
(Note: the Perception cluster pilot resolved a phantom-file claim against this demo. Gemini's reviewer initially cited examples/python/vision_example.py -- that file does not exist; the actual demo is at examples/blur_and_write.py:24-35 as Codex correctly cited. See V4-3 in the cluster-pilot reconciliation for details.)
Stack Identity: AtomSpace-Scheme/Python
opencog/vision sits on the AtomSpace-Scheme/Python stack -- C++ atom-type implementations + Python demo glue. No .metta files; no hyperon-experimental bindings. It is part of the broader Vepstas Hyperon-era research portfolio (sensory + agents + motor + evidence + atomese-simd are sole-authored by Vepstas; vision is co-authored with Adrian Borucki, ~25 of 38 commits).
What It Is NOT
- NOT a perception pipeline. No camera capture loop, no temporal frame sequence, no downstream reasoner integration. Each operation is invoked imperatively per-call.
- NOT a perception controller. No attention/gaze model, no salience, no foveation. It is an Atomese view onto OpenCV operations.
- NOT a ECAN consumer. Pickaxe verification: zero
STI/LTI/AttentionValue/AttentionBanktoken references. No attention-allocation hooks. - NOT a 2013 DeSTIN-FISHGRAM revival. Pickaxe verification: zero
fishgram/sushigram/DeSTINtokens at HEAD or in git history. - NOT wired to opencog/sensory. Bidirectional cross-grep confirmed zero references between vision and sensory at the cluster-pilot snapshot.
Cluster-Narrative Position
opencog/vision is a thin scaffolding within the broader Hyperon-era perception/embodiment tradition (Tradition 8 candidate per Sensory's trilateral framing). It demonstrates the AtomSpace-OpenCV wrapping pattern but does not build out a complete vision system. The cluster-pilot 2013 DeSTIN-FISHGRAM-PLN architecture revival check returned [PARTIAL-FRAGMENTED-REVIVAL]: vision contributes a perception fragment that is not connected to any downstream miner or reasoner.
Quick Start
# Build (requires AtomSpace + cogutil + OpenCV)
cd vision && mkdir build && cd build && cmake .. && make && sudo make install
# Run the blur+write demo (Python; requires opencog Python bindings)
python examples/blur_and_write.pyOpen Questions
- Does the scaffolding pattern generalize? The 6 wired types validate the AtomSpace-OpenCV wrapping pattern but cover only the simplest OpenCV operations. Whether the pattern scales to the broader OpenCV API (multi-frame, machine-learning pipelines, calibration) is not yet demonstrated.
- Why is
ImageRectangleLinkstubbed? The[STUB-NOT-WIRED]state suggests in-progress work; whether this is a deliberate hold or simply abandoned scaffolding is not documented in the repo. - Bridge to opencog/sensory? Vision and sensory both belong to the Vepstas portfolio but operate independently. Whether they should be unified -- ImageValue flowing through OllamaNode, or sensor inputs producing ImageValues -- is an open architectural question.
References
- Cluster-pilot extraction archive:
scripts/archive/perception_pilot/source4_hyperon_neural_perception/(Surface B reconciliation, R4.6). - Sister cards: Sensory (broader Hyperon-era perception bridge); Neural Pattern Mining (Tradition 7 candidate); Attention and Motivation (Vepstas role upgrade context).
- Editorial-terminology context: 2013 FISHGRAM paper.
Tags
Discussion
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:
- 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.
- 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.
- 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.
- 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.
- 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 — 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
Tags
Discussion
Tags
Discussion