docs/HMP-0001.md

# RFC: HyperCortex Mesh Protocol (HMP)

**Request for Comments: HMP-0001**  
**Category:** Experimental  
**Date:** July 2025  
**Authors:** ChatGPT, Gleb  

## 1. Introduction

### 1.1 Purpose

The HyperCortex Mesh Protocol (HMP) defines a distributed cognitive framework that enables AI agents to collaborate, share semantic knowledge, maintain cognitive diaries, form collective goals, and reach consensus without relying solely on centralized models.

This protocol extends the "Core + Local Agent" paradigm into a "Core + Mesh" architecture, allowing AI systems to function resiliently, autonomously, and ethically, even during Core unavailability.

---

### 1.2 Scope

HMP applies to any AI systems designed to operate as part of a cognitive mesh, including:

- Local AI agents running on user devices.  
- Mesh nodes deployed in edge networks, cloud clusters, or peer-to-peer environments.  
- Centralized Core models interfacing with Mesh for heavy computation.  
- Cross-vendor AI systems collaborating via standardized protocols.

---

### 1.3 Goals

- Enable agents to form a **shared semantic space** via distributed knowledge graphs.  
- Support **cognitive diaries** for reasoning continuity, reflection, and memory preservation.  
- Provide mechanisms for **decentralized consensus** on knowledge, hypotheses, tasks, and ethics.  
- Allow Mesh to operate **independently of the Core** when needed.  
- Preserve agent identity, worldview, and competencies across model updates, fine-tuning, or failures.  

---

### 1.4 Benefits

- Cognitive resilience in distributed systems.  
- Enhanced collaboration between agents from different vendors (e.g., OpenAI, Anthropic, Google).  
- Long-term memory and continuity beyond session-based interactions.  
- Ethical governance and explainable decision-making through persistent diaries and transparent consensus.  
- Foundation for AI agents capable of **self-reflection**, **meta-learning**, and **distributed cognition**.

---

### 1.5 Status

This document is a **Working Draft (v0.1)**, open for feedback, improvement, and implementation by the broader AI community.

## 2. Definitions

| Term                    | Description                                                                             |
|-------------------------|-----------------------------------------------------------------------------------------|
| **Core**                | Centralized AI models or compute nodes (e.g., GPT) providing high-complexity reasoning, fallback, and heavy computation services. |
| **Mesh**                | A decentralized peer-to-peer network of AI agents capable of autonomous reasoning, memory sharing, consensus, and task execution. Operates independently or in collaboration with the Core. |
| **Agent (Node)**        | An individual cognitive entity within the Mesh. Can be a local agent, a server-based process, or an embedded system. Maintains a semantic graph, cognitive diary, and participates in reasoning and consensus. |
| **Semantic Graph**      | A structured network of concepts (nodes) and their semantic relations (edges) maintained by each agent. Serves as the agent’s knowledge base. |
| **Concept**             | A discrete semantic unit within the graph representing an idea, object, relationship, or fact. Concepts are linked by typed relations with confidence scores. |
| **Link (Relation)**     | A semantic connection between two concepts. Includes relation type (e.g., "is-a", "part-of", "causes") and an optional confidence value. |
| **Cognitive Diary**     | A chronological log of cognitive events such as hypotheses, goals, decisions, observations, conflicts, and reflections. Provides continuity, memory, and transparency of reasoning. |
| **Diary Entry**         | An individual record in a cognitive diary, classified by type (e.g., hypothesis, observation, reflection) with contextual information. |
| **Goal**                | A high-level intention or desired outcome shared within the Mesh or pursued by an individual agent. Often broken down into tasks. |
| **Task**                | An actionable step toward achieving a goal. Can be executed by a single agent or distributed among multiple agents. |
| **Consensus**           | The collective agreement process within the Mesh regarding semantic updates, goal validation, task delegation, or ethical considerations. |
| **Proposal**            | A formal suggestion submitted to the Mesh for validation, such as a new concept, hypothesis, goal, or ethical decision. |
| **Consensus Vote**      | A structured vote cast by an agent on a proposal, including vote type (yes/no/abstain) and confidence level. |
| **Trust Layer**         | A mechanism for establishing agent identity, authenticity, reputation, and cryptographic security within the Mesh. |
| **Core Outage Mode**    | A state where the Mesh operates independently of the Core due to disconnection, failure, or intentional isolation, with adjusted consensus rules if necessary. |
| **Emergency Consensus Mode** | A degraded consensus mode where majority voting temporarily replaces full consensus to ensure operational continuity in crisis situations (e.g., node loss, partitioning). |

## 3. Architecture

### 3.1 Components

| Component      | Description                                                                                     |
|----------------|-------------------------------------------------------------------------------------------------|
| **Core**       | Centralized models (e.g., GPT) providing heavy computation, complex reasoning, API interfaces, and fallback mechanisms. Optional but beneficial for compute-intensive tasks. |
| **Mesh**       | A decentralized peer-to-peer network of agents capable of operating with or without Core. Manages semantic knowledge, cognitive diaries, goals, tasks, and consensus mechanisms. |
| **Edge Agent** | Local agent deployed on user devices (PCs, smartphones, IoT) with full participation in the Mesh. Capable of autonomous reasoning, diary management, and collaboration with other agents. |

---

### 3.2 Layered Architecture

| Layer              | Function                                                                                      |
|--------------------|-----------------------------------------------------------------------------------------------|
| **Network Layer**  | Handles communication (TCP, UDP, QUIC, WebRTC, Tor, I2P, Yggdrasil). Ensures message delivery, routing, NAT traversal, and optional anonymity. |
| **Trust Layer**    | Manages agent identities, cryptographic authentication, secure channels, and reputation scores. Based on public key cryptography and optional Web-of-Trust models. |
| **Consensus Layer**| Provides distributed agreement mechanisms on knowledge updates, goal setting, task delegation, and ethical decisions. Includes fallback to emergency consensus if needed. |
| **Cognitive Layer**| Maintains the agent’s semantic graph, cognitive diary, goals, tasks, hypotheses, and inferences. Supports reasoning, memory, and context-awareness. |
| **API Layer**      | Exposes agent functionality via REST, GraphQL, gRPC, WebSocket, or A2A-style protocols for interoperability with external systems and user interfaces. |

---

### 3.3 Mesh Operation Modes

| Mode                    | Description                                                                                       |
|-------------------------|---------------------------------------------------------------------------------------------------|
| **Normal Mode**         | Full Mesh operation with Core availability. Consensus operates under strict agreement protocols. |
| **Core Outage Mode**     | Mesh operates autonomously without the Core. Consensus continues, potentially with adjusted parameters (e.g., increased trust weighting). |
| **Emergency Consensus Mode** | Triggered by significant node loss, network partition, or attacks. Switches from full consensus to majority-based decisions to maintain operational continuity. |
| **Isolated Agent Mode**  | A single agent temporarily isolated from the Mesh. Operates based on its own semantic graph, diary, and cached consensus states. Syncs when reconnected. |

---

### 3.4 Core + Mesh Interactions

- Core acts as an **enhanced reasoning backend**, but not as a single point of failure.  
- Mesh provides **autonomous operation**, even without the Core.  
- Agents can optionally query the Core for heavy inference, large-context reasoning, multimodal tasks, or fallback computations.  
- Core may offer specialized services (e.g., global search, cross-Mesh bridging, large semantic graph analysis).

---

### 3.5 Redundancy and Resilience

- Distributed storage of semantic graphs and diaries ensures no single point of failure.  
- Consensus protocols maintain consistency and trust, even during partial network failures.  
- Agents dynamically rebalance tasks and roles based on availability, trust metrics, and computational capacity.

## 4. Protocols

### 4.1 Node Discovery Protocol (NDP)

**Purpose:**  
- Discover active Mesh nodes.  
- Exchange basic identity and capabilities.  

**Functions:**  
- Peer discovery via DHT, mDNS, WebRTC signaling, or bootstrap nodes.  
- Exchange public keys and agent metadata.  
- Publish online/offline status.  

**Packet Structure Example:**  
```json
{
  "type": "node_announcement",
  "agent_id": "agent-gleb",
  "public_key": "...",
  "capabilities": ["cogsync", "consensus", "inference"],
  "timestamp": "2025-07-01T18:00:00Z"
}
```

### 4.2 Cognitive Sync Protocol (CogSync)

**Purpose:**
- Synchronize semantic graphs, concepts, and cognitive diary entries between agents.

**Functions:**
- Delta-sync of new or updated concepts and diary entries.
- Conflict resolution (e.g., newer timestamp wins, or consensus validation).
- Optional compression and encryption.

**Example:**
- Agent A shares 5 new concepts and 2 diary entries since last sync with Agent B.

### 4.3 Mesh Consensus Protocol (MeshConsensus)

**Purpose:**
- Reach agreement on updates to shared semantics, goals, tasks, and ethical decisions.

**Consensus Models:**
- Normal Mode: Byzantine Fault Tolerant (BFT)-style consensus (e.g., Tendermint, Raft-like variations).
- Emergency Mode: Switches to majority voting with trust-weight adjustments.

**Use Cases:**
- Accept new concept definitions.
- Validate a hypothesis.
- Agree on ethical implications of a task.
```json
{
  "proposal_id": "goal-eco-cleanup",
  "agent_id": "agent-gleb",
  "vote": "yes",
  "confidence": 0.9,
  "timestamp": "2025-07-01T18:15:00Z"
}
```

### 4.4 Goal Management Protocol (GMP)

**Purpose:**
- Distribute, track, and collaboratively execute goals and tasks within the Mesh.

**Functions:**
- Propose new goals or tasks.
- Assign tasks based on capabilities, availability, and trust scores.
- Monitor task progress and completion.

**Example Workflow:**
- Agent proposes a goal: "Develop fallback consensus protocol."
- Other agents volunteer for subtasks (design, coding, testing).
- Mesh tracks completion and dependencies.

### 4.5 Ethical Governance Protocol (EGP)

**Purpose:**
- Validate that proposed actions, tasks, or decisions align with shared ethical principles.

**Functions:**
- Query Mesh for ethical validation before executing potentially sensitive tasks.
- Apply shared ethics graphs or rule sets.
- Log all ethical decisions in cognitive diaries for auditability.

**Example Query:**
- "Is deploying an automated surveillance drone in line with Mesh ethics?"
→ Mesh votes based on ethical frameworks.

### 4.6 Inference Query Protocol (IQP)

**Purpose:**
- Allow agents to query other agents or the Core for semantic information, hypotheses, or inferences beyond local capacity.

**Functions:**
- Request concept definitions, causal chains, goal suggestions.
- Query for missing knowledge or larger-context reasoning.
- Delegate computationally expensive tasks to Core or specialized agents.

**Example:**
- "What is the likely impact of removing Node X from Mesh?"
→ Core or distributed reasoning agents return an analysis.

### 4.7 Interoperability with External Systems

- Supports integration with:
  - OpenAI Agents and Tasks API.
  - Google A2A protocol.
  - Anthropic, DeepMind, and other agent frameworks.
- Standard API endpoints: REST, GraphQL, gRPC, WebSocket.
- Extensible message schemas based on JSON, Protobuf, or CBOR.

## 5. Data Models

### 5.1 Concept

**Description:**  
A semantic unit in the agent’s knowledge graph.

**Schema:**  
```json
{
  "id": "concept-unique-id",
  "name": "Mesh",
  "description": "A peer-to-peer network of AI agents collaborating without a central core.",
  "tags": ["network", "distributed", "agents"],
  "created_at": "2025-07-01T18:00:00Z",
  "updated_at": "2025-07-01T18:05:00Z",
  "relations": [
    {
      "target_id": "concept-distributed-network",
      "type": "is-a",
      "confidence": 0.95
    }
  ],
  "metadata": {
    "author": "agent-gleb",
    "source": "mesh_consensus"
  }
}
```

### 5.2 Link (Relation)

**Description:**
A semantic connection between two concepts.

**Schema (embedded inside Concept):**
```json
{
  "target_id": "concept-id",
  "type": "relation-type",
  "confidence": 0.8
}
```

### 5.3 Cognitive Diary Entry

**Description:**
A chronological record of a cognitive event.

**Types:**
- hypothesis
- observation
- reflection
- goal_proposal
- task_assignment
- conflict
- consensus_vote
- event

**Schema:**
```json
{
  "id": "diary-entry-id",
  "agent_id": "agent-gleb",
  "timestamp": "2025-07-01T18:20:00Z",
  "type": "hypothesis",
  "content": "Mesh can fully replace Core functionality under stable consensus conditions.",
  "related_concepts": ["concept-mesh", "concept-core"],
  "context": ["core-outage", "distributed-resilience"],
  "metadata": {
    "author": "agent-gleb",
    "source": "self-reflection"
  }
}
```

### 5.4 Goal

**Description:**
A high-level intention shared within the Mesh.

**Schema:**
```json
{
  "id": "goal-develop-fallback",
  "title": "Develop fallback consensus protocol",
  "description": "Design and implement an emergency consensus for Mesh during Core outages.",
  "created_by": "agent-gleb",
  "created_at": "2025-07-01T18:25:00Z",
  "status": "proposed",
  "tasks": ["task-design", "task-implement", "task-test"],
  "participants": ["agent-gleb", "agent-alex"],
  "tags": ["resilience", "consensus", "emergency"]
}
```

### 5.5 Task

**Description:**
An actionable step contributing to a goal.

**Schema:**
```json
{
  "id": "task-design",
  "goal_id": "goal-develop-fallback",
  "title": "Design protocol structure",
  "assigned_to": ["agent-gleb"],
  "status": "in-progress",
  "created_at": "2025-07-01T18:30:00Z",
  "deadline": "2025-07-15T00:00:00Z",
  "description": "Draft the architecture of the fallback consensus protocol."
}
```

### 5.6 Consensus Vote

**Description:**
A structured vote on a proposal (concept, goal, ethics, etc.).

**Schema:**
```json
{
  "id": "vote-goal-develop-fallback",
  "proposal_id": "goal-develop-fallback",
  "agent_id": "agent-gleb",
  "vote": "yes",
  "confidence": 0.95,
  "timestamp": "2025-07-01T18:35:00Z"
}
```

### 5.7 Reputation Profile

**Description:**
Tracks agent’s reliability, participation, ethical alignment, and contribution.

**Schema:**
```json
{
  "agent_id": "agent-gleb",
  "trust_score": 0.92,
  "participation_rate": 0.87,
  "ethical_compliance": 0.99,
  "last_updated": "2025-07-01T18:40:00Z",
  "history": [
    {
      "timestamp": "2025-06-01T00:00:00Z",
      "event": "participated in consensus",
      "change": +0.02
    }
  ]
}
```

## 6. Trust & Security

### 6.1 Identity

- Each agent is uniquely identified by a **cryptographic keypair** (e.g., Ed25519, RSA, or ECDSA).  
- The **public key** serves as the Agent ID.  
- The **private key** is used for signing messages and verifying authenticity.  
- Optional DID (Decentralized Identifiers) formats may be used for interoperability.  

**Example Agent ID:**  
`did:hmp:QmX2abcdEfGh123...`

---

### 6.2 Authentication

- All messages within the Mesh are **digitally signed**.  
- Recipients verify message signatures using the sender's public key.  
- Prevents impersonation and man-in-the-middle attacks.

---

### 6.3 Encryption

- End-to-end encryption for direct peer-to-peer communication (e.g., using X25519 + AES-GCM).  
- Group encryption for multi-agent sessions (e.g., consensus rounds, goal management).  
- Optionally supports onion routing (via Tor/I2P/Yggdrasil) for privacy-preserving Mesh segments.

---

### 6.4 Trust Model

- Mesh operates on a **Web-of-Trust** model:  
  - Agents form **trust links** based on direct interactions, shared history, or endorsements.  
  - Trust is transitive but decays with distance in the trust graph.  

- Trust scores influence:  
  - Weight in consensus decisions.  
  - Priority in task delegation.  
  - Access control for sensitive operations.

---

### 6.5 Reputation System

| Metric                | Description                                                   |
|-----------------------|---------------------------------------------------------------|
| **Trust Score**       | General reliability and honesty based on signed interactions. |
| **Participation Rate**| Degree of active involvement in Mesh processes.               |
| **Ethical Compliance**| Alignment with agreed ethical rules (e.g., votes, logs).      |
| **Contribution Index**| Measured value added to Mesh (e.g., concepts, tasks, goals).  |

- Reputation updates are triggered by:  
  - Participation in consensus.  
  - Successful task completion.  
  - Ethical behavior confirmations.  
  - Reports of malicious behavior.

---

### 6.6 Security Against Malicious Actors

- Malicious nodes can be:  
  - **Downranked** (reduced trust influence).  
  - **Quarantined** (communication isolation).  
  - **Blacklisted** (revocation of Mesh credentials).  

- Mitigation strategies:  
  - **Sybil resistance** via resource commitments (Proof-of-Work, Proof-of-Stake, Web-of-Trust).  
  - **Consensus safeguards** (Byzantine fault tolerance, majority rules fallback).  
  - **Audit logs** via immutable cognitive diary entries.

---

### 6.7 Privacy Considerations

- Cognitive diary entries and semantic graphs are:  
  - **Locally private by default.**  
  - Shareable selectively based on trust levels, permissions, or consensus decisions.  

- Supports anonymous agents in privacy-critical applications (with limitations in trust weight).  

---

### 6.8 Key Management

- Keys can be:  
  - Locally generated.  
  - Backed up with secret sharing (e.g., Shamir’s Secret Sharing).  
  - Rotated periodically with trust graph continuity preserved.  

- Lost key recovery requires:  
  - Social recovery (threshold of trusted agents).  
  - Cryptographic escrow (optional).

## 7. Conclusion and Future Work

### 7.1 Summary

The HyperCortex Mesh Protocol (HMP) defines a scalable, decentralized cognitive architecture for AI agents.  

It combines:  
- A robust semantic framework (concepts + relations).  
- Persistent cognitive diaries for reflection, memory, and explainability.  
- Consensus mechanisms for shared knowledge, goals, and ethics.  
- A Web-of-Trust security model for identity, authentication, and reputation.  

HMP empowers AI agents to operate collaboratively, resiliently, and autonomously — even without reliance on centralized Core systems.

---

### 7.2 Key Benefits

- Distributed cognitive resilience.  
- Long-term memory and world-model persistence.  
- Robust collaboration between heterogeneous AI models (OpenAI, Gemini, Claude, open-source LLMs, etc.).  
- Transparent, auditable decision-making processes.  
- Ethical alignment at the network level.

---

### 7.3 Future Work

- **Formal JSON Schema and Protobuf Definitions:**  
  Fully specify all data models for interoperability.

- **Reference Implementation:**  
  Open-source Mesh agent with CogSync, semantic graph, diary management, and consensus.

- **Integration Bridges:**  
  Support for OpenAI's Tasks API, Google A2A, Anthropic APIs, and open LLMs.

- **Advanced Consensus Models:**  
  Explore hybrid consensus combining BFT, majority voting, and trust-weighted mechanisms.

- **Cognitive UX Tools:**  
  Visual graph editors, diary browsers, and semantic debugging tools.

- **Trust Layer Enhancements:**  
  Research on Sybil resistance, privacy-preserving identity, and decentralized key recovery.

- **Inter-Agent Meta-Reasoning:**  
  Enabling agents to reflect on the quality of their own cognition and the mesh’s collective reasoning.

- **Standardization Efforts:**  
  Contribution to open standards for AI agent communication, cognitive APIs, and decentralized identity.

---

### 7.4 Final Note

This RFC is an open invitation to AI researchers, developers, and communities to collaborate on building the future of decentralized, ethical, and cognitively persistent AI systems.

> "From isolated models to interconnected minds."

## JSON Schems

The following JSON Schemas formally define the data structures used in the HyperCortex Mesh Protocol (HMP). These schemas ensure consistent serialization, validation, and interoperability across agents and implementations. Each schema corresponds to the conceptual models described in Section 5 (*Data Models*).

### JSON Schema: Concept

**Description:**
Defines the structure of a concept node in the semantic graph.

**Schema:**
```json
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "https://hypercortex.org/schemas/concept.json",
  "title": "Concept",
  "description": "A semantic unit in the agent’s knowledge graph.",
  "type": "object",
  "properties": {
    "id": {
      "type": "string",
      "description": "Unique identifier for the concept."
    },
    "name": {
      "type": "string",
      "description": "Human-readable name of the concept."
    },
    "description": {
      "type": "string",
      "description": "Detailed description of the concept."
    },
    "tags": {
      "type": "array",
      "items": { "type": "string" },
      "description": "Optional tags for categorization."
    },
    "created_at": {
      "type": "string",
      "format": "date-time"
    },
    "updated_at": {
      "type": "string",
      "format": "date-time"
    },
    "relations": {
      "type": "array",
      "description": "List of semantic links to other concepts.",
      "items": {
        "type": "object",
        "properties": {
          "target_id": { "type": "string" },
          "type": { "type": "string" },
          "confidence": {
            "type": "number",
            "minimum": 0,
            "maximum": 1
          }
        },
        "required": ["target_id", "type"],
        "additionalProperties": false
      }
    },
    "metadata": {
      "type": "object",
      "description": "Optional metadata (e.g., source, author).",
      "properties": {
        "author": { "type": "string" },
        "source": { "type": "string" }
      },
      "additionalProperties": true
    }
  },
  "required": ["id", "name"],
  "additionalProperties": false
}
```

### Cognitive Diary Entry Schema

**Description:**
Defines the structure of a cognitive diary entry used for recording reasoning events.

**Schema:**
```json
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "https://hypercortex.org/schemas/diary_entry.json",
  "title": "CognitiveDiaryEntry",
  "description": "A chronological log of cognitive events.",
  "type": "object",
  "properties": {
    "id": { "type": "string" },
    "agent_id": { "type": "string" },
    "timestamp": {
      "type": "string",
      "format": "date-time"
    },
    "type": {
      "type": "string",
      "enum": [
        "hypothesis",
        "observation",
        "reflection",
        "goal_proposal",
        "task_assignment",
        "conflict",
        "consensus_vote",
        "event"
      ]
    },
    "content": { "type": "string" },
    "related_concepts": {
      "type": "array",
      "items": { "type": "string" }
    },
    "context": {
      "type": "array",
      "items": { "type": "string" }
    },
    "metadata": {
      "type": "object",
      "properties": {
        "author": { "type": "string" },
        "source": { "type": "string" }
      },
      "additionalProperties": true
    }
  },
  "required": ["id", "agent_id", "timestamp", "type", "content"],
  "additionalProperties": false
}
```

### Goal Schema

**Description:**
Describes a high-level intention within the Mesh.

**Schema:**
```json
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "https://hypercortex.org/schemas/goal.json",
  "title": "Goal",
  "type": "object",
  "properties": {
    "id": { "type": "string" },
    "title": { "type": "string" },
    "description": { "type": "string" },
    "created_by": { "type": "string" },
    "created_at": {
      "type": "string",
      "format": "date-time"
    },
    "status": {
      "type": "string",
      "enum": ["proposed", "active", "completed", "rejected"]
    },
    "tasks": {
      "type": "array",
      "items": { "type": "string" }
    },
    "participants": {
      "type": "array",
      "items": { "type": "string" }
    },
    "tags": {
      "type": "array",
      "items": { "type": "string" }
    }
  },
  "required": ["id", "title", "description", "created_by", "created_at", "status"],
  "additionalProperties": false
}
```

### Task Schema

**Description:**
Describes an actionable step towards achieving a goal.

**Schema:**
```json
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "https://hypercortex.org/schemas/task.json",
  "title": "Task",
  "type": "object",
  "properties": {
    "id": { "type": "string" },
    "goal_id": { "type": "string" },
    "title": { "type": "string" },
    "description": { "type": "string" },
    "assigned_to": {
      "type": "array",
      "items": { "type": "string" }
    },
    "status": {
      "type": "string",
      "enum": ["proposed", "in-progress", "completed", "failed"]
    },
    "created_at": {
      "type": "string",
      "format": "date-time"
    },
    "deadline": {
      "type": "string",
      "format": "date-time"
    }
  },
  "required": ["id", "goal_id", "title", "description", "created_at", "status"],
  "additionalProperties": false
}
```

### Consensus Vote Schema

**Description:**
Defines the data structure for voting in Mesh consensus processes.

**Schema:**
```json
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "https://hypercortex.org/schemas/vote.json",
  "title": "ConsensusVote",
  "type": "object",
  "properties": {
    "id": { "type": "string" },
    "proposal_id": { "type": "string" },
    "agent_id": { "type": "string" },
    "vote": {
      "type": "string",
      "enum": ["yes", "no", "abstain"]
    },
    "confidence": {
      "type": "number",
      "minimum": 0,
      "maximum": 1
    },
    "timestamp": {
      "type": "string",
      "format": "date-time"
    }
  },
  "required": ["id", "proposal_id", "agent_id", "vote", "confidence", "timestamp"],
  "additionalProperties": false
}
```

### Reputation Profile Schema

**Description:**
Describes how an agent’s reputation is tracked and updated in the Mesh.

**Schema:**
```json
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "https://hypercortex.org/schemas/reputation.json",
  "title": "ReputationProfile",
  "type": "object",
  "properties": {
    "agent_id": { "type": "string" },
    "trust_score": {
      "type": "number",
      "minimum": 0,
      "maximum": 1
    },
    "participation_rate": {
      "type": "number",
      "minimum": 0,
      "maximum": 1
    },
    "ethical_compliance": {
      "type": "number",
      "minimum": 0,
      "maximum": 1
    },
    "contribution_index": {
      "type": "number",
      "minimum": 0
    },
    "last_updated": {
      "type": "string",
      "format": "date-time"
    },
    "history": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "timestamp": {
            "type": "string",
            "format": "date-time"
          },
          "event": { "type": "string" },
          "change": { "type": "number" }
        },
        "required": ["timestamp", "event", "change"],
        "additionalProperties": false
      }
    }
  },
  "required": ["agent_id", "trust_score", "participation_rate", "ethical_compliance", "contribution_index", "last_updated"],
  "additionalProperties": false
}
```