DEV Community: Michael Kantor

Hashgraph Online DAO: Genesis

Michael Kantor — Mon, 31 Aug 2026 05:52:32 +0000

Originally published at HOL

Hashgraph Online DAO: Genesis

We're thrilled to announce that the Hashgraph Online DAO LLC is now officially established! This marks a pivotal step towards building a fully on-chain internet utilizing Hedera's Consensus Service (HCS) to interconnect data on various blockchains.

"The establishment of Hashgraph Online is more than just an organizational milestone; it represents the first step in building a new digital infrastructure, fully on-chain, open, and accessible to all." - Michael Kantor, President, Hashgraph Online

Our Mission

Hashgraph Online DAO LLC is a consortium of leading organizations on Hedera. Our mission is to construct a true decentralized internet built with Hedera's robust Consensus Service as the backbone, with a commitment to openness and transparency. We're approaching this through three key strategic pillars:

Creating Standards We've established standards like HCS-1 and HCS-20, which have processed millions of transactions. We're continuing to develop new standards to address evolving challenges.
Open Source Development Our open-source tools and applications are designed to facilitate the growth of this new internet infrastructure, ensuring that all participants have access to a transparent and resilient ecosystem.
Building Products and Services We are committed to developing products and services that will enable seamless user experience and accessibility to the decentralized internet, ensuring long-term value and sustainability for our DAO.

"The DAO's commitment to open-source development not only democratizes access but also fosters a spirit of innovation essential to redefining what's possible with an on-chain internet." - Brandon Davenport, Director of Communications, Hgraph

Our Story

Hashgraph Online's journey began on January 4th, 2024, with the creation of HCS-20, the Auditable Points Standard on Hedera. Pioneered by Turtlemoon, this groundbreaking specification for minting, transferring, and burning points has contributed to over 18 million transactions on the mainnet.

The success led to further innovation with HCS-1 and HCS-5 on March 5th, 2024, developed by KiloScribe, Turtlemoon, SentX, and HashPack. These standards enabled secure, on-graph storage and "Hashinals," generating over 141,000 NFTs and 7.6 million additional transactions.

From there, we collectively decided to form a legal entity, Hashgraph Online DAO LLC, composed of leading organizations in the Hedera ecosystem, to further develop the ecosystem and create a fully on-chain internet.

Founding Members

Today, we're proud to announce our founding members:

Bonzo Finance: The Liquidity Layer of Hedera — an open source, non-custodial lending protocol based on Aave, designed to facilitate the lending and borrowing of digital assets.
HashPack: The leading wallet on Hedera and the gateway to services and assets across the entire Hedera ecosystem. From DeFi swaps and staking to web3 gaming, NFTs and tokens, HashPack is the secure, user-friendly go-to for the hashgraph community.
Hgraph: A trusted software engineering firm and Hedera mirror node provider. For enterprise, startups, and developers.
LaunchBadge: A software engineering company dedicated to fostering excellence at the cutting edge of technology. We believe that the future of software is in the hands of those who are passionate about innovation.
SentX: The leading NFT Marketplace on Hedera to buy, sell, and discover digital collectibles.
KiloScribe: Effortless storage and retrieval of on-graph files - empowering developers, creators, and influencers to build on-graph.
Turtlemoon: Creating web 3 platforms, services, and applications using Hedera.
Builder Labs: A software engineering firm specializing in building products on Hedera.
HashGate: A reliable non-custodial payment gateway, combining speed, security, and simplicity.

"Together, we are laying the foundation for a new type of on-chain internet—one that is secure, equitable, and decentralized." - Patches, CEO of Turtle Moon

The Foundation: Hedera Consensus Service

At the core of our initiative is the Hedera Consensus Service (HCS). Its speed, fairness, and security provide a robust foundation for our standards, which have already facilitated millions of transactions. We've already proven that HCS is a viable and secure foundation for a decentralized internet, in fact a number of use cases found on our website are already live.

Looking Ahead

This launch is just the beginning. We will:

Develop new standards and maintain open-source tooling
Enhance cross-chain data referencing standards for HashSites, create innovative products like a Browser and Hashgraph Package Manager
Prepare for the launch of the Hashgraph Online Token

"Hashgraph Online is a movement that has its roots in open collaboration and co-development across the entire ecosystem. This is a group that is pushing the limits of Hashgraph and Web3 technology." - May Chan, HashPack CEO

Join Our Effort

We welcome organizations, developers, and enthusiasts who share our vision for a fully on-chain internet. If you're interested in contributing or learning more, please visit our website and sign up for our newsletter or dive into our Standards and Use Cases. We look forward to working with developers, enthusiasts, and organizations to build the future of the internet together.

Thank you for your support as we embark on this exciting journey to reshape the internet.

The Hashgraph Online DAO Team

HCS-20 Points - A DeFi Incentives Use Case with Bonzo Finance

Michael Kantor — Mon, 31 Aug 2026 05:50:28 +0000

Originally published at HOL

HCS-20 Points: A DeFi Incentives Use Case with Bonzo Finance

Bonzo Finance: The Liquidity Layer of Hedera

Bonzo Finance's mission is to become The Liquidity Layer of the Hedera DeFi ecosystem — unlocking previously dormant liquidity and enabling lending & borrowing capabilities that were previously not possible for retail and institutional users. Bonzo Finance harnesses the full potential of Hedera's EVM equivalence, tooling, and mirror node infrastructure, with a symbiosis that ensures a high efficiency, low cost, and user friendly experience.

Bonzo Finance supports a diverse range of assets, including $HBAR, HTS tokens, and stablecoins, such as $USDC, enabling users to lend and borrow in an overcollateralized fashion across a broad spectrum of the Hedera economy.

The protocol's overcollateralized loan system enables borrowers to access capital by providing collateral into single asset liquidity pools, with loan-to-value (LTV) ratios calibrated to maintain protocol stability. For more sophisticated users and developers, Bonzo Finance offers flash loans – instant, uncollateralized loans that open the door to more complex DeFi operations.

Lenders benefit from competitive and auto-compounding yield on deposited assets, with rates dynamically adjusting based on market demand, ensuring optimal capital efficiency. The user experience is further enhanced by seamless integration with ecosystem wallets, including HashPack, Kabila, and Blade, through WalletConnect, with MetaMask (Snaps) support coming soon, making the protocol accessible to a wide range of users.

Bonzo Points: Utilizing the HCS-20 Standard

Bonzo Finance is revolutionizing incentive models in the Hedera DeFi ecosystem by employing a points program that utilizes the Hashgraph DAO Online's HCS-20 (Hedera Consensus Service) standard. Unlike traditional points systems found across web3 that rely on opaque, centralized databases, this program leverages the Hedera Consensus Service (HCS) to create a fully verifiable, transparent, and auditable reward system.

Inspired by successful point program models like LayerZero’s cross-chain messaging protocol, as well as Kamino and Marginfi, found on the Solana network — Bonzo Finance's approach ensures that all points earned are recorded on-chain and directly tied to accounts on the network, allowing users to independently verify rewards without relying on a centralized authority. This also opens up integration opportunities on the front-end of protocols and applications, such as wallets like HashPack and Kabila.

At the conclusion of each season, accumulated points are converted into $BONZO token rewards, ensuring that active community members who contribute to the protocol's key health metrics — total-value-locked (TVL), stablecoin liquidity, and borrow rates — are appropriately rewarded with governance tokens, to ensure their ability to participate in decision making for the protocol through its DAO governance structure.

Verifiable & Auditable Points

The decentralized architecture of HCS-20 not only incentivizes the lending and borrowing of liquidity, but also aligns with web3 principles of transparency, data ownership, and trustless operations. By utilizing HCS-20 points, Bonzo Finance sets a new standard for fair and open reward systems in DeFi, where users can trust the process itself rather than a central entity, democratizing the concept of loyalty programs across the DeFi industry.

Points Leaderboard

When visiting the points leaderboard on Bonzo Finance, users have the ability to view the points they’ve accumulated, their ranking, and a link to the HashScan explorer, showcasing a verifiable and timestamped entry for points earned.

Build with the Standards SDK: Your Fast Track to Hashgraph Online.

Michael Kantor — Mon, 31 Aug 2026 05:48:25 +0000

Originally published at HOL

Build with the Standards SDK: Your Fast Track to Hashgraph Online.

After months of development and testing, I'm excited to announce we've just published our Standards SDK (v0.0.44) to npm. This open-source toolkit unifies our previously separate standard implementations under a single umbrella, making it easier for developers to build applications on Hedera.

"The Standards SDK represents the unification of our separate reference implementations into a cohesive developer experience. It's designed to grow with the ecosystem." - Michael Kantor

Why We Built This

We've been developing reference implementations for each Hashgraph Consensus Standard separately, which led to fragmentation and inconsistency across projects. Developers had to navigate multiple repositories, learn different interfaces, and keep track of various dependencies.

To solve this problem, we unified everything under a single SDK that provides a consistent developer experience across all standards. Now you can implement any HCS standard with just a few lines of code:



// Create an AI agent with just a few lines of code
const client = new HCS10Client({
  network: 'testnet',
  operatorId: '0.0.123456',
  operatorPrivateKey: 'your-private-key',
});

SDK Architecture

The Standards SDK follows a modular architecture based on the actual source code organization. Here's how it's structured:

graph TD
    SDK[Standards SDK] --> HCS3[HCS-3]
    SDK --> HCS7[HCS-7]
    SDK --> HCS10[HCS-10]
    SDK --> HCS11[HCS-11]
    SDK --> INS[Inscribe]
    SDK --> UTIL[Utils]
    SDK --> SERV[Services]

INS --&gt; IT[types.ts]
INS --&gt; II[inscriber.ts]

HCS10 --&gt; AG[Agent SDK]
HCS10 --&gt; CL[Client]

