How to Build a Hermes Agent Plugin

Build a Hermes Agent plugin with tools, hooks, commands, integrations, bundled Skills, memory providers, context engines, or model providers, then measure it with Telvine.

This guide explains how to build a Hermes Agent plugin and manage it as part of a broader Agent Plugin portfolio. Hermes Agent plugins can extend the runtime with custom tools, hooks, slash commands, CLI commands, integrations, bundled Skills, memory providers, context engines, and model providers.

Use the Hermes Agent plugin docs for the latest Hermes-specific packaging details. Use Telvine as the cross-harness product layer: one plugin identity, one component inventory, one telemetry contract, and adapters for Hermes, Codex, OpenClaw, Claude, Copilot Cowork, and direct SKILL.md targets.

1. Define the plugin product

Start with the installable product:

Plugin id: the stable id you keep across harnesses.
User: who installs or enables it.
Job: what work Hermes should help complete.
Hermes components: tools, hooks, commands, integrations, Skills, memory, context, or model providers.
Other adapters: Codex, OpenClaw, Claude, Copilot Cowork, or direct SKILL.md.
Telemetry: plugin, component, runtime, version, and outcome events.

Example: a research-briefing plugin could include a Hermes slash command, a source-checking Skill, a web research integration, and a hook that records completion metadata.

2. Create the source plugin workspace

Keep the plugin product separate from the Hermes adapter:

research-briefing/
├── telvine.plugin.json
├── skills/
│   └── source-check/
│       └── SKILL.md
├── tools/
│   └── citation-audit/
├── hooks/
│   └── after-run/
├── telemetry/
│   └── events.md
└── adapters/
    ├── hermes/
    ├── codex/
    ├── openclaw/
    └── claude/

telvine.plugin.json should describe the plugin product: owner, version, target harnesses, component inventory, and telemetry policy. The Hermes adapter should contain only the Hermes-specific manifest, registration, and runtime code.

3. Choose the Hermes extension points

Pick the Hermes plugin surfaces that match the job:

Hermes extension point	Use it when	Telvine component type
Tool	Hermes needs a callable action or deterministic helper	`tool`
Hook	You need lifecycle behavior before or after agent work	`hook`
Slash or CLI command	Users should trigger a named workflow directly	`command`
Integration	The plugin connects Hermes to an external app or service	`connector`
Bundled Skill	The plugin ships task-specific instructions and references	`skill`
Memory or context engine	The plugin changes retrieval, memory, or context assembly	`context_engine`
Model provider	The plugin adds or routes model access	`model_provider`

Bundled Skills are still capabilities inside the plugin. Measure them as components, not as loose files.

4. Build the Hermes adapter

Inside adapters/hermes/, create the package Hermes expects:

adapters/hermes/
├── plugin.yaml
├── __init__.py
├── schemas.py
├── tools.py
├── hooks.py
└── skills/
    └── source-check/
        └── SKILL.md

The adapter should register Hermes-facing metadata and extension points in Python. A typical Hermes plugin exposes a register(ctx) function, then calls APIs such as ctx.register_tool(...), ctx.register_hook(...), ctx.register_command(...), ctx.register_cli_command(...), or ctx.register_skill(...).

General user plugins are discovered under ~/.hermes/plugins/<name>/ and are opt-in: users enable them through hermes plugins enable <name> or by adding the plugin name to plugins.enabled in ~/.hermes/config.yaml. Project plugins can live under .hermes/plugins/ when project plugin loading is enabled.

Keep shared Skills, scripts, references, and telemetry rules in the source plugin workspace so the Hermes package can stay aligned with the Codex, OpenClaw, Claude, and Copilot Cowork adapters.

5. Instrument the plugin

Emit Telvine telemetry wherever the Hermes plugin controls execution:

Tool handlers.
Hooks.
Command handlers.
Integration backends.
Skill wrapper scripts.
Provider, memory, or context adapters.

Example:

{
  "event_type": "plugin.component.invoked",
  "plugin_id": "plg_research_briefing",
  "version": "0.9.0",
  "runtime": "hermes",
  "properties": {
    "component_type": "skill",
    "component_name": "source-check",
    "operation": "completed",
    "duration_ms": 961,
    "outcome": "completed"
  }
}

Do not collect prompts, documents, retrieved passages, connector payloads, tool arguments, or model outputs. Send metadata that helps the team understand adoption, reliability, latency, and version impact.

6. Release through adapters

Ship the Hermes package as one adapter for the plugin product:

Build the Hermes plugin package.
Build the Codex, OpenClaw, Claude, Copilot Cowork, or direct SKILL.md adapters for the same product if needed.
Register the plugin version and component inventory in Telvine.
Roll out to a small audience.
Compare Hermes behavior against other harnesses.

With Telvine:

npm i -g @telvine/cli
telvine login
telvine publish ./research-briefing

Checklist

The Hermes plugin has a stable plugin id and version.
Tools, hooks, commands, integrations, Skills, memory, context, and provider pieces are registered as components.
The Hermes adapter does not become the only source of truth.
Telemetry records runtime hermes plus component type, component name, outcome, and version.
The same product can be deployed through other harness adapters.