HyperContext (HC) Standard

Overview

HyperContext (HC) is an open standard for creating portable AI context that works across all LLM platforms. It enables Recursive Context Injection (RCI) - where outputs become inputs, creating compound learning effects.

The Core Idea

"The Web is built on Hypertext (Links). The AI Web is built on HyperContext (Links + Brains)."

Every HC file is simultaneously a document humans can read AND instructions AI can execute. Context compounds automatically through the Neural Registry, creating self-improving knowledge graphs.

Key Benefits

Portable: Works across Claude, ChatGPT, Gemini, and any LLM with web_fetch
Zero Lock-In: You own files, host anywhere (GDrive, Dropbox, GitHub, etc.)
Self-Improving: Quality compounds through RCI automatically
Token Efficient: Lazy loading saves 96% of context costs
Self-Executing: NEW in v1.1 Skills become applications
Validated: NEW in v1.1 Integrity hashes enable caching

Use Cases

Skills: Reusable AI transformations (content generation, formatting, analysis)
Neural Registry: Personal knowledge graph that grows smarter over time
Voice Consistency: Outputs match your style automatically through RCI
Team Knowledge: Shared context across team members
Expert Systems: Package domain expertise as HC-compliant skills

💡 Quick Example: After creating 10 newsletters with HC skills, the 11th newsletter automatically matches your voice, structure, and quality standards without manual instruction. That's RCI.

What's New in v1.1

1. Split Machine-Readable Blocks NEW

Cleaner separation between public metadata (SEO) and agent contract (operational):

<!-- SEO/Public (Schema.org) -->
<script type="application/ld+json">
{...Schema.org for crawlers}
</script>

<!-- Agent Contract (NEW in v1.1) -->
<script type="application/json" id="hc-metadata">
{
  "hc_version": "1.1",
  "hc_type": "skill",
  "content_hash": "sha256:...",
  "metadata_hash": "sha256:...",
  ...pure operational metadata
}
</script>

2. Canonical 5 Types NEW

Standardized to exactly 5 types for reliable routing:

Type	Purpose	Examples
`registry`	Neural Registry routers/indexes	dashboard.html, catalog.html
`skill`	Single-purpose transformations	newsletter-writer, toc-generator
`artifact`	Generated outputs/content	newsletters, landing pages, reports
`identity`	Voice/style context	identity-jason.html
`framework`	Methodologies/specifications	GOLDEN, SHARP, this document

3. Fetchable Registry Manifest NEW

Registries now serve dual formats for token optimization:

https://ideas.asapai.net → Full HTML (humans + agents)
https://ideas.asapai.net/registry.json → Pure JSON (agents only)

Token savings: ~100 tokens (JSON) vs ~5,000 tokens (HTML) = 98% reduction

4. Self-Executing Agent Architecture NEW

Skills can now execute themselves via embedded agent config:

<!-- Agent Config -->
<script type="application/json" id="mastery-agent-config">
{
  "agent_id": "skill-newsletter-writer-v1",
  "execution_mode": "interactive",
  "requires_approval": true,
  "neural_registry_optional": true
}
</script>

<!-- Agent Knowledge -->
<template id="mastery-agent-knowledge">
---
skill_purpose: Write newsletters in user's voice
inputs_required: [topic, key_points]
quality_gates: [...]
---
</template>

Result: Skills shift from "instructions to copy" → "applications to execute"

🎯 This is the moat. Not the HTML format. The self-execution model. Nobody else is doing this.

5. Integrity & Change Detection NEW

Every HC v1.1 file includes integrity hashes:

content_hash - SHA-256 of human-visible content
metadata_hash - SHA-256 of hc-metadata block

Enables:

Safe caching: "Hash matches? Use cached version"
Change detection: "Metadata changed? Re-fetch"
Temporal reasoning: "What versions existed when?"
Drift alerts: "Skill changed since last use"

Backward Compatibility

✅ HC v1.0 files still work. New agents handle both versions. Migration is additive - keep existing blocks, add new ones. No breaking changes.

The Three Laws of HyperContext

These fundamental principles define what makes a file HC-compliant:

Law 1: Container Law

Every HC file MUST be valid HTML5

Renders in any modern browser
Viewable by humans without LLM
Professional appearance
Accessible documentation

Law 2: Hidden Brain Law

Every HC file MUST contain embedded LLM instructions

JSON metadata for agent contract
Hidden script with instructions
LLM can extract and execute
Works without browser execution

Law 3: Linkage Law

Every HC file MUST support referencing and being referenced

Can reference Neural Registry
Produces HC-compliant outputs
Linkable by future HC files
Enables RCI compound learning

⚠️ Critical: All three laws must be satisfied for HC compliance. Missing any one disqualifies a file from the standard.

Complete File Structure

Required Blocks (v1.1)

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>[Title]</title>
    
    <!-- 1. SEO/Public (Schema.org) -->
    <script type="application/ld+json">
    {...Schema.org metadata}
    </script>
    
    <!-- 2. Agent Contract (NEW v1.1 - REQUIRED) -->
    <script type="application/json" id="hc-metadata">
    {
        "hc_version": "1.1",
        "hc_type": "skill|artifact|registry|identity|framework",
        "artifact_id": "unique-id",
        "version": "semver",
        "content_hash": "sha256:...",
        "metadata_hash": "sha256:...",
        "created": "ISO 8601",
        "updated": "ISO 8601",
        ...
    }
    </script>
    
    <!-- 3. Human Metadata (OPTIONAL) -->
    <script type="text/yaml" id="hc-frontmatter">
    ---
    Human-readable YAML
    ---
    </script>
    
    <!-- 4. Self-Execution Config (Skills only - NEW v1.1) -->
    <script type="application/json" id="mastery-agent-config">
    {
        "agent_id": "...",
        "execution_mode": "interactive|autonomous",
        "requires_approval": true|false
    }
    </script>
    
    <!-- 5. Self-Execution Knowledge (Skills only - NEW v1.1) -->
    <template id="mastery-agent-knowledge">
    ---
    YAML knowledge manifest
    ---
    </template>
    
    <!-- 6. Python Helpers (OPTIONAL) -->
    <script type="text/python" id="hc-python">
    # Python code
    </script>
    
    <style>/* CSS */</style>
</head>
<body>
    <!-- 7. LLM Instructions (REQUIRED) -->
    <script type="text/plain" id="hc-instructions">
    # Instructions for LLM execution
    </script>
    
    <!-- 8. Human Documentation (REQUIRED) -->
    <div id="hc-human-docs">
        [Visible documentation]
    </div>
</body>
</html>

Block Purposes

Block	Required?	Purpose	Who Uses
Schema.org JSON-LD	REQUIRED	SEO, discovery, validation	Search engines, browsers
hc-metadata JSON	REQUIRED v1.1	Agent operational contract	LLMs, agents
hc-frontmatter YAML	OPTIONAL	Human-readable metadata	Humans, doc generators
mastery-agent-config	OPTIONAL v1.1	Self-execution parameters	Embedded agents (skills only)
mastery-agent-knowledge	OPTIONAL v1.1	Skill-specific knowledge	Embedded agents (skills only)
hc-python	OPTIONAL	Automation helpers	Code Execution sandbox
hc-instructions	REQUIRED	Step-by-step LLM logic	LLMs for manual execution
hc-human-docs	REQUIRED	Visible documentation	Humans browsing in browser

File Naming Convention

[type]-[slug]-v[version].html

Examples:

skill-newsletter-writer-v1.html
artifact-newsletter-001-v2.html
identity-jason-macdonald-v1.html
framework-golden-v1.html
registry-dashboard-v1.html

Rules:

Lowercase only
Hyphens for spaces (no underscores)
Version number always included
Type prefix for categorization

Canonical Types NEW in v1.1

HC v1.1 defines exactly 5 canonical types to prevent type sprawl and enable reliable routing:

🗂️ registry

Neural Registry routers and indexes

Contains artifact catalog
Routes to relevant context
Dual format (HTML + JSON)
Human dashboard interface

Examples: dashboard.html, catalog.html

⚙️ skill

Single-purpose transformation tools

Accepts input
Performs transformation
Outputs HC artifact
Can self-execute (v1.1)

Examples: newsletter-writer, toc-generator

📄 artifact

Generated outputs and content

Result of skill execution
References parent artifacts
Referenceable by future skills
Enables RCI

Examples: newsletters, landing pages, reports

👤 identity

Voice and style context

Defines user's voice/tone
Lists preferred frameworks
Style guidelines
Applied throughout session

Examples: identity-jason.html

📚 framework

Methodologies and specifications

Complete methodology docs
Standards and specs
Educational content
Reference materials

Examples: GOLDEN, SHARP, this document

⚠️ No Custom Types: Use these 5 types only. Subtypes can be specified in classification.subcategory field, but hc_type must be one of the canonical 5.

Type Selection Guide

If you're creating...	Use type...
A tool that generates content	`skill`
Content generated by a skill	`artifact`
Index of your artifacts	`registry`
Your personal voice/style guide	`identity`
Documentation of a methodology	`framework`

Neural Registry Protocol

The Neural Registry is the semantic router for your knowledge graph. It indexes all artifacts and enables intelligent context loading through lazy loading and relevance scoring.

Dual Format Architecture NEW in v1.1

Registries now serve two formats:

Format	URL Pattern	Tokens	Use Case
HTML	`https://ideas.asapai.net`	~5,000	Human browsing + full agent context
JSON	`https://ideas.asapai.net/registry.json`	~100	Agent catalog scan only (98% savings)

Discovery & Loading Protocol

Phase 1: Registry Discovery

Skill asks: "Load your Neural Registry?"
User provides: Registry URL
Agent fetches: /registry.json OR full HTML
Agent parses: Artifact catalog JSON

Phase 2: Identity Loading (Optional)

If identity_url present: Fetch identity
Parse: Voice, frameworks, style
Apply: To all outputs in session

Phase 3: Artifact Discovery

Calculate relevance score (1-10) for each artifact
Factors: Tag matching, type matching, recency, quality
Sort by relevance DESC
Present top 3-5 to user

Phase 4: User Confirmation (MANDATORY)

Found 3 relevant artifacts:

1. Newsletter Growth Tactics (relevance: 8.5/10)
   Type: newsletter | Created: Feb 1, 2026
   Tags: growth, clinic, 3-2-1
   Summary: Newsletter strategies for clinics using 3-2-1 method
   
2. Email Engagement Framework (relevance: 7.2/10)
   ...

Load for context?
- 'all' - Load all 3
- 'select [1,3]' - Load specific
- 'none' - Continue without
- 'different' - Show different artifacts

Your choice:

Phase 5: Lazy Loading

For each selected artifact:
- Fetch artifact URL
- Parse YAML frontmatter ONLY (~200 tokens)
- Validate relevance from expanded metadata
- IF still relevant: Fetch full content (~3000 tokens)
- IF not relevant: Skip to next
Stop after 3 artifacts loaded (token limit)

Token Economics

Operation	Token Cost	What Happens
Registry scan	~100	Fetch catalog, calculate relevance
Identity load	~500	Voice context for session
Per artifact YAML	~200	Frontmatter validation
Per artifact content	~3,000	Full context if relevant
3 artifacts (smart)	~10,200	Typical execution
50 artifacts (dumb)	~250,000	Would exceed context window

✅ 96% Token Savings: Lazy loading makes large registries (1000+ artifacts) feasible. Without it, registries would be unusable beyond ~10 artifacts.

Registry JSON Schema

{
  "hc_version": "1.1",
  "registry_type": "neural_registry",
  "registry_id": "nr-[owner-slug]-[timestamp]",
  "html_url": "https://...",
  "owner": {
    "name": "string",
    "identity_url": "https://... (optional)"
  },
  "created": "ISO 8601",
  "last_updated": "ISO 8601",
  "artifact_count": 42,
  
  "artifacts": [
    {
      "id": "hc-artifact-001",
      "type": "newsletter|skill|identity|framework|artifact",
      "title": "Human-readable title",
      "created": "ISO 8601",
      "updated": "ISO 8601",
      "tags": ["array"],
      "category": "string",
      "frameworks": ["GOLDEN", "SHARP"],
      "summary": "50-100 token preview",
      "url": "https://...",
      "related": ["artifact-ids"],
      "quality_score": 9.2,
      "usage_count": 5
    }
  ],
  
  "external_registries": [
    {
      "name": "Brad Himel's Methods",
      "url": "https://...",
      "access": "public|team|private",
      "trust_level": "high|medium|low"
    }
  ],
  
  "statistics": {
    "total_artifacts": 42,
    "by_type": {...},
    "rci_connections": 127,
    "avg_quality_score": 8.7
  }
}

Self-Executing Agent Architecture NEW in v1.1

The biggest differentiator in HC v1.1: Skills can now execute themselves via embedded agent configuration.

The Shift

❌ Old Model (v1.0)

Skills as Instructions

User visits skill page
Copies launch link
Opens Claude/ChatGPT
Pastes skill URL
LLM fetches instructions
User follows prompts

Friction: 5 manual steps

✅ New Model (v1.1)

Skills as Applications

User visits skill page
Embedded agent activates
Agent reads config + knowledge
Agent prompts for inputs
Agent executes skill
Agent outputs artifact

Friction: 0 manual steps

Configuration Blocks

mastery-agent-config: Defines execution parameters

<script type="application/json" id="mastery-agent-config">
{
  "agent_id": "skill-newsletter-writer-v1",
  "execution_mode": "interactive",
  "requires_approval": true,
  "neural_registry_optional": true,
  "neural_registry_required": false,
  "python_execution_optional": true,
  "output_format": "hc-artifact",
  "max_iterations": 5,
  "quality_threshold": 8.0
}
</script>

mastery-agent-knowledge: Skill-specific knowledge base

<template id="mastery-agent-knowledge">
---
skill_purpose: "Write newsletters in user's voice using past work for consistency"

inputs_required:
  - name: "topic"
    type: "string"
    description: "Newsletter topic or theme"
    required: true
  - name: "key_points"
    type: "array"
    description: "Main points to cover"
    required: false

quality_gates:
  - "GOLDEN score ≥ 8/10"
  - "SHARP score ≥ 8/10"
  - "Word count: 800-1200"
  - "Voice matches identity"

best_practices:
  - "Lead with hook in first 2 sentences"
  - "Use 3-2-1 structure if applicable"
  - "End with clear CTA"
  - "Apply GOLDEN+SHARP validation"
---
</template>

Execution Flow

Page Load: Embedded agent detects config blocks
Initialization: Agent reads mastery-agent-config
Knowledge Load: Agent parses mastery-agent-knowledge
Registry Check: If optional, asks user for registry URL
Input Collection: Prompts for required inputs from config
Execution: Runs skill logic with loaded context
Quality Validation: Applies quality gates from knowledge
Output: Generates HC-compliant artifact
Registry Update: If connected, updates user's registry

Why This Matters

The Moat

Red Ocean: "Prompt libraries" (everyone building these)
Blue Ocean: "Self-executing knowledge pages" (nobody doing this)

This isn't about the HTML format. It's about the execution model. Skills become zero-friction applications that run themselves.

Implementation Guide

To make a skill self-executing:

Create standard HC v1.1 skill file
Add mastery-agent-config block with execution parameters
Add mastery-agent-knowledge block with skill knowledge
Deploy embedded agent JavaScript (separate component)
Test execution flow end-to-end

When to use:

Premium skills (paid tier)
Frequently-used skills
Complex multi-step workflows
Skills requiring consistent quality

When NOT to use:

Simple one-step transformations
Educational/learning skills (user should see process)
Highly variable workflows
Skills where manual control is important

Integrity & Change Detection NEW in v1.1

Every HC v1.1 file includes cryptographic hashes enabling safe caching, version tracking, and drift detection.

Hash Fields

Field	What It Hashes	Purpose
`content_hash`	Human-visible content (`#hc-human-docs` div)	Detect documentation changes
`metadata_hash`	hc-metadata JSON block	Detect operational changes

Hash Calculation

Algorithm: SHA-256

// Calculate content_hash
const contentDiv = document.getElementById('hc-human-docs');
const contentText = contentDiv.textContent.trim();
const contentHash = sha256(contentText);

// Calculate metadata_hash
const metadataScript = document.getElementById('hc-metadata');
const metadataJSON = JSON.parse(metadataScript.textContent);
// Remove hash fields before hashing
delete metadataJSON.content_hash;
delete metadataJSON.metadata_hash;
const metadataString = JSON.stringify(metadataJSON, null, 2);
const metadataHash = sha256(metadataString);

// Store in hc-metadata
metadataJSON.content_hash = `sha256:${contentHash}`;
metadataJSON.metadata_hash = `sha256:${metadataHash}`;

Use Cases

1. Safe Caching

// Agent fetches artifact
const cached = localStorage.getItem(artifactUrl);
if (cached) {
  const cachedHash = JSON.parse(cached).metadata_hash;
  
  // Fetch just metadata to check hash
  const current = await fetchMetadata(artifactUrl);
  
  if (current.metadata_hash === cachedHash) {
    // Safe to use cached version
    return JSON.parse(cached);
  }
}

// Cache miss or hash mismatch - fetch full content
return await fetchFull(artifactUrl);

2. Change Detection

// Track what changed
if (current.content_hash !== previous.content_hash) {
  console.log("Documentation updated");
  showChangeNotification("Docs updated - review changes");
}

if (current.metadata_hash !== previous.metadata_hash) {
  console.log("Operational logic changed");
  showChangeNotification("Skill logic updated - may behave differently");
}

3. Temporal Reasoning

// Registry stores hash history
{
  "artifact_id": "hc-skill-newsletter-v1",
  "versions": [
    {
      "version": "1.0.0",
      "timestamp": "2026-02-01T10:00:00Z",
      "content_hash": "sha256:abc123...",
      "metadata_hash": "sha256:def456..."
    },
    {
      "version": "1.1.0",
      "timestamp": "2026-02-08T10:00:00Z",
      "content_hash": "sha256:ghi789...",
      "metadata_hash": "sha256:jkl012..."
    }
  ]
}

// Agent can reason: "What version did user use last time?"

4. Drift Alerts

// User executes skill
const lastUsed = registry.getLastUsed("hc-skill-newsletter-v1");
const current = await fetch(skillUrl);

if (current.metadata_hash !== lastUsed.metadata_hash) {
  alert("⚠️ Skill updated since your last use. Review changes?");
  showChangelog(lastUsed.version, current.version);
}

Best Practices

✅ Calculate hashes on every file save
✅ Store hash history in registries
✅ Check hashes before using cached content
✅ Alert users when skills change
✅ Use metadata_hash for logic changes
✅ Use content_hash for doc changes
❌ Don't use placeholder hashes in production
❌ Don't skip hash validation
❌ Don't cache without checking hashes

Complete Templates

Production-ready templates for each canonical type:

Template Files

skill-template-v1.1.html - Basic skill structure
skill-self-executing-v1.1.html - Self-executing skill (NEW)
artifact-template-v1.1.html - Generated output format
registry-template-v1.1.html - Neural Registry with dual format
identity-template-v1.1.html - Voice/style context
framework-template-v1.1.html - Methodology documentation

📦 Download Templates: Full templates available at github.com/masterymade/hypercontext/templates

Quick Start

Choose appropriate template for your type
Replace placeholder content with yours
Calculate integrity hashes
Validate against checklist (Section 10)
Deploy to public URL
Test with LLM

Validation Checklist

Use this checklist before claiming HC v1.1 compliance:

Structure ✓

□ Valid HTML5 doctype
□ UTF-8 encoding specified
□ All required sections present
□ No syntax errors in any block
□ Renders correctly in browser

Metadata (hc-metadata) ✓

□ hc_version: "1.1"
□ hc_type: One of canonical 5
□ artifact_id: Unique, proper format
□ version: Valid semver
□ content_hash: SHA-256 calculated
□ metadata_hash: SHA-256 calculated
□ created: ISO 8601 format
□ updated: ISO 8601 format
□ All required fields populated
□ Valid JSON syntax

LLM Instructions ✓

□ Hidden in proper script tag
□ Step 0 (Neural Registry) included
□ Clear step-by-step logic
□ Quality gates defined
□ Error handling specified
□ Output format specified

Human Documentation ✓

□ "What This Does" section
□ "How to Use" section
□ Launch links (if skill)
□ Requirements listed
□ Examples provided
□ Troubleshooting included
□ Footer with HC badge
□ Professional styling

Self-Execution (if applicable) ✓

□ mastery-agent-config present
□ mastery-agent-knowledge present
□ Valid JSON in config
□ Valid YAML in knowledge
□ All required inputs defined
□ Quality gates specified
□ Execution mode appropriate

Registry (if type=registry) ✓

□ Dual format implemented (HTML + JSON)
□ /registry.json endpoint works
□ Valid JSON catalog
□ All artifacts have required fields
□ identity_url present (if applicable)
□ Statistics calculated correctly
□ Human dashboard functional
□ Search/filter working

RCI Compliance ✓

□ Generates HC-compliant outputs
□ References parent artifacts
□ Linkable/referenceable
□ Lazy load compatible
□ Summary within 50-100 tokens
□ Unique artifact_id generated

Quality ✓

□ URLs publicly accessible
□ No broken links
□ Professional appearance
□ Consistent styling
□ Mobile responsive
□ Fast loading
□ Accessible (WCAG)

Testing ✓

□ Tested in Chrome
□ Tested in Safari
□ Tested in Firefox
□ Tested with Claude
□ Tested with ChatGPT
□ Launch links work
□ Registry integration works
□ Self-execution works (if applicable)

✅ 100% Checklist Complete? Your file is HC v1.1 compliant. Add the badge: <img src="https://img.shields.io/badge/HyperContext-v1.1-blue">

Migration from v1.0 to v1.1

Step-by-Step Migration

Add hc-metadata block (NEW):

<script type="application/json" id="hc-metadata">
{
  "hc_version": "1.1",
  "hc_type": "[your-type]",
  "artifact_id": "[your-id]",
  "version": "1.0.0",
  "content_hash": "sha256:...",
  "metadata_hash": "sha256:...",
  "created": "...",
  "updated": "...",
  ...
}
</script>

Calculate integrity hashes:
- Hash human-docs div → content_hash
- Hash hc-metadata (excluding hashes) → metadata_hash
Update hc_type to canonical 5:
- If custom type: Map to closest canonical
- Use subcategory for specificity
Add version field (semver):
```
"version": "1.0.0"  // Not just "1.0"
```
Optional: Add self-execution blocks:
- mastery-agent-config (for skills)
- mastery-agent-knowledge (for skills)
Optional: Create /registry.json:
- Extract catalog from HTML
- Serve as separate endpoint
- Same payload, JSON wrapper
Keep existing v1.0 blocks:
- Schema.org JSON-LD
- hc-frontmatter YAML
- hc-instructions
- hc-human-docs
Update version references:
```
hc_version: "1.0" → "1.1"
```
Test thoroughly:
- Validate against checklist
- Test with multiple LLMs
- Verify backward compatibility
Update documentation:
- Mention v1.1 compliance
- Document new features
- Update badges

What Changes vs. What Stays

Aspect	v1.0	v1.1	Migration
Metadata	Single YAML	Split (Schema.org + hc-metadata)	Add hc-metadata, keep YAML
Types	Free-form	Canonical 5 only	Map to closest canonical
Registry	HTML only	Dual format (HTML + JSON)	Add /registry.json endpoint
Execution	Manual launch	Self-executing (optional)	Add agent config blocks
Integrity	None	Content/metadata hashes	Calculate and add hashes
Structure	Same	Same	No change
Three Laws	Same	Same	No change

Backward Compatibility

✅ v1.0 files still work. HC v1.1 agents can read v1.0 files. No breaking changes. Migration is additive only.

v1.1 agents handle v1.0 files by:

Reading YAML frontmatter if hc-metadata missing
Accepting any type if not canonical 5
Skipping hash validation if not present
Falling back to manual execution if no agent config
Using HTML registry if JSON not available

v1.0 agents with v1.1 files:

Ignore hc-metadata (use YAML)
Ignore agent config blocks
Ignore integrity hashes
Still functional, just less optimized

License & Contributing

License

This specification is released under MIT License.

Copyright (c) 2026 MasteryMade

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

Contributing

We welcome contributions to the HC Standard.

How to contribute:

Fork the repository: github.com/masterymade/hypercontext
Create a feature branch
Make your changes
Submit a pull request
Discuss with community

Contribution guidelines:

Maintain backward compatibility
Follow existing patterns
Include complete examples
Update documentation
Test thoroughly across LLMs
Explain rationale in PR

Report issues: github.com/masterymade/hypercontext/issues

Community

Website: skills.masterymade.com
Repository: github.com/masterymade/hypercontext
Examples: github.com/masterymade/hypercontext/examples
Templates: github.com/masterymade/hypercontext/templates

Version History

v1.1.0 (2026-02-08) - Current

Major enhancements:

✅ Split metadata blocks (Schema.org + hc-metadata)
✅ Canonical 5 types (registry, skill, artifact, identity, framework)
✅ Dual registry format (HTML + /registry.json)
✅ Self-executing agent architecture
✅ Integrity hashes (content_hash, metadata_hash)
✅ Enhanced token optimization
✅ Improved Neural Registry protocol
✅ Complete templates for all types
✅ Comprehensive validation checklist
✅ Migration guide from v1.0

v1.0.0 (2026-01-15)

Initial release:

Three Laws defined
File structure specification
Neural Registry concept
RCI mechanism
Lazy loading protocol
Platform-agnostic architecture
Basic templates