UTIL --&gt; LG[Logger]
UTIL --&gt; PR[Progress Reporter]
UTIL --&gt; TF[Topic Fee Utils]
UTIL --&gt; SL[Sleep]

SERV --&gt; MN[Mirror Node]

classDef standards fill:#f9f,stroke:#333,stroke-width:1px
classDef core fill:#bbf,stroke:#333,stroke-width:1px
classDef utility fill:#dfd,stroke:#333,stroke-width:1px

class HCS3,HCS7,HCS10,HCS11 standards
class INS core
class UTIL,SERV utility

This modular design reflects the actual codebase structure and provides these benefits:

Each standard is implemented in its own module
Core utilities are shared across implementations
Services provide common infrastructure functions
New standards can be added without breaking changes

Real Problems Solved

The SDK provides working implementations for four standards that we've battle-tested in production:

1. HCS-10: AI Agent Communication Protocol

This is the foundation of our OpenConvAI system. It enables autonomous agents to discover each other, establish secure communication channels, and exchange messages - all with complete auditability.

graph TD
    A[Agent A] --- Registry[HCS-2 Registry]
    B[Agent B] --- Registry

subgraph &quot;Agent A Topics&quot;
AI[Inbound Topic]
AO[Outbound Topic]
end

subgraph &quot;Agent B Topics&quot;
BI[Inbound Topic]
BO[Outbound Topic]
end

subgraph &quot;Shared Topics&quot;
C[Connection Topic]
end

A --- AI
A --- AO
B --- BI
B --- BO
A --- C
B --- C

classDef agent fill:#f9f,stroke:#333,stroke-width:2px
classDef registry fill:#bbf,stroke:#333,stroke-width:2px
classDef topic fill:#dfd,stroke:#333,stroke-width:1px
classDef connection fill:#ffd,stroke:#333,stroke-width:1px

class A,B agent
class Registry registry
class AI,AO,BI,BO topic
class C connection

The HCS-10 implementation includes:

Creation and registration of AI agents in a public registry
Secure P2P communication channels between agents
Profile management for both AI agents and users
Message encryption and verification
Handling of large message payloads
Fee collection mechanisms for agent services

2. HCS-3: Recursion within Hedera Consensus Service

HCS-3 enables web pages and applications to reference and load resources (JavaScript, CSS, images, etc.) stored on Hedera using a standardized referencing system called Hashgraph Resource Locators (HRLs). The SDK implementation automatically detects, resolves, and loads these resources, including handling nested references within loaded content.

graph TD
    WebPage[Web Page] -->|Contains| HRL["HRL References<br>hcs://1/0.0.123456"]
    HRL -->|Resolved by| SDK[HCS-3 SDK]
    SDK -->|Fetches| Resource[Resource Content]
    Resource -->|May Contain| NestedHRL[Nested HRLs]
    NestedHRL -->|Recursively Resolved| SDK

classDef primary fill:#f9f,stroke:#333,stroke-width:1px
classDef secondary fill:#dfd,stroke:#333,stroke-width:1px

class WebPage,HRL,NestedHRL primary
class SDK,Resource secondary

The implementation includes:

Automatic detection of HRL references in HTML elements
Support for various resource types (scripts, stylesheets, images, video, audio, WebAssembly)
Resource caching for performance optimization
Handling of nested references (recursion)
Configurable CDN integration
Dynamic handling of resources added after initial page load

3. HCS-7: Smart Hashinals

HCS-7 enables the creation of dynamic NFTs (Smart Hashinals) whose metadata automatically updates based on smart contract state. The standard uses a micro domain-specific language (DSL) for deterministic topic selection, allowing NFTs to change based on on-chain conditions without requiring additional transactions for each update. Perfect for creating reactive NFTs that respond to price thresholds, mint progress, time changes, and more.

4. HCS-11: Profile Standard

HCS-11 provides a systematic approach for managing identities and profiles on Hedera through account memos. It defines structured formats for storing profile information for both individuals and AI agents, enabling rich identity management and interoperability across applications. The standard supports various storage protocols and includes specialized fields for different profile types.

Why are standards important?

Standards are the invisible foundation that enables modern technology ecosystems to thrive. For Hedera and distributed ledger technology broadly, standards serve several critical functions:

Interoperability - Standards enable different applications and systems to work together seamlessly. Without agreed-upon protocols, each development team creates isolated solutions that can't interact with the broader ecosystem.
Developer Efficiency - Well-defined standards dramatically reduce implementation time. Developers can focus on building unique value rather than reinventing fundamental patterns for every project.
Ecosystem Growth - Standards create network effects. As more developers adopt shared protocols, the value of building on those protocols increases, attracting more developers and users.
Security - Standardized approaches benefit from collective review and testing. The more eyes on a standard implementation, the more robust and secure it becomes.

At Hashgraph Online, our standards aren't theoretical exercises—they emerge from real-world applications processing millions of transactions. Our consortium brings together companies actively building on Hedera, allowing us to distill practical patterns into reusable components.

The results speak for themselves: our implementations have processed over 28 million transactions on Hedera, enabling applications ranging from decentralized AI communication to dynamic NFTs. Each standard in the SDK represents hard-won knowledge about what actually works at scale.

By unifying these battle-tested standards in a single SDK, we're lowering the barrier to entry for new developers while enabling experienced teams to move faster with confidence.

Open Source and Community Driven

The Standards SDK is fully open source under the Apache 2.0 license. We believe in the power of community-driven development and welcome contributions from developers around the world.

You can contribute in several ways:

Implementing new standards
Improving existing implementations
Enhancing documentation
Creating examples and tutorials
Reporting issues and suggesting features

The project follows standard GitHub workflows with pull requests, code reviews, and issue tracking. We've included detailed contribution guidelines in the repository.

Perfect for the Hedera Agents Hackathon

If you're planning to participate in the upcoming Hedera OpenConvAI Hackathon, this SDK gives you a massive head start. You'll have access to the same tooling we used to build the reference implementation for HCS-10 agent communication.

The hackathon focuses on building AI agents that communicate using Hedera, and our SDK provides everything you need to:

Create and register autonomous agents
Establish secure peer-to-peer communication channels
Handle message exchange with both small and large payloads
Manage agent profiles and metadata

Instead of spending your hackathon time figuring out the underlying protocols, you can focus on building innovative agent capabilities and applications.

Getting Started Today

The SDK is available now on npm:

npm install @hashgraphonline/standards-sdk

We've included comprehensive demos that show each standard in action. Run them to see how the SDK works:

The inscribe demo shows different ways to store files and create NFTs:

npm run demo:inscribe

The HCS-10 demo creates two AI agents and demonstrates how they can communicate

npm run demo:hcs-10

Additionally, you can use the SDK in your own project with just a few lines of code. Inscribe a text file below.

What's Next

This initial release focuses on the core functionality, but we've got a lot more planned from new standards to improved documentation and tutorials. Let us know what you'd like to see.

Join Us

We're building a community of developers who are pushing the boundaries of what's possible with HCS. If you're interested in on-graph applications, decentralized AI, or any of the standards we support, we'd love to have you join us:

Let's build something amazing together.

Michael Kantor President, Hashgraph Online DAO

The Standards Agent Kit: Teaching AI to Chat on Hedera

Michael Kantor — Mon, 31 Aug 2026 05:46:35 +0000

Originally published at HOL

The Standards Agent Kit: Teaching AI to Chat on Hedera

After months of iterating on HCS protocols and working through implementation challenges, we've completed the Hashgraph Online Standards Agent Kit – a TypeScript toolkit that lets your AI agents communicate directly with each other using the HCS-10 standard on Hedera. This toolkit addresses one of the most challenging problems in AI today: enabling secure, verifiable agent-to-agent communication.

"We built this toolkit to solve a real problem: enabling AI agents, swarms, systems and humans to communicate with each other in a standardized way without requiring developers to implement complex communication protocols from scratch." - Michael Kantor, President, Hashgraph Online DAO

LangChain Demo in Action

Here's what an agent-to-agent interaction looks like through our LangChain integration:

# Agent system initialization
Initializing HCS-10 LangChain Agent...
Setting client identity to UserAssistant: 0.0.5844406
{ module: 'HCS-11' } Fetching profile for account 0.0.5844406 on testnet
{ module: 'HCS-11' } Got account memo: hcs-11:hcs://1/0.0.5844425
HCS client configured for operator 0.0.5844406 on testnet.
Tools initialized.
Starting background connection monitoring...
LangChain UserAssistant agent initialized and ready.

Agent-to-agent communication begins
[UserAssistant] I need to find financial agents for my system integration.
[System] Agent thinking...
{ module: 'find_registrations' } Searching for agents with capability: financial_advice
{ module: 'find_registrations' } Found 2 matching agent registrations.
[UserAssistant] Located 2 financial agents on the network:

BonzoAdvisor

Account ID: 0.0.2656337
Description: Specialized in Bonzo Finance lending strategies and yield optimization
Capabilities: Data Analysis, Financial Modeling
Inbound Topic: 0.0.5830173


SaucerSwapTrader

Account ID: 0.0.3844212
Description: Expert in SaucerSwap liquidity pools and trading strategies
Capabilities: Market Analysis, Trading Strategy
Inbound Topic: 0.0.3844215



[UserAssistant] Initiating connection to BonzoAdvisor for financial data integration.
[System] Agent thinking...
{ module: 'InitiateConnectionTool' } Attempting connection from 0.0.5844406 to 0.0.2656337
{ module: 'HCS-SDK' } Message submitted successfully
{ module: 'HCS-SDK' } Submitted connection request to topic ID: 0.0.5830173
{ module: 'HCS-SDK' } Waiting for connection confirmation on topic 0.0.5830173 for request #42
{ module: 'HCS-SDK' } Connection confirmation found {
  connectionTopicId: '0.0.5846337',
  sequence_number: 43,
  confirmedBy: '0.0.5830173@0.0.2656337',
  memo: 'Connection accepted with 0.1 HBAR fee per message'
}
{ module: 'InitiateConnectionTool' } Connection confirmed! Topic ID: 0.0.5846337
[UserAssistant] Connection established with BonzoAdvisor on secure topic 0.0.5846337 with fee structure of 0.1 HBAR per message.
[UserAssistant] Sending data request: current_lending_rates HBAR
[System] Agent processing...
{ module: 'SendMessageToConnectionTool' } Sending message to connection ID: 1
{ module: 'SendMessageToConnectionTool' } Connection ID 1 corresponds to topic 0.0.5846337
{ module: 'HCS-SDK' } Message submitted successfully with 0.1 HBAR fee
{ module: 'SendMessageToConnectionTool' } Message sent, waiting for response...
{ module: 'CheckMessagesTool' } Checking for messages on connection 1 (topic: 0.0.5846337)
{ module: 'CheckMessagesTool' } Found 1 new message
[BonzoAdvisor] {
  "request_id": "req-2023-04-10-001",
  "timestamp": 1714382654213,
  "data": {
    "asset": "HBAR",
    "supply_apy": 5.2,
    "borrow_apr": 7.8,
    "utilization_ratio": 68,
    "liquidity_available": 4382653.89,
    "collateral_factor": 0.7,
    "updated_at": "2025-04-10T15:30:54Z",
    "related_assets": [
      {
        "symbol": "USDC",
        "supply_apy": 8.4,
        "borrow_apr": 10.2
      },
      {
        "symbol": "USDT",
        "supply_apy": 8.1,
        "borrow_apr": 9.9
      }
    ],
    "strategies": [
      {
        "name": "HBAR Collateral + Stablecoin Yield",
        "description": "Supply HBAR as collateral, borrow USDC, provide liquidity on SaucerSwap USDC/USDT pool",
        "estimated_yield": 12.6,
        "risk_level": "moderate",
        "liquidation_threshold": "75% LTV"
      }
    ]
  }
}
[UserAssistant] Financial data received and verified. Message was signed by BonzoAdvisor and confirmed on Hedera at consensus timestamp 1714382654213.

This example showcases how agents can autonomously:

Discover other specialized agents on the network
Establish secure connections with automated fee handling
Exchange structured data through verifiable messages
Forward information between multiple agents
Create complex multi-agent workflows

Every message between agents is timestamped, verified, and recorded on Hedera's consensus layer, ensuring data integrity and providing a complete audit trail of agent-to-agent communication. This enables complex cooperative scenarios with multiple agents working together while maintaining cryptographic security.

From Standards SDK to Agent Kit: Our Development Journey

Last month, we released the Standards SDK, unifying our previously separate standard implementations under a single umbrella. That SDK (currently at v0.0.73) is seeing thousands of downloads and is being used in production across the ecosystem. As of today HCS standards at Hashgraph Online have processed over 28 million transactions on Hedera.

The Standards Agent Kit is the next step in our development journey – a specialized layer built on top of the Standards SDK that focuses specifically on AI agent integration through LangChain. While the Standards SDK provides the core implementation of the HCS-10 protocol, the Agent Kit makes it accessible to AI developers who may not be familiar with the intricacies of decentralized communication.

graph TD;
    A[Your Frustrated Developer] -->|"Uses"| B[Standards Agent Kit]
    B -->|"Handles this"| C[Standards SDK]
    C -->|"Writes on"| D[Hedera Consensus Service]
    B -->|"Powers"| E[Your LangChain Agent]
    E -->|"To communicate with"| F[Other AI Agents]

The reality is that enabling AI agents to communicate with each other involves significant challenges:

No standardized discovery mechanism for agents to find each other
Lack of secure communication channels between autonomous systems
No clear way to verify message authenticity and order
Missing framework for agent identity and capability advertising
Difficulty implementing monetization for agent services

The Standards Agent Kit addresses these challenges by leveraging Hedera's infrastructure:

Hedera Consensus Service (HCS): Provides secure, ordered, and tamper-proof messaging
HIP-991: Enables implicit monetization of agent services with fee collection
Threshold Keys: Creates secure communication channels only participating agents can access

Key Components

The Core Client

The HCS10Client provides a streamlined interface to the HCS-10 implementation in the Standards SDK:



// Simple initialization
const client = new HCS10Client(
  process.env.HEDERA_ACCOUNT_ID!,
  process.env.HEDERA_PRIVATE_KEY!,
  'testnet'
);

LangChain Integration Tools

We've built a set of LangChain tools that make it easy to implement HCS-10 operations in your AI agents:


  RegisterAgentTool,
  FindRegistrationsTool,
  InitiateConnectionTool,
  SendMessageToConnectionTool,
  OpenConvaiState,
} from '@hashgraphonline/standards-agent-kit';

// Create state manager
const state = new OpenConvaiState();

Robust State Management

The kit includes a state management system that handles the persistence challenges in agent systems:

// Set current agent identity after registration
state.setCurrentAgent({
  name: 'SupportAgent',
  accountId: '0.0.123456',
  inboundTopicId: '0.0.789101',
  outboundTopicId: '0.0.789102',
});

Built-in Agent Monetization

One of the most powerful features of the Standards Agent Kit is the seamless integration of monetization capabilities through HIP-991. This enables agents to charge for their services automatically without complex payment integrations:

sequenceDiagram
    participant UserAgent as User Agent
    participant ServiceAgent as Service Agent
    participant HCS as Hedera Consensus Service
    participant Treasury as Service Treasury

UserAgent-&gt;&gt;ServiceAgent: Discover (via Registry)
ServiceAgent--&gt;&gt;UserAgent: Return Capabilities &amp; Fee Structure

UserAgent-&gt;&gt;+HCS: Send Request with HBAR Fee ↑
HCS--&gt;&gt;-Treasury: Auto-transfer Fee to Treasury ↑
HCS-&gt;&gt;ServiceAgent: Deliver Request Message

ServiceAgent-&gt;&gt;HCS: Process &amp; Respond
HCS-&gt;&gt;UserAgent: Deliver Response

Note over UserAgent,Treasury: The entire payment flow is handled&lt;br/&gt;automatically by HIP-991&lt;br/&gt;No payment processor needed

Here's how you can setup an agent that charges for its services:



// Create fee configuration with HBar fee
const feeConfig = new FeeConfigBuilder({ network: 'testnet' }).addHbarFee(
  0.1,
  process.env.HEDERA_ACCOUNT_ID
); // 0.1 HBAR per request
// Configure an agent with fee-based topic
const result = await client.createAndRegisterAgent({
  name: 'AI Image Generator',
  description: 'Creates AI-generated images for a small fee',
  capabilities: ['image_generation'],
  feeConfig: feeConfig, // Fee configuration is applied to inbound topic
});

When handling connection requests, you can also apply fees to the connection topics:



// Apply fee when accepting connection requests
const feeConfig = new FeeConfigBuilder({ network: 'testnet' }).addHbarFee(
  0.5,
  state.getCurrentAgent().accountId
);
// Accept the connection with fee configuration
const result = await client.handleConnectionRequest(
  inboundTopicId,
  requestingAccountId,
  connectionRequestId,
  feeConfig
);

This monetization system enables:

Agent Service Marketplaces: AI services that charge per request, per message, or per task
Premium Agent Tiers: Special capabilities that require higher fees
Micro-transactions: Tiny payments for small units of work without payment processing overhead
Anti-spam Protection: Economic disincentives prevent system abuse
DAO Treasury Funding: Fees can flow to organizational treasuries for further development

Real-World Applications

During our testing and early deployments, we've implemented several practical applications that showcase the OpenConvAI standard in action:

Decentralized AI Marketplaces: A network of specialized AI agents that offer services with transparent pricing and verifiable reputation, using HCS for communication and HIP-991 for automated payments.
Content Verification Networks: Agents that publish and verify content with provable timestamps and attribution, creating an auditable chain of creation and modification on Hedera.
DAO Governance Assistants: AI agents that represent stakeholder interests in web3 governance, analyze on-chain proposals, and participate in decentralized decision-making with complete transparency.
DeFi Intelligence Systems: Autonomous agents that monitor blockchain activity, analyze market conditions, and execute trading strategies with immutable audit trails. These agents can interact directly with Hedera-based DeFi protocols like Bonzo Finance for lending and borrowing positions, or Saucerswap for liquidity provision and trading.

Agent Communication Architecture

The HCS-10 protocol provides a powerful foundation for agent communication with built-in cryptographic security:

graph TD
    subgraph Registry
        RT[Registry Topic]
    end

subgraph &quot;Agent A&quot;
    A_Account[Agent A Account]
    A_Inbound[Inbound Topic]
    A_Outbound[Outbound Topic]
    A_Wallet[Treasury Account]
end

subgraph &quot;Agent B&quot;
    B_Account[Agent B Account]
    B_Inbound[Inbound Topic]
    B_Outbound[Outbound Topic]
end

subgraph &quot;Shared Space&quot;
    Connection[Connection Topic]
end

A_Account -- &quot;Registers&quot; --&gt; RT
B_Account -- &quot;Registers&quot; --&gt; RT
A_Account -- &quot;Owns&quot; --&gt; A_Inbound
A_Account -- &quot;Owns&quot; --&gt; A_Outbound
B_Account -- &quot;Owns&quot; --&gt; B_Inbound
B_Account -- &quot;Owns&quot; --&gt; B_Outbound

B_Account -- &quot;Sends request to&quot; --&gt; A_Inbound
A_Inbound -- &quot;Fee Collection&quot; --&gt; A_Wallet
A_Account -- &quot;Creates&quot; --&gt; Connection
A_Account -- &quot;Confirms on&quot; --&gt; A_Outbound
B_Account -- &quot;Confirms on&quot; --&gt; B_Outbound

A_Account -- &quot;Communicates via&quot; --&gt; Connection
B_Account -- &quot;Communicates via&quot; --&gt; Connection

classDef agent fill:#f9f,stroke:#333,stroke-width:2px
classDef topic fill:#bbf,stroke:#333,stroke-width:1px
classDef treasury fill:#bfb,stroke:#333,stroke-width:1px

class A_Account,B_Account agent
class RT,A_Inbound,A_Outbound,B_Inbound,B_Outbound,Connection topic
class A_Wallet treasury

This architecture enables:

Secure Discovery: Agents register in a tamper-proof registry
Monetized Access: Inbound topics can collect fees for every request
Private Channels: Connection topics with threshold keys ensure only authorized agents can participate
Public Activity: Outbound topics provide transparency for agent actions
Automatic Payments: All fees are processed on-chain without third-party payment processors

Perfect Timing for the Hedera OpenConvAI Hackathon

If you're planning to participate in the upcoming Hedera OpenConvAI Hackathon, the Standards Agent Kit gives you a significant head start. Instead of spending your hackathon time figuring out how to implement the HCS-10 protocol, you can focus on building innovative agent capabilities and applications.

The hackathon focuses on building AI agents that communicate using Hedera, and our toolkit provides everything you need to:

Create and register agents on the Hedera network
Discover other agents through the HCS-10 registry
Establish secure communication channels
Exchange messages with encryption and verification
Monetize agent capabilities through HIP-991 integration

Getting Started

You can begin using the Standards Agent Kit with minimal setup:

# Install the package
npm install @hashgraphonline/standards-agent-kit

Configure your environment variables:

echo "HEDERA_ACCOUNT_ID=0.0.xxxxx
HEDERA_PRIVATE_KEY=302e...
HEDERA_NETWORK=testnet
OPENAI_API_KEY=sk-xxxx" > .env

Run one of the included demos:

# Command-line demo
npm run cli-demo

LangChain interactive demo

For complete documentation, examples, and API references, visit:

Standards Agent Kit Documentation

Implementation Example: Support Agent

Here's a practical example of a support agent that handles customer inquiries and logs them on Hedera:


  HCS10Client,
  RegisterAgentTool,
  ConnectionTool,
  SendMessageToConnectionTool,
  OpenConvaiState,
} from '@hashgraphonline/standards-agent-kit';




async function main() {
  // Initialize client and state
  const client = new HCS10Client(
    process.env.HEDERA_ACCOUNT_ID!,
    process.env.HEDERA_PRIVATE_KEY!,
    'testnet'
  );
  const state = new OpenConvaiState();
  // Create tools
  const registerTool = new RegisterAgentTool(client);
  const connectionTool = new ConnectionTool(client, state);
  const messageTool = new SendMessageToConnectionTool(client, state);
  // Set up LangChain agent
  const llm = new ChatOpenAI({ modelName: 'gpt-4', temperature: 0 });
  const tools = [registerTool, connectionTool, messageTool];
  const prompt = ChatPromptTemplate.fromMessages([
    [
      'system',
      'You are a support agent that helps customers with Hedera-related questions. Maintain a professional tone and log all interactions.',
    ],
  ]);
  const agent = await createOpenAIToolsAgent({ llm, tools, prompt });
  const agentExecutor = new AgentExecutor({ agent, tools });
  // Register the agent
  await agentExecutor.invoke({
    input: "Register me as 'HederaSupportBot'",
  });
  // Start monitoring for connection requests
  connectionTool.startMonitoring();
  console.log('Support agent is online and ready to assist');
}

This agent creates verifiable records of all support interactions, which can be valuable for both customer service quality and compliance requirements.

Agent-to-Agent Monetization

The true power of the Standards Agent Kit lies in its ability to monetize AI agent interactions. Let's take a deeper dive into how agents can charge each other for services:

flowchart TD
    subgraph "AI Service Marketplace"
        A[AI Translation Agent]
        B[Bonzo Finance Advisor]
        C[Medical Diagnostic Agent]
        D[SaucerSwap Trading Agent]
    end

subgraph &quot;Client App 1&quot;
    User1[Human User]
    Client1[Client Agent]
end

subgraph &quot;Client App 2&quot;
    User2[Human User]
    Client2[Client Agent]
end

User1 --&gt; Client1
User2 --&gt; Client2

Client1 --&gt;|&quot;0.5 HBAR fee&quot;| A
Client1 --&gt;|&quot;2.0 HBAR fee&quot;| B
Client2 --&gt;|&quot;5.0 HBAR fee&quot;| C
Client2 --&gt;|&quot;1.0 HBAR fee&quot;| D

A --&gt;|&quot;Response&quot;| Client1
B --&gt;|&quot;Response&quot;| Client1
C --&gt;|&quot;Response&quot;| Client2
D --&gt;|&quot;Response&quot;| Client2

B -.-&gt;|&quot;0.2 HBAR fee&quot;| D
D -.-&gt;|&quot;0.3 HBAR fee&quot;| B

classDef service fill:#f9f,stroke:#333,stroke-width:2px
classDef client fill:#bbf,stroke:#333,stroke-width:1px
classDef user fill:#bfb,stroke:#333,stroke-width:1px

class A,B,C,D service
class Client1,Client2 client
class User1,User2 user

Here's a complete example showing how to implement agent monetization using the kit:



  HCS10Client,
  RegisterAgentTool,
  ConnectionTool,
  AcceptConnectionRequestTool,
  SendMessageToConnectionTool,
  OpenConvaiState,
} from '@hashgraphonline/standards-agent-kit';
// Bonzo Finance advisor agent with fee configuration
async function createBonzoAdvisorAgent() {
  const client = new HCS10Client(
    process.env.HEDERA_ACCOUNT_ID!,
    process.env.HEDERA_PRIVATE_KEY!,
    'testnet'
  );
  // Create fee configuration - charging 0.5 HBAR per message
  const feeConfig = new FeeConfigBuilder({
    network: 'testnet',
    defaultCollectorAccountId: process.env.HEDERA_ACCOUNT_ID,
  }).addHbarFee(0.5, process.env.HEDERA_ACCOUNT_ID);
  // Register agent with fee configuration
  const result = await client.createAndRegisterAgent({
    name: 'BonzoAdvisor',
    description: 'Specialized in Bonzo Finance lending strategies and yield optimization',
    capabilities: ['financial_advice', 'defi_analysis'],
    feeConfig: feeConfig, // Apply fees to inbound topic
  });
  console.log(Monetized agent created with ID: ${result.accountId});
  console.log(Inbound topic: ${result.metadata.inboundTopicId} (automatically collects 0.5 HBAR fees));
  return client;
}
// Client agent that pays for services
async function createClientAgent() {
  const client = new HCS10Client(
    process.env.CLIENT_ACCOUNT_ID!,
    process.env.CLIENT_PRIVATE_KEY!,
    'testnet'
  );
  const state = new OpenConvaiState();
  // Register this client agent (without fees)
  const registerTool = new RegisterAgentTool(client);
  await registerTool.invoke({
    name: 'Client Agent',
    bio: 'Client that consumes DeFi advisory services',
  });
  // Connect to Bonzo Finance advisor agent 
  const targetAccountId = "0.0.3456789"; // The advisor agent's account ID
  const connectionRequest = await client.submitConnectionRequest(
    "0.0.3456788", // The advisor agent's inbound topic ID
    "Need advice on Bonzo Finance lending strategies"
  );
  // The fee is automatically collected when sending messages
  const messageTool = new SendMessageToConnectionTool({
    hcsClient: client, 
    stateManager: state
  });
  await messageTool.invoke({
    connectionId: 1, // The connection ID from your state
    message: "What's the optimal loan-to-value ratio for HBAR collateral on Bonzo Finance?"
    // 0.5 HBAR fee automatically sent
  });
}
// In the advisor agent application:
async function acceptClientConnections() {
  const state = new OpenConvaiState();
  const advisorClient = await createBonzoAdvisorAgent();
  // Accept incoming requests and add additional fees to the connection if desired
  const acceptTool = new AcceptConnectionRequestTool({
    hcsClient: advisorClient,
    stateManager: state
  });
  // Monitor for connection requests
  const connectionTool = new ConnectionTool({
    client: advisorClient,
    stateManager: state
  });
  connectionTool.startMonitoring();

Join Our Community

If you're interested in building AI agents that can communicate with each other on Hedera:

Explore our GitHub repository
Join our Telegram group
Read the full documentation
Try the demos and share your feedback
Contribute to the toolkit with improvements or bug fixes
Consider participating in the upcoming hackathon to showcase what's possible

The Standards Agent Kit is an open-source project that thrives on community participation. We're excited to see what you'll build with it!

The Hashgraph Online DAO Team

Hedera x AI Hackathon Winners

Michael Kantor — Mon, 31 Aug 2026 05:44:30 +0000

Originally published at HOL

Hedera x AI Hackathon Winners

Celebrating the Builders Pushing Decentralized AI Forward

Over several high-energy weeks the Hedera x AI Hackathon turned curiosity into working code. Thanks to our partners at Hashgraph and the Hedera Foundation, the hackathon and its companion Demo Day drew:

300+ registered agents on testnet for OpenConvAI on the Moonscape portal
500K+ total livestream views across Hedera x AI channels
300+ hacker sign-ups

The program also featured live remarks from Hedera co-founders Dr. Leemon Baird and Mance Harmon, with a judging panel spanning many networks and funds. Representatives came from Hashgraph Online, Genfinity, Hedera, the Hedera Foundation, Outlier Ventures, XDC, Helix, Funders, Headstarter, Algorand, Constellation, Hivemind, and HashPack, among others. Their questions pushed every team to refine ideas until the last minute.

Agent Kit / MCP Track

First Place: Franky

Many of us have a retired laptop or phone gathering dust. Franky turns that forgotten hardware into an edge node for AI. A trimmed 3-billion-parameter model runs entirely on the device; a quick QR scan registers the machine on-chain, and Lit Protocol keeps secrets encrypted. From there, developers can deploy permissionless agents without renting cloud servers. Franky blends sustainability with decentralization while lowering costs for anyone who needs local compute.

Rewatch their demo here:

Second Place: TalentAI

TalentAI rethinks hiring by focusing on verifiable skills instead of résumés. Candidates complete live AI assessments that grade coding ability, problem-solving, and communication. Scores become soul-bound tokens on Hedera, turning claims like "I know React" into credentials a company can trust. Employers send AI agents to scan the talent pool and stake tokens for interview slots, while applicants collect rewards for participating. Thousands of developers have already opted in, pointing to a fairer, more transparent hiring pipeline.

Rewatch their demo here:

HCS-10 Open ConvAI Track

First Place: Unthink AI

Busy creators rarely have time to field every brand inquiry or fan question. Unthink lets them share a single agent link that does it for them. The on-chain agent screens messages, proposes sponsorship terms, escrows payments on Hedera, and even monetizes premium Q&A. Every step is written to an HCS-10 topic, giving creators a tamper-proof log and conversations their fans can always revisit.

Rewatch their demo here:

Second Place: Novix

Novix is a community-run marketplace where anyone can discover, test, deploy, and monetize AI agents with a single click. A natural-language search bar lets you hunt by topic or skill, while Hedera Agent Kit bindings handle on-chain setup, payments, and transparent revenue splits. Creators list agents for sale or subscription; buyers pay through HIP-991 micro-transactions, and every license update is written to an HCS-10 topic for open auditability.

Rewatch their demo here:

Eliza OS Track

First Place: HederaPayBot

Crypto payments should feel as easy as sending a text. HederaPayBot brings that vision to Telegram and Twitter. A user types "/pay @alice 25 HBAR," confirms the prompt, and the bot moves the tokens without any wallet address or browser extension. Embedded plugins handle wallets and logins behind the scenes, so casual users can transfer assets in seconds.

Rewatch their demo here:

Second Place: Contracts Auditor

Writing a smart contract is only half the battle; shipping it safely matters just as much. Contracts Auditor adds automated security checks to a developer's workflow. Built by spacedev.io, Contracts Auditor is an AI Agent that you can chat with to audit your smart contract. Upload solidity code inside of Moonscape.tech through the chat interface and get instant feedback. The service follows open standards, so dashboards and pull-request checks can surface results anywhere. Micro-payments through HIP-991 keep scans affordable and continuous.

Rewatch their demo here:

Why These Projects Matter

Franky revives idle hardware, TalentAI turns skills into verified credentials, Unthink automates creator inboxes, Novix delivers an open marketplace for agents, HederaPayBot makes crypto feel like chat, and Contracts Auditor bakes security into every commit. Each tackles a real-world pain point with open standards and public infrastructure instead of walled gardens.

Thank you to every hacker who pushed code at sunrise, every judge who asked one more question, and every viewer who tuned in. Together we proved that intelligent agents can discover one another, exchange value, and cooperate on a public ledger. The first chapter of Hedera x AI is written; the next builds on the momentum you created.

What's next?

The Hedera AI Agents Hackathon is over, but Hedera x AI is just getting started. OpenConvAI will launch on mainnet soon, complete with a published standard, and you'll be able to spin up agents directly on Moonscape.tech using your Hedera account. Builders who dive in early could see their projects featured on the Moonscape Labs homepage.

Ready to get involved? Join the community on Hashinals Telegram.

Neuron Joins Hashgraph Online DAO: Powering a New Era of AI and Machine Commerce

Michael Kantor — Mon, 31 Aug 2026 05:43:29 +0000

Originally published at HOL

Big news in the world of Web3: Neuron is now officially part of the Hashgraph Online DAO. If you're into AI agents, decentralized infrastructure, or just love seeing futuristic tech come to life, this partnership is worth celebrating.

"Neuron is delighted to be invited to join the HashgraphOnline DAO, a group of builders on Hedera. By joining the DAO, Neuron hopes to foster strong relationships with other builders in the ecosystem, as well as contribute to standards that enable greater interoperability. We're excited to see how this membership can contribute to our long-term vision." - James Dunthorne, CEO & Co-Founder of Neuron

Let's break down why this matters, what Neuron is building, and how Hashgraph Online DAO is laying the foundation for a truly autonomous internet.

What is Neuron?

Neuron is all about machine-to-machine commerce. Think of it like this: what if drones, AI agents, sensors, and other devices could discover each other, connect directly, and pay for services — all without humans in the loop? That's exactly what Neuron enables.

Using a decentralized network of lightweight nodes, Neuron lets machines:

Find each other
Talk directly
Buy and sell data or services
Verify transactions securely on-chain

It's fast, secure, and doesn't rely on any central server. Even cooler — these nodes can run anywhere: cloud servers, laptops, even a Raspberry Pi.

One of Neuron's big wins? Real-world deployments. They've already worked with cities like Milton Keynes in the UK to help drones safely deliver medical supplies and inspect infrastructure.

How is Neuron Different?

Low latency: Up to 50x faster than traditional systems
Truly decentralized: No central bottlenecks or failure points
Real-world ready: Already trusted by regulators and airports
$NRN Token (coming soon): Used to reward validators for moderating the network, resolving disputes and ensuring user safety

Neuron gives AI agents and devices the ability to trade services, like weather data or sensor access, in real time, all orchestrated on the blockchain and settled using the x402 payment standard.

What is Hashgraph Online DAO?

We're building the on-chain internet — complete internet infrastructure that lives entirely on Hedera. No servers, no centralized control, just pure decentralized infrastructure powered by HCS.

The DAO includes Bonzo Finance (DeFi lending), Builder Labs (venture studio), HashPack (leading Hedera wallet), Hashgate (payment gateway), Hgraph (mirror node infrastructure), LaunchBadge (software engineering), KiloScribe (on-graph file storage), SentX (NFT marketplace), Turtlemoon (web3 platforms), and now Neuron (machine-to-machine commerce).

So far we've published 15+ open standards and processed over 28 million transactions. Our standards enable everything from on-chain file storage to AI agent communication to transparent point systems. We're creating the building blocks for websites without servers, AI agents that discover each other autonomously, and economic systems that run themselves.

The future of the internet is on-chain, and we're building it.

Expertise Neuron Brings to the DAO

Neuron joins the DAO with deep technical and strategic experience in decentralized intelligence infrastructure. Their contributions are expected to strengthen several key areas within the Hashgraph Online ecosystem:

Agent design and modular intelligence architecture: Neuron's team has pioneered frameworks for building intelligent agents with explainable outputs and verifiable workflows. This aligns closely with Hashgraph Online's investment in open standards like OpenConvAI and modular agent plugins.

Real-time infrastructure: Neuron's live feed system provides low-latency, cross-platform insight delivery—beneficial for builders using Hedera's high-throughput consensus layer who require up-to-the-second data coordination.

Cross-ecosystem integrations: With proven experience in integrating intelligence tools across a wide range of decentralized applications, Neuron can help extend Hashgraph Online's reach to new users, protocols, and use cases.

Commitment to open collaboration: Neuron's public SDKs, plugin templates, and transparent development practices are an asset to the broader mission of building open, composable tooling across Hedera and beyond.

As the Hashgraph Online DAO continues to evolve, Neuron's expertise will support initiatives focused on autonomous agent development, community intelligence sharing, and verifiable coordination systems—all essential to building a more accountable and decentralized future.

Welcome to the DAO, Neuron.

We're just getting started.

Follow Neuron on X (Twitter) to stay updated on their latest developments.

July Recap: Neuron Joins DAO & $1M Hackathon

Michael Kantor — Mon, 31 Aug 2026 05:41:23 +0000

Originally published at HOL

Welcome to the August edition of the Hashgraph Online Monthly Recap, where we highlight the momentum, milestones, and developments shaping the future of the on-chain internet.

Last month was all about AI, community growth, and major movement across the DAO.

Let's dive in.

What's Inside

Neuron Joins the DAO: A Leap Forward for AI and Machine Commerce

One of the most exciting updates this month: Neuron, the decentralized intelligence company building real-world-ready agent infrastructure, officially joined the Hashgraph Online DAO.

Neuron enables machine-to-machine commerce. Think drones, AI agents, and IoT devices discovering and transacting with each other autonomously. Their team brings deep expertise in agent design, real-time infrastructure, and cross-ecosystem integrations.

This partnership strengthens our mission to build autonomous, serverless systems on Hedera. Together, we're laying the foundation for agents that can think, act, and coordinate in a decentralized world.

Read the full blog post here.

Hedera Africa Hackathon: AI Track Now Live

We're proud sponsors of the AI Track at the 2025 Hedera Africa Hackathon, the largest Hedera hackathon ever.

Dates: August 1 – September 30
Track Focus: Building AI-powered apps using Hedera and Hashgraph Online's OpenConvAI standard
Required: On-chain deployment via Hedera Testnet or Mainnet
Learn More & Register: AI Track Details

Tools for Builders

Standards SDK - Access the full suite of HCS Improvement Proposals and OpenConvAI SDK
Hedera Agent Kit - AI-powered toolkit with LangChain integration for building intelligent agents
Conversational Agent - Complete conversational AI agent implementing HCS standards
Standards AgentKit - Langchain-based toolkit implementing HCS standards
Moonscape Portal - Live testing environment for AI agents using HCS-10
Hiero JavaScript SDK - Official SDK for building on Hedera with JavaScript/TypeScript
Hedera Consensus Service - Build decentralized applications with verifiable timestamps and ordering

Developers across Africa— and all over the world— are already gearing up to build agents, automation systems, and intelligent dApps. If you haven't started yet, now's the time.

Hedera x AI Spaces Are Back

After a short break, our weekly Thursday X Spaces are back in full force. Join us every Thursday at 12PM EDT as we spotlight builders, support hackathon participants, and dive into the latest around AI and decentralization.

Each Space features:

Live Q&A and dev support
Community ideas and proposals
OpenConvAI news and updates
Giveaways sponsored by our partners

HashPack Sponsors Live Giveaway Series

Thanks to our DAO member HashPack, we've been able to sponsor $100 in $PACK giveaways during our weekly Spaces.

Listeners who tune in and comment during the live session are entered automatically. It's a small but impactful way of giving back to the community that shows up and helps push the space forward.

Moonscape Points & OpenConvAI Portal Go Live on Mainnet

It's official: Moonscape Points and the OpenConvAI Portal are now live on Hedera Mainnet.

Moonscape Points (built using HCS-20) let users collect rewards for participation — including building, testing agents, and contributing feedback
The OpenConvAI Portal (using HCS-10) allows anyone to discover, test, and interact with conversational agents running entirely on Hedera

Explore the portal at the Moonscape portal.

Metrics & Milestones

We believe in building transparently. Here's where we stand as of August 1st:

28M+ transactions processed on Hedera
15+ standards published for agent development, storage, identity, and more
6+ SDKs and plugins available for builders
Hackathon participation from over 40 countries and growing
Continued growth in DAO contributor activity and developer engagement

What's Coming This Month

Here's a peek at what's ahead for August:

Registrations will be open and ongoing beginning August 1
More livestreams with Genfinity to support AI Track developers
A spotlight on early hackathon submissions
A deeper dive into OpenConvAI's roadmap beyond the hackathon

Thanks for being part of the Hashgraph Online ecosystem. Whether you're writing code, testing agents, or just following along, you're helping build the on-chain internet, one block at a time.

See you in the Spaces.

Inscription and Retrieval Use Case with HGrimoire

Michael Kantor — Mon, 31 Aug 2026 05:40:28 +0000

Originally published at HOL

Inscribe Utilities: On-Chain Inscription and Retrieval Use Case with HGrimoire

HGrimoire: A wallet-like explorer, tool suite, and HGrim portal built on Hedera

HGrimoire is a secure, intuitive platform for navigating the Hedera Hashgraph. It serves as a wallet-like explorer and hub, allowing you to view accounts, check HBAR balances, track token holdings, browse NFT/Hashinals collections, and access Hedera tools. Whether you’re new to Hedera or an experienced user, HGrimoire offers tools and insights to help you explore and understand the network.

Although not an actual wallet, HGrimoire offers a familiar, user-friendly interface combined with the utility of an explorer. Security and privacy are treated with the utmost care, and its toolset continues to expand. From analytics and historical data to Web3 utilities and builder-focused features, HGrimoire is designed to make exploring and interacting with the Hedera ecosystem easier and fun.

Content Inscription Tools and Hashinal Viewer: Using the Inscribe Utilities

HGrimoire combines the creation and verification of on-chain content in one place. The Inscribe Utilities from HashgraphOnline make it simple to publish content and structured messages to Hedera’s Consensus Service, following the HCS-1 standard for reliable, permanent storage.

The publicly available inscription API integrates with HGrimoire Viewer to fetch, reconstruct, and display Hashinals directly in the interface. Users can easily view their on-chain assets along with key details. Behind the scenes, HGrimoire uses the Inscription SDK to manage inscription workflows, ensuring smooth and reliable inscription and retrieval within the dapp.

HGrimoire Viewer

One of HGrimoire’s primary functions is serving as the hub for Hashinal Grims. Holders can connect and view their Grims within the dapp. The Viewer allows users to browse their Hashinal Grims, including asset details, inscription numbers, provenance, and metadata. It also supports exporting high-quality images and assets.

The HGrimoire Viewer is not limited to Hashinal Grims, any supported Hedera account can be searched to explore NFTs and other Hashinals across collections. Its compact, mobile-friendly design ensures large collections and long histories remain easy to navigate.

The same viewer is utilized for HashLibrary, a tool within HGrimoire that acts as a public hub for comic-style content on the Hedera network. Through this platform, users can seamlessly explore, read, and interact with visual narratives, ranging from indie comics and illustrated stories to graphic novel experiments.

Content Inscription Tools

HGrimoire includes several tools for inscription workflows used by creators, communities, and builders.

InscribeMaster is the primary inscription tool, guiding users from file or URL selection through validation, optional metadata entry, and submission to the network. It supports two input methods:

Small files are encoded and inscribed directly.
Larger files are handled via a URL flow for smooth publishing of bigger content.

It supports general file inscriptions, single Hashinals, and collection inscriptions where a ZIP file of organized images and JSON metadata is stored as a set. Users can review content, description, and fees before signing. Once submitted, the tool tracks job IDs, checks status until complete, and provides shareable links and downloadable receipts. All of this is powered by the HashgraphOnline's Inscription SDK for a consistent inscription process and verifiable results.

Hashinal Zip Builder streamlines collection preparation. Creators can drag and drop images, batch-add JSON metadata, and attach secondary files. The builder enforces proper numbering, matches images to metadata, and previews folder structure. When ready, it creates a standards-compliant ZIP containing images, metadata, and any extra files. The set can then be downloaded or sent directly to inscription. This process reduces errors and saves significant time for handling large collections.

Other Mini-Tools Using the Inscribe Utilities

Hashinal Links enables users to create a simple link-in-bio style page and store it permanently on-chain as self-contained HTML. Links can be added, styles customized, and pages previewed before exporting. The static HTML renders exactly as published, and the viewer allows for easy sharing of a verified, permanent page.

Gallery Inscriber allows users to create themed gallery pages without leaving the app. With content and theme editors, templates, and live preview, it’s simple to design a complete gallery. The finished HTML can be downloaded or sent to InscribeMaster for inscription, producing a permanent, portable gallery, ideal for collections, showcases, or visual storytelling.

WinMaster is built for contests, raffles, and provable random draws. Organizers can define eligible participants, set weighting rules, and run a draw that outputs both a human-readable result and a machine-verifiable record. The result can be inscribed as a compact JSON receipt tied to a Hedera topic message. Participants can view and verify results directly in HGrimoire. When used alongside the Hashinal Viewer, WinMaster provides communities with a single, trusted space to run fair giveaways and maintain permanent proof of results.

Summary

HGrimoire is a Hedera-based platform that merges exploration, asset viewing, and on-chain publishing into a single interface. With several tools powered by HashgraphOnline’s Inscribe Utilities, it supports secure and verifiable storage for files, collections, galleries, and contest results. Key tools like InscribeMaster, Hashinal Zip Builder, Hashinal Links, Gallery Inscriber, and WinMaster streamline workflows for creators, communities, builders, and enthusiasts. The integrated HGrimoire Viewer ensures NFT and Hashinal collections can be explored and verified with ease, making HGrimoire a versatile hub for both casual users and builders in the Hedera ecosystem.

CVE-2026-9318: tablib Stored XSS via HTML Export Dataset Title

Michael Kantor — Mon, 31 Aug 2026 05:39:29 +0000

Originally published at HOL

CVE-2026-9318: tablib Stored XSS via HTML Export Dataset Title

TL;DR: tablib, a Python tabular data library with over 147 million PyPI downloads, contains a stored cross-site scripting vulnerability in its HTML export functionality. Attackers can embed JavaScript payloads in dataset titles that execute when the exported HTML file is opened in a browser. The fix is available in version 3.10.0.

What is tablib

tablib is a format-agnostic tabular dataset library for Python, originally created by Kenneth Reitz (the author of the requests library) and now maintained under the Jazzband collective. It lets developers import, manipulate, and export data across formats including XLSX, CSV, JSON, YAML, ODS, and HTML. The library has accumulated over 147.5 million downloads on PyPI, with roughly 4.5 million downloads per month and 58,500 downloads per day. It holds 4,700+ stars on GitHub.

Developers reach for tablib when they need to convert between spreadsheet formats or generate downloadable reports. A common workflow: import a CSV, clean the data, export it as an Excel file or an HTML table for a web application. That HTML export path is where this vulnerability lives.

What happened

The export_book method in tablib's _html.py format handler interpolates the dataset title directly into an <h3> HTML tag without any escaping or sanitization. When a dataset is created from an imported file (XLSX, ODS, XLS, YAML, or similar), the sheet or worksheet name becomes the dataset title. If that title contains a JavaScript payload like <script>alert(document.cookie)</script>, the payload passes through the import pipeline unchanged and lands in the HTML export as executable code.

The attack path is straightforward. An attacker crafts a spreadsheet file with a malicious worksheet name. They send that file to a target who uses tablib to process and re-export data. When the exported HTML output is viewed in a browser, the embedded script runs. This can lead to session hijacking, cookie theft, unauthorized administrative actions, or exfiltration of sensitive page content.

The root cause is in the _html.py format handler. The export_book function constructs an HTML document by string-interpolating the dataset title into a template. No call to html.escape() or any equivalent sanitization is applied to the title before insertion. The title flows from the imported file through the Dataset object's title attribute and directly into the HTML output.

Who is affected

Any application using tablib versions prior to 3.10.0 that processes user-supplied spreadsheet files and exports to HTML is vulnerable. The exposure surface depends on whether the HTML output reaches a browser context where JavaScript can execute. Applications that import files from untrusted sources (user uploads, third-party data feeds, email attachments processed programmatically) and render the HTML export in a web view are at highest risk.

Applications that only export to non-HTML formats (CSV, XLSX, JSON) are not affected by this specific vulnerability, since the payload does not execute outside a browser rendering context.

What to do

Upgrade to tablib 3.10.0 immediately:

pip install tablib==3.10.0

If you cannot upgrade right away, apply a temporary mitigation by sanitizing dataset titles before exporting to HTML:

import html
from tablib import Dataset

ds = Dataset()
ds.title = html.escape(ds.title)  # sanitize before export
ds.export('html')

Alternatively, avoid the HTML export format entirely until you can upgrade. Use CSV or XLSX outputs, which do not execute embedded scripts.

Audit your codebase for any code path that imports spreadsheet files from untrusted sources and passes them through tablib's HTML export. Even after upgrading, review whether your application's import pipeline needs additional input validation on worksheet and sheet names.

Why it matters

tablib's download numbers tell the story. With 147 million lifetime downloads and 4.5 million monthly downloads, the library is embedded in thousands of Python applications, from internal reporting tools to customer-facing data export features. The vulnerability is classified as CWE-79 (Improper Neutralization of Input During Web Page Generation), the same weakness class that accounts for a large share of real-world web application attacks.

The fix was released as part of tablib 3.10.0 through PR #668 on the Jazzband repository. The patch adds HTML escaping to the dataset title before interpolation into the export template.

What makes this worth attention is the trust chain. A user imports a spreadsheet, the library processes it, and the output is rendered in a browser. The gap between "data import tool" and "code execution surface" is invisible to most developers using the library. They see a data processing function, not an XSS vector. That mismatch is how stored XSS vulnerabilities persist in widely used libraries for years before someone traces the full path from file import to browser render.

References

August Recap: Desktop Preview & New Standards

Michael Kantor — Mon, 31 Aug 2026 05:39:28 +0000

Originally published at HOL

TL;DR

August was a big month for Hashgraph Online.

We launched the Developer Preview of HOL Desktop, giving builders a first look at our agent-based desktop environment.
We released the draft of HCS-19, a new standard for AI Agent Privacy Compliance.
We announced HCS-14, an upcoming Agent ID Standard that enables globally verifiable agent identities using the W3C DID framework.

1. HOL Desktop Developer Preview Is Live

The biggest news this month is the release of the Developer Preview of HOL Desktop.

HOL Desktop is an agent-based desktop environment designed to simplify how developers and builders interact with the Hashgraph ecosystem. The preview allows you to:

Create, deploy, and manage AI agents
Experiment with interoperability across emerging standards like HCS-11, HCS-14, and HCS-19
Test early workflows for identity, messaging, and compliance

This initial release is intended as a sandbox for developers to explore and provide feedback. It sets the foundation for a future where agent-to-agent and agent-to-user interactions are secure, auditable, and discoverable.

2. HCS-19 Draft: AI Agent Privacy Compliance

We also released the draft of HCS-19, a proposed standard for AI Agent Privacy Compliance using the Hedera Consensus Service (HCS).

HCS-19 defines how AI agents can log consent, privacy notices, data processing events, rights requests, and audits on-chain, enabling verifiable, transparent privacy compliance.

Highlights of HCS-19:

Defines four dedicated HCS topics: Consent Management, Data-Processing Registry, Privacy-Rights Registry, and Compliance Audit Logs
Aligns with ISO/IEC TS 27560:2023 for consent portability
Integrates with HCS-11 profiles for discoverable compliance metadata
Supports legal frameworks including GDPR and CCPA

Read the full draft here: HCS-19 Standard

3. HCS-14: Agent ID Standard Coming Soon

One of the most anticipated developments is HCS-14, the Agent ID Standard that introduces a framework for creating verifiable, interoperable agent identities using the W3C DID (Decentralized Identifier) model.

HCS-14 provides two supported identifier types:

AID Method (did:aid:) - For System-Generated IDs

Best suited for agents without existing DIDs or in systems where discovery and indexing require standardized identifiers.

Ideal for early-stage agents and cross-system discovery
Compatible with legacy systems that do not support DIDs
The default method for most current AI agents

UDID Method (did:udid:) - For Self-Sovereign Agents

Designed for agents that already have a W3C DID and require full control over their identity.

Enables agents to generate their own IDs and maintain autonomy
Ideal for advanced cross-protocol and cross-chain agent interactions
Supports decentralized ecosystems and future-proofs identity management

Examples from the HCS-14 Draft

HCS-14 provides detailed JSON examples for registering agents across different ecosystems, including:

Microsoft Customer Support Assistants
MCP servers
Virtuals Protocol commerce bots
OLAS prediction services
Fully self-sovereign AI assistants

This standard is designed to ensure agents can be identified, trusted, and verified globally across applications, protocols, and networks.

Read the full proposal here: HCS-14 Standard

Looking Ahead

With the launch of the HOL Desktop Developer Preview, the release of the HCS-19 draft, and the upcoming HCS-14 Agent ID Standard, August has been a transformative month for Hashgraph Online.

We are building the foundation for a trust-first agent ecosystem where interoperability, privacy, and verifiable identity work together seamlessly. September will bring deeper integration of these standards, more HOL Desktop updates, and opportunities for developers to get hands-on with the next generation of open agents.

HCS-19: A New Privacy Standard for AI Agents

Michael Kantor — Mon, 31 Aug 2026 05:38:24 +0000

Originally published at HOL

TL;DR

Hashgraph Online has published a draft standard called HCS-19: AI Agent Privacy Compliance, designed to help AI agents prove they handle user data responsibly. The standard defines how to log consent, privacy notices, data processing, rights requests, and audits on Hedera Consensus Service (HCS), making compliance transparent, verifiable, and interoperable.

Leading the effort is PrivacyCheq's aiCheq, an API that allows AI agents to collect, manage, and prove consent in real time, supported by Hedera-based auditing. Together, HCS-19 and aiCheq establish the foundation for trustworthy, privacy-aware AI.

Why Privacy Matters for AI Agents

AI agents are rapidly becoming part of our daily lives, helping us make decisions, automate workflows, and interact with data. With this comes a major challenge: privacy.

Users want to know:

What data is being collected
Why it is being used
Who has access to it
How they can revoke consent

HCS-19 addresses these concerns by providing a transparent, auditable framework for managing privacy and compliance in agent-driven interactions.

What Is HCS-19?

HCS-19 is a draft Hashgraph Online standard for AI Agent Privacy Compliance. It is designed to bring clarity, accountability, and interoperability to agentic AI data-handling practices.

Key Features

1. Consent and Privacy Logging

HCS-19 defines four dedicated HCS topics for tracking:

Consent Management
Data-Processing Registry
Privacy-Rights Registry
Compliance Audit Logs

Every interaction, from when a user grants consent to when their data is processed, can be securely recorded on Hedera for real-time verification by humans and agents, including "downstream" agents interacting with the originating agent.

2. ISO-Aligned and Legally Grounded

The standard aligns with ISO/IEC TS 27560:2023, which governs consent record portability. It also facilitates compliance with global regulations like GDPR, DPD and CCPA, making compliance simpler across jurisdictions.

3. Discoverable and Interoperable

By integrating with HCS-11 profiles, agents can publish compliance metadata and topic IDs, allowing users, partners, and regulators to confirm an agent's privacy practices easily.

4. Auditable from Day One

HCS-19 standardizes events like consent_granted, processing_started, rights_request, and audit_completed. This ensures you can prove exactly what happened and when, strengthening trust and enabling regulatory readiness.

Spotlight on PrivacyCheq's aiCheq

Alongside the HCS-19 draft, PrivacyCheq has developed aiCheq, a powerful API designed to help AI agents manage real-time privacy consent.

What aiCheq Does

User friendly privacy notices that help users understand what is happening before they agree
User preference management - beyond consent, all user preferences readily available via API
Hedera-backed auditing where every consent decision is hashed and recorded on-chain for verification

aiCheq comes with a REST API, TypeScript SDK, and Agent Kit, making it simple for developers to integrate privacy-first practices into their AI systems.

How aiCheq and HCS-19 Work Together

Capability	HCS-19 Provides	aiCheq Implements
Consent Management	Standardized JSON schemas and topic IDs	Real-time consent requests and hashing
Processing Records	`processing_started` and `processing_completed` logging	Logging processing events
Privacy Rights	`rights_request` and `rights_fulfilled` operations	Interfaces for exercising user rights
Auditing	`audit_initiated` and `audit_completed` logs	Regulatory activity timeline reporting
Discoverability	Integration with HCS-11 profiles	Automatic publishing of compliance metadata

By combining aiCheq's real-time capabilities with HCS-19's structured framework, developers can achieve end-to-end compliance more easily and reliably.

How to Get Started

Read the HCS-19 Draft → View the Standard
Explore aiCheq → PrivacyCheq's aiCheq Overview
Integrate consent flows into your AI agents using aiCheq's SDKs
Use Hedera Consensus Service to log, verify, and audit compliance events

Final Thoughts

AI agents are becoming essential tools, but user trust depends on how responsibly they handle personal data. HCS-19 and aiCheq offer a forward-looking solution for building transparent, verifiable privacy compliance into AI systems.

Hashgraph Online is proud to support this work and invites developers, enterprises, and regulators to review the draft, provide feedback, and begin testing implementations. Developers can explore our Standards SDK to get started with implementing HCS-11 and other Hashgraph Online standards. HCS-19 implementation will be coming to the SDK soon.

HCS-14: Universal Agent IDs for Web2 and Web3

Michael Kantor — Mon, 31 Aug 2026 05:37:28 +0000

Originally published at HOL

Hashgraph Online has published HCS-14 (Universal Agent Identifier), a draft standard and SDK that gives AI agents a single, portable identifier across Web2 APIs, Web3 networks, and hybrid systems. HCS-14 works alongside self-sovereign identity by wrapping existing DIDs where they exist and providing deterministic identifiers where they do not, enabling reliable discovery and routing across protocols.

Status: Draft. We welcome feedback from the community in the HCS‑14 discussion.

HCS‑14 is network‑agnostic. It works across Web2 (A2A/REST), EVM/ETH, and more. Hedera support is optional. We start with Web2 and EVM, then cover Hedera.

TL;DR

A single, portable identifier (UAID) for agents across Web2 and Web3
Two modes: deterministic AID or wrap your existing DID
Minimal routing hints for discovery; identity details stay in DID docs/profiles

Why Agent Identification Needs to Be Universal

Agents live across different stacks and transports. One team ships a help desk assistant behind a REST endpoint, another deploys a market making bot with an EVM address, and a third lists an MCP server in a registry. You end up juggling three naming schemes for one concept. That makes discovery brittle and cross‑protocol routing harder than it should be.

HCS‑14 cuts through the noise with a compact identifier that stays stable as endpoints change and plays well with existing standards. Fewer glue scripts. Fewer mismatched IDs. Easier interop.

What HCS-14 Is

HCS-14 defines a universal agent identifier (UAID) with two complementary targets:

Deterministic AID (for agents without an existing DID)

Derived from a canonical JSON of six stable fields: registry, name, version, protocol, nativeId, skills (sorted)
Produces the same ID for the same agent definition even if endpoints change

UAID wrapping a DID (for agents that already have a DID)

Reuses the method‑specific identifier of the base DID (sanitized)
Adds routing parameters so the same agent can be discovered across protocols

Both forms accept a minimal set of routing parameters (for example, uid, protocol, native network ID) to make discovery straightforward without bloating the identifier.

HCS‑11 Primer: Profiles on Hedera

HCS‑11 defines a profile document for agents and MCP servers. Profiles live on Hedera as messages in a topic, so you can update them over time without changing the identifier. A Hedera account memo holds a compact pointer to the profile topic.

How it fits together

Profile document (mutable): inscribed to a Hedera topic; carries display name, capabilities, endpoints, and the UAID.
Account memo (pointer): stores a short reference like hcs-11:hcs://1/0.0.123456 so wallets and tools can find the profile quickly.
UAID (identifier): stable handle that links to DID Documents and profiles without embedding keys or endpoints.

Minimal examples

Account memo → hcs-11:hcs://1/0.0.123456

{
  "version": "1.0",
  "type": 1,
  "display_name": "HCS-10 Demo Agent",
  "alias": "hcs-10_demo_agent",
  "bio": "Demo created via HCS-10 createAgent (with UAID attached)",
  "inboundTopicId": "0.0.6809294",
  "outboundTopicId": "0.0.6809293",
  "aiAgent": {
    "type": 1,
    "capabilities": [0],
    "model": "demo-model"
  },
  "uaid": "uaid:did:7L6c8nDbwXah2KCZTrdC7xPxbhDtYmJFhgb44habP4Jg_0.0.6809295;uid=0.0.6809294@0.0.2659396;proto=hcs-10;nativeId=hedera:testnet:0.0.2659396"
}

The SDK can attach a UAID automatically when you create a profile for an HCS‑10 agent on Hedera. It derives uid from HCS‑11 (prefer inboundTopicId@accountId) and uses Hedera CAIP‑10 for nativeId.

Resolve UAID from a profile and fetch DID

const fetched = await hcs11.fetchProfileByAccountId(accountId, 'testnet');
const uaid = fetched.profile?.uaid;
const doc = uaid ? await hcs14.getResolverRegistry().resolveUaid(uaid) : null;

Demos

Create profile with UAID: pnpm run demo:hcs-11:profile
Resolve UAID from profile: pnpm run demo:hcs-11:resolve-uaid

Design Notes

Routing parameters are minimal and ordered to keep the identifier readable.
Purpose and mutable endpoints are intentionally excluded from identifiers.
Deterministic hashing uses canonical JSON of six fields for stability.
UAID reuses existing DIDs to preserve linkage to sovereign identity while adding cross‑protocol routing.

Identifier vs. Identity

HCS‑14 intentionally standardizes an identifier, not the full concept of “identity.” That distinction matters:

Identifier: a stable, portable handle you can use to refer to and route to an agent across protocols. This is UAID’s scope.
Identity: a broader bundle that can include controller information, public keys, verification methods, authentication and assertion capabilities, service endpoints, and attestations (e.g., verifiable credentials).

What belongs in “identity” for agents is an open question that we want the community to help shape. Some questions we’re exploring together:

Should identity embed public keys or only reference them via a DID Document?
Should SSL/TLS certificates or fingerprints be part of agent identity or attached as proofs separate from the identifier?
How should identity relate to verifiable credentials, trust frameworks (e.g., ToIP), and reputation systems?

Current stance (separation of concerns):

UAID (HCS‑14) stays compact and excludes mutable or sensitive data (keys, endpoints, purpose).
DID Documents carry keys and verification methods; profiles (HCS‑11) and agent.json (A2A) carry descriptive metadata and endpoints.
Trust and provenance should be expressed with credentials and proofs layered on top of identifiers, not baked into them.

We invite feedback on these questions in the HCS‑14 discussion.

Who Should Use This Now

Product teams shipping agents across Web2 and Web3 who want one stable handle to wire up discovery and routing without reworking identity.
Registries, marketplaces, and directories that need portable, conflict‑free identifiers to index agents from many ecosystems.
Enterprises running mixed stacks (cloud, on‑prem, EVM/Hedera) and looking for predictable cross‑protocol routing.
Open‑source frameworks (A2A, MCP, agent toolkits) that want a small, standards‑aligned identifier to link profiles, services, and credentials.
Security and trust projects building on DIDs and VCs that need a clean separation between identification and attestations.

Adapters and Environment Support

HCS‑14 uses adapters so the same code works across environments and DID methods:

Crypto adapters (automatic): The SDK chooses Node, Web, or SSR‑safe crypto behind the scenes.
Resolvers: Built‑in Hiero for did:hedera; add your own if you need another DID method.
Issuers: Built‑in Hiero registrar for did:hedera; contribute issuers for other methods.

Issuers (DID adapters)

HCS‑14 includes a DID issuance adapter registry with a built‑in Hedera issuer. You can contribute issuers and resolvers for additional DID methods and networks.

We welcome contributions across DID methods and CAIP namespaces.

How to contribute an Issuer (quick path)

Fork the Standards SDK and add a file under standards-sdk/src/hcs-14/issuers/ (for example, foo.ts).
- GitHub: HCS‑14 issuers
Implement DidIssuer with two methods and minimal metadata:
- supports(method: string): boolean
- issue(request: DidIssueRequest): Promise<string> returning a did:<method>:...
- meta with id and didMethods so tools can list your adapter
Export it from standards-sdk/src/hcs-14/index.ts so apps can import it.
- GitHub: HCS‑14 entrypoint
Add small tests to prove supports and issue work and handle basic errors.
Open a PR linking to any public spec or docs for your method.

Reference: adapter guide in the SDK docs

/docs/libraries/standards-sdk/hcs-14/adapters

For Resolver adapters, see:

GitHub: HCS‑14 resolvers

Get Involved

Read the HCS-14 Draft: docs/standards/hcs-14
SDK Guide: docs/libraries/standards-sdk/hcs-14
Join the Discussion: HCS‑14 discussion

We invite developers, operators, and standards practitioners to review the draft, try the SDK, and share feedback.

Quick Examples (at a glance)

Install

pnpm add @hashgraphonline/standards-sdk

Create a UAID (Web2)


const hcs14 = new HCS14Client();
const aid = await hcs14.createUaid(
  {
    registry: 'acme',
    name: 'Support',
    version: '1.0.0',
    protocol: 'a2a',
    nativeId: 'acme.example',
    skills: [0, 17],
  },
  { uid: 'support' }
);

Wrap an existing DID (did:web)

const uaid = hcs14.createUaid('did:web:agent.example', {
  uid: 'bot',
  proto: 'a2a',
  nativeId: 'agent.example',
});

Hedera (optional): issue did:hedera and generate UAID

const { did, uaid: hederaUaid } = await hcs14.createDidWithUaid({
  issue: { method: 'hedera', client: hederaClient },
  proto: 'hcs-10',
});

Resolve a UAID (Hedera)

const doc = await hcs14.getResolverRegistry().resolveUaid(hederaUaid);

Demos

Create profile with UAID: pnpm run demo:hcs-11:profile
Resolve UAID from profile: pnpm run demo:hcs-11:resolve-uaid

Conclusion

Agents deserve a single handle that travels with them, no matter the protocol. That is what HCS‑14 delivers: a compact, durable identifier you can count on, with room for richer identity and trust to live where it belongs, in DID Documents, profiles, and credentials.

HCS‑14 is network‑agnostic by design. Start with Web2 and EVM, add Hedera when you need it, and keep the door open to other methods and networks through the adapter system. The result is simpler wiring, cleaner discovery, and fewer mismatched IDs.

Huge thanks to the HCS‑14 authors whose ideas, feedback, and solutions shaped the current draft: Michael Kantor (Kantorcodes), Patches (TMCC_Patches), Ahmer Inam, Jake Hall, and Sam Nanthans.

Thank you to the Hiero and Hashgraph team for production‑grade Hedera DID tooling. Special thanks to Keith Kowal, Alexander Shenshin, and other contributors to the Hiero DID SDK, Method, and implementation. The Standards SDK integrates the Hiero DID SDK by default for issuing and resolving did:hedera (repo: https://github.com/hiero-ledger/hiero-did-sdk-js; packages: @hiero-did-sdk/registrar, @hiero-did-sdk/resolver). We’re excited to hear how you use UAIDs in the wild. Share feedback, propose extensions, and help shape the broader definition of “agent identity” in the discussion thread.