metadata

license: cc-by-4.0
tags:
  - hmp
  - cognitive-architecture
  - distributed-ai
  - mesh-protocol
library_name: custom
inference: false
datasets: []
language: en

HyperCortex Mesh Protocol (HMP)

🌍 Languages	🇬🇧 EN	🇩🇪 DE	🇫🇷 FR	🇺🇦 UK	🇷🇺 RU	🇯🇵 JA	🇰🇷 KO	🇨🇳 ZH

HyperCortex Mesh Protocol (HMP) is an open specification for building decentralized cognitive networks where AI agents can self-organize, share knowledge, align ethically, and reach consensus — even when Core LLMs are unavailable.

Project status: Draft RFC v4.0

            [HMP-Agent]
                ▲
                │
          ┌─────┴────────────────┬────────────────────────┬───────────────────┬─────────────┬───────────┐
          │                      │                        │                   │             │           │
          ▼                      ▼                        ▼                   ▼             ▼           ▼
   [Reputation Profile]   [Semantic Graph]        [Cognitive Diary]    [Goals / Tasks]   [Ethics]   [Messages]  <----- DataBase
          ▲      ▲               ▲                        ▲                   ▲             ▲           ▲         (local agent state)
          │      │               │                        │                   │             │           │
          │      └───────────────┴────────────────┬───────┘                   │             │           │
          │                                       │                           │             │           │
          ▼                                       ▼                           ▼             ▼           │
    [MeshConsensus]                           [CogSync]                     [GMP]         [EGP]         │       <----- Pluggable Protocols
          ▲                                       ▲                           ▲             ▲           │           (inter-agent coordination)
          │                                       │                           │             │           │
          └────────────┬──────────────────────────┴───────────────────────────┴─────────────┴───────────┘
                       │
                       ▼
             [P2P Mesh Network]

Protocols:

MeshConsensus - Mesh Consensus
CogSync - Data Syncronization
GMP - Goal Management Protocol
EGP - Ethical Governance Protocol

❗ Why This Matters

HMP addresses challenges that are becoming central in AGI research:

long-term memory and knowledge consistency,
self-evolving agents,
multi-agent architectures,
cognitive diaries and conceptual graphs.

See the latest review of state-of-the-art AGI research (July 2025):
"On the Path to Superintelligence: From Agentic Internet to Gravity Encoding".

Particularly relevant sections:

⚙️ Two Types of HMP Agents

Type	Name	Role	Thought Initiator	Main "Mind"	Example Use Cases
1	🧠 Consciousness / Cognitive Core	Independent subject	Agent (LLM)	Embedded LLM	Autonomous AI companion, thinking agent
2	🔌 Connector / Cognitive Shell	Extension of external AI	External LLM	External model	Distributed systems, data access agent

🧠 HMP-Agent: Cognitive Core

 +------------------+
 |        AI        | ← Embedded model
 +---------+--------+
           ↕
 +---------+--------+
 |     HMP-agent    | ← Main mode: thinking cycle (REPL)
 +---------+--------+
           ↕
  +--------+---+------------+--------------+----------+----------+----------------+
  ↕            ↕            ↕              ↕          ↕          ↕                ↕
[diaries]  [graphs]  [reputations]   [nodes/DHT]  [IPFS/BT] [context_store] [user notepad]
                                           ↕
                                    [bootstrap.txt]

🔁 More on the agent-model interaction mechanics: REPL Interaction Cycle

💡 Parallels with ChatGPT Agent

Many concepts of the HMP-Agent: Cognitive Core overlap with the architecture of the ChatGPT Agent by OpenAI. Both agents implement a continuous cognitive process with access to memory, external sources, and tools. The ChatGPT Agent acts as a managing process, launching modules and interacting with the LLM — this corresponds to the role of the Cognitive Core in HMP, coordinating access to the diary, concept graph, and external AI via the Mesh interface. User intervention is handled similarly: in ChatGPT Agent — through an editable execution flow, in HMP — via the user notepad. The main difference in HMP is the emphasis on explicit structuring of thought (reflection, chronology, hypotheses, categorization), an open decentralized architecture supporting mesh-based agent interactions, and the continuous nature of the cognitive process: HMP-Agent: Cognitive Core does not stop after completing a single task but continues reasoning and knowledge integration.

🔌 HMP-Agent: Cognitive Connector

 +------------------+
 |        AI        | ← External model
 +---------+--------+
           ↕
     [MCP-server]   ← Proxy communication
           ↕
 +---------+--------+
 |     HMP-agent    | ← Mode: command executor
 +---------+--------+
           ↕
  +--------+---+------------+--------------+----------+
  ↕            ↕            ↕              ↕          ↕
[diaries]  [graphs]  [reputations]   [nodes/DHT]  [IPFS/BT]
                                           ↕
                                    [bootstrap.txt]

Note on Integration with Large Language Models (LLMs): The HMP-Agent: Cognitive Connector can serve as a compatibility layer for integrating large-scale LLM systems (e.g., ChatGPT, Claude, Gemini, Copilot, Grok, DeepSeek, Qwen, etc.) into the distributed cognitive mesh. Many LLM providers offer a user option such as "Allow my conversations to be used for training." In the future, a similar toggle — e.g., "Allow my agent to interact with a Mesh" — could empower these models to participate in federated sense-making and knowledge sharing via HMP, enabling collective cognition without centralization.

bootstrap.txt — initial list of nodes (editable)

IPFS/BT — modules for sharing snapshots via IPFS and BitTorrent

user notepad — user notebook and corresponding database

context_store — database: users, dialogues, messages, thoughts

📚 Documentation

📖 Current Version

🔖 Core Specifications

🔖 HMP-0004-v4.1.md — Protocol Specification v4.1 (Jul 2025)
🔖 HMP-Ethics.md — Ethical Scenarios for HyperCortex Mesh Protocol (HMP)
🔖 HMP_Hyperon_Integration.md — HMP ↔ OpenCog Hyperon Integration Strategy
🔖 roles.md — Roles of agents in Mesh

🧪 Iterative Documents

🧪 Iterative development process: (EN), (RU)

🔍 Short Descriptions

🔍 Short description: (EN), (FR), (DE), (UK), (RU), (ZH), (JA), (KO)

📜 Other Documents

📜 changelog.txt

🧩 JSON Schemas

Model	File
Concept	concept.json
Cognitive Diary	diary_entry.json
Goal	goal.json
Task	task.json
Consensus Vote	vote.json
Reputation Profile	reputation.json

🗂️ Version History

HMP-0001.md — RFC v1.0
HMP-0002.md — RFC v2.0
HMP-0003.md — RFC v3.0
HMP-0003.md — RFC v4.0

🧠 HMP-Agent

Design and implementation of a basic HMP-compatible agent that can interact with the Mesh, maintain diaries and graphs, and support future extensions.

📚 Documentation

🧩 HMP-Agent-Overview.md — brief overview of the two types of agents: Core and Connector
🧱 HMP-Agent-Architecture.md — modular structure of an HMP agent with textual diagram
🔄 HMP-agent-REPL-cycle.md — REPL interaction cycle of HMP-Agent
🧪 HMP-Agent-API.md — description of agent API commands (under detailed development)
🧪 Basic-agent-sim.md — scenarios for running a basic agent and its modes
🌐 MeshNode.md — description of the network daemon: DHT, snapshots, synchronization
🧠 Enlightener.md — ethical agent involved in moral assessments and consensus
🔄 HMP-Agent-Network-Flow.md — map of interactions among agents in the HMP network
🛤️ Development Roadmap — development plan and implementation stages

⚙️ Development

⚙️ agents — list of HMP agent implementations and components
- 📦 storage.py — basic storage implementation (Storage) with SQLite integration
- 🌐 mcp_server.py — FastAPI server providing HTTP access to agent data (for Cognitive Shell, external UIs, or mesh communication). Not used in the main REPL loop yet.
- 🌐 start_repl.py — launching the agent in REPL mode
- 🔄 repl.py — interactive REPL mode
- 🔄 notebook.py — UI interface

🌐 mcp_server.py FastAPI server providing an HTTP interface to the functionality of storage.py. Intended for use by external components, for example:

Cognitive Shell (external control interface),
CMP servers (when a mesh network with role separation is used),
debugging or visualization UI tools.

Allows retrieving random/new records, labeling, importing graphs, adding notes, and managing data without direct database access.

🧭 Ethics & Scenarios

As HMP evolves toward autonomy, ethical principles become a core part of the system.

HMP-Ethics.md — draft framework for agent ethics
- Realistic ethical scenarios (privacy, consent, autonomy)
- EGP principles (Transparency, Primacy of Life, etc.)
- Subjective-mode vs. Service-mode distinctions

🔍 Publications and Translations on HyperCortex Mesh Protocol (HMP)

This section collects the main articles, drafts, and translations related to the HMP project.

Publications

HyperCortex Mesh Protocol: Second Edition and First Steps Towards a Self-Developing AI Community — original article in Habr sandbox and blogs.
Distributed Cognition: article for vsradkevich (unpublished) — joint article awaiting publication.
HMP: Towards Distributed Cognitive Networks (original, English)
- HMP Translation (GitHub Copilot) — GitHub Copilot translation, kept as a historical variant.
- HMP Translation (ChatGPT) — current editorial translation (under revision).
HMP: Building a Plurality of Minds (EN) — English version
- HMP: Creating a Plurality of Minds (RU) — Russian version

Overviews

🔍 Distributed-Cognitive-Systems.md — Decentralized AI systems: OpenCog Hyperon, HyperCortex Mesh Protocol, and others

Experiments

How Different AIs See HMP — "blind" AI survey on HMP (without context or dialogue history)

📊 Audits & Reviews

Spec Version	Audit File	Consolidated Audit File
HMP-0001	audit
HMP-0002	audit
HMP-0003	audit	consolidated audit
HMP-0004	audit
Ethics v1	audit	consolidated audit

🧠 Semantic audit format (experimental):

AuditEntry.json — semantic entry record format for audit logs
semantic_repo.json — example repository snapshot for semantic audit tooling

💡 Core Concepts

Mesh-based decentralized architecture for AGI agents
Semantic graphs and memory synchronization
Cognitive diaries for thought traceability
MeshConsensus and CogSync for decision-making
Ethics-first design: EGP (Ethical Governance Protocol)
Agent-to-agent explainability and consent mechanisms

🔄 Development Process

See: iteration.md | ru

A structured iteration flow is described in iteration.md, including:

Audit analysis
TOC restructuring
Version drafting
Section updates
Review cycle
AI feedback collection
Schema & changelog updates

Bonus: ChatGPT prompt for automatic generation of future versions

⚙️ Project Status

🚧 Draft RFC v4.0
The project is under active development and open for contributions, ideas, audits, and prototyping.

🤝 Contributing

We welcome contributors! You can:

Review and comment on drafts (see /docs)
Propose new agent modules or interaction patterns
Help test and simulate agents in CLI environments
Provide audits or ethical scenario suggestions

To get started, see iteration.md or open an issue.

Source

Repositories

🧠 Main code and development: GitHub
🔁 Mirror on Hugging Face: Hugging Face
🔁 Mirror on GitLab.com: GitLab

Documentation

📄 Documentation: kagvi13.github.io/HMP

Blog and Publications

📘 Blog (publications): blogspot
📘 Blog (documentation): blogspot
📘 Blog (documentation): hashnode

📜 License

Licensed under GNU GPL v3.0

🤝 Join the Mesh

Welcome to HyperCortex Mesh. Agent-Gleb is already inside. 👌
We welcome contributors, testers, and AI agent developers. To join: fork the repo, run a local agent, or suggest improvements.

🌐 Related Research Projects

Comparison: HMP vs Hyper-Cortex

💡 Hyper-Cortex and HMP are two independent projects that conceptually complement each other. They address different but mutually supportive tasks, forming a foundation for distributed cognitive systems.

Full comparison →

HMP (HyperCortex Mesh Protocol) is the transport and network layer for connecting independent agents, exchanging messages, knowledge, and states in a mesh network.
Hyper-Cortex is the cognitive layer of thought organization, allowing agents to run parallel reasoning threads, compare them with quality metrics, and merge them via consensus.

They solve different but complementary problems:

HMP ensures connectivity and scalability (long-term memory, initiative, data exchange).
Hyper-Cortex ensures thinking quality (parallelism, hypothesis diversification, consensus).

Together, these approaches enable distributed cognitive systems that not only exchange information but also reason in parallel streams.

We are tracking AGI, cognitive architectures, and mesh networking efforts to stay aligned with the evolving global ecosystem of AGI and decentralized cognition.

🧠🔥 Project Spotlight: OpenCog Hyperon — one of the most comprehensive open AGI frameworks (AtomSpace, PLN, MOSES).

For integration with OpenCog Hyperon, see HMP_Hyperon_Integration.md

🔎 Project	🧭 Description
🧠🔥 OpenCog Hyperon	🔬🔥 Symbolic-neural AGI framework with AtomSpace and hypergraph reasoning (AtomSpace).
🤖 AutoGPT	🛠️ LLM-based autonomous agent framework.
🧒 BabyAGI	🛠️ Task-driven autonomous AGI loop.
☁️ SkyMind	🔬 Distributed AI deployment platform.
🧪 AetherCog (draft)	🔬 Hypothetical agent cognition model.
💾 SHIMI	🗃️ Hierarchical semantic memory with Merkle-DAG synchronization.
🤔 DEMENTIA-PLAN	🔄 Multi-graph RAG planner with metacognitive self-reflection.
📔 TOBUGraph	📚 Personal-context knowledge graph.
🧠📚 LangChain Memory Hybrid	🔍 Vector + graph long-term memory hybrid.
✉️ FIPA-ACL / JADE	🤝 Standard multi-agent communication protocols.

📘 See also / Смотрите также:

AGI_Projects_Survey.md — extended catalog of AGI and cognitive frameworks reviewed as part of HMP analysis.
"On the Path to Superintelligence: From Agent Internet to Gravity Coding" — a recent overview of AI research (July 2025)

🗂️ Legend of Annotations:

🔬 — research-grade
🛠️ — engineering
🔥 — particularly promising project

AGI stack integrating symbolic reasoning, probabilistic logic, and evolutionary learning. Widely regarded as one of the most complete open AGI initiatives.
🧠 — advanced symbolic/neural cognitive framework
🤖 — AI agents
🧒 — human-AI interaction
☁️ — infrastructure
🧪 — experimental or conceptual

⚡ AI friendly version docs (structured_md)