Best Hermes Agent Plugins in 2026: 8 Tools by Use Case

Hermes Agent can use tools, work with files, and retain context across sessions. Its plugins and integrations let developers adapt that foundation to more specific work: gathering information from the live web, taking action in business applications, or investigating why an agent run failed.
This guide compares nine Hermes plugins and integrations by the problems they solve. Each entry explains how the tool works, where it fits, its strengths and limitations, and how to get started; so developers can decide which additions are useful for their own setup.
TL;DR: Hermes plugins at a glance
Use the table to find the capability missing from the workflow, then read that entry for its setup and limitations. The list includes marketplace plugins, bundled plugins, memory providers, and an MCP integration; those categories determine how each tool connects to Hermes.
| Plugin or integration | Best for | Type |
|---|---|---|
| TinyFish | Web search, extraction, website operations | Marketplace plugin |
| Composio Connect | Business application workflows | MCP integration |
| Langfuse | Tracing and debugging agent runs | Marketplace plugin |
| Honcho | Personalized cross-session context | Memory provider |
| Hindsight | Fact and entity recall | Memory provider |
| Web Search Plus | Search-provider routing and fallback | Marketplace plugin |
| Google Meet | Meeting transcription and notes | Bundled plugin |
| Security Guidance | Warnings during code writing | Bundled plugin |
| Disk Cleanup | Eligible temporary-file cleanup | Bundled plugin |
These are recommendations by use case, not a benchmark ranking. Capabilities and setup paths were checked against official documentation on November 16, 2026. Commands are documentation-verified, not executed for this article; workflow examples are illustrative.
Use TinyFish in your agent
Add TinyFish to ChatGPT, Claude, Cursor and more in one click.
Connect TinyFish
What are Hermes Agent plugins?
Before installing an extension, it helps to distinguish the code that adds a capability from the instructions that tell an agent how to use it. Hermes supports both, along with separate connection paths for memory services and external tools.
General plugins add executable capabilities such as tools, commands, or hooks. A hook runs when a particular event occurs—for example, after a file-writing tool finishes. Skills instead supply reusable task instructions. A skill can explain how to conduct a review, but it still needs the appropriate tools to read files or query a service.
Memory providers supply additional context across sessions. Hermes permits one external memory provider at a time, alongside its built-in memory. MCP servers expose external tools through the Model Context Protocol, allowing Hermes to connect to services without requiring each one to become a native plugin.
For the tools below, Composio connects through MCP, Honcho and Hindsight use memory-provider setup, and the remaining entries use the general plugin system.
How to install Hermes Agent plugins
For catalog plugins, start by finding the entry and inspecting what it adds:
hermes plugins search <term>
hermes plugins install <plugin-name>
hermes plugins list
hermes plugins enable <plugin-name>
Replace the angle-bracket placeholders with an actual search term or catalog name. Installation places the plugin on disk. The installer can also ask whether to enable it; if it is already enabled, a separate enable command is unnecessary.
The official plugin catalog installs reviewed, pinned revisions. Inspect the maintainer, declared capabilities, required credentials, and minimum Hermes version before installing. Catalog review is useful provenance, not a guarantee that every extension suits every environment.
Bundled plugins already ship with Hermes and generally only need enabling. For memory providers and MCP integrations, follow the selection or authorization steps in the relevant entry below.
Run setup in the Hermes profile that will use the plugin, and follow its restart instructions so the new tools are available.
9 best Hermes Agent plugins and integrations
The right Hermes Agent plugin or integration depends on what the agent needs to accomplish, whether that's searching the web, retrieving information, working with developer tools, or automating tasks across applications.
The nine options below support different parts of these workflows. Each is evaluated by what it enables, when it's useful, and what to consider before adding it to a Hermes Agent setup.
1. TinyFish: For web search, extraction, and website operations

TinyFish gives Hermes access to the live web through search, page extraction, remote browser sessions, and goal-based website tasks. The distinction matters because a web workflow can begin with reading public information and later require interaction with a page.
For an agent comparing vendors, search and extraction may be enough to build the initial shortlist. Browser access becomes useful when the next step involves navigating an interactive page or checking information behind a login. TinyFish is a useful fit when those stages belong to the same workflow.
Pros
- Combines search and page extraction with remote browser sessions and goal-based website tasks.
- Can power Hermes’s native web_search and web_extract tools; saved Browser Context Profiles support signed-in workflows.
Limitations
- Browser and Agent operations consume credits and request approval by default. Search and Fetch are free within the published limits.
- TinyResearch reports and TinySet datasets are separate products; do not assume they are included in the Hermes plugin’s tool list.
Setup: Use the TinyFish Hermes setup guide for installation, authentication, and connection checks.
Example: Compare vendors using official sources, then use browser interaction only where retrieval cannot supply the required information.
2. Composio Connect: For connecting Hermes to SaaS apps

Composio Connect gives Hermes access to business applications through a hosted MCP connection. It brings application tools into the agent’s workflow, with OAuth authorization for the accounts involved, so Hermes can work with information held in services such as GitHub, Linear, and Slack.
Its value becomes clearer when a task crosses application boundaries. Reading an issue is only the first step if the outcome also requires creating a task elsewhere. Composio suits these connected workflows, provided its supported actions and the user’s permissions cover the full job.
Pros
- Connects Hermes to applications such as GitHub, Linear, Gmail, Slack, and Notion.
- Uses OAuth for its hosted HTTP MCP connection, avoiding manually supplied authentication headers.
Limitations
- The connected account needs permission for each action, including reading the source and writing to the destination.
- Supported actions, service availability, and rate limits constrain the workflow.
How to Setup:
Enter this in Hermes chat, then complete the relevant application authorization:
Set up Composio from composio.dev/hermesExample: Turn a GitHub issue into a reviewed Linear task, retaining the original issue link so the team can inspect the discussion.
3. Langfuse: For observing and debugging agent runs

Langfuse is an observability platform that makes agent execution easier to inspect. Its Hermes plugin records the sequence of model calls, tool use, and subagent activity behind a response, alongside usage and cost estimates.
That execution history is useful because the final answer often hides where a workflow struggled. A slow run could involve an unresponsive tool, repeated calls, or unnecessary model work. Langfuse helps developers distinguish those possibilities before changing the prompt or replacing a tool, making it especially useful as workflows become longer and harder to diagnose.
Pros
- Traces turns, model calls, tool calls, and subagent activity.
- Shows token usage and cost estimates from Hermes, helping distinguish repeated model work from slow tools.
Limitations
- Trace capture needs appropriate data handling. Sanitized capture is the default, but settings affect what is recorded.
- Cost estimates help with diagnosis; provider billing remains the source for actual charges.
How to Setup:
Install the current marketplace plugin, supply project keys, and restart Hermes:
hermes plugins install langfuseExample: Inspect a repeated page fetch to determine whether retrieval failed or the agent kept calling a tool after receiving a useful result.
4. Honcho: For personalized long-term memory

Honcho is a memory provider that helps Hermes carry context about people and their work across conversations. It stores conversation information and derives representations and conclusions that can inform later interactions, giving an assistant more continuity than the current chat alone provides.
This approach suits ongoing assistance where preferences and priorities develop over time. An assistant preparing recurring updates, for example, benefits from understanding what the reader considers important. The reason to choose Honcho is that continuing relationship; a handful of fixed instructions may not require an additional memory service.
Pros
- Stores conversation information and derives context for later interactions.
- Offers managed and self-hosted deployment, with several cloud authentication options.
Limitations
- Stored conclusions can become outdated or be inferred incorrectly; test how corrections affect later responses.
- Conversation processing needs review. A few stable instructions may already fit Hermes’s built-in memory.
How to Setup:
hermes plugins install honcho
hermes memory setup honchoExample: Carry a reader’s preferred summary format and recurring project priorities into weekly updates without repeating those instructions.
5. Hindsight: For structured memory retrieval

Hindsight is a memory provider built around structured facts, entity relationships, and retrieval. Its retain, recall, and reflect operations let an agent store information, recover relevant memories, and synthesize an answer from accumulated context.
This is useful when remembering the connection between events matters as much as remembering an isolated fact. During incident investigations, a team may need to connect a service failure to a previous mitigation and the reasoning behind it. Hindsight is worth considering for that kind of recurring factual inquiry, where loosely related notes would leave important context unresolved.
Pros
- Supports structured memory, entity relationships, and multiple retrieval strategies.
- Provides retain, recall, and reflect operations for storing information, retrieving it, and synthesizing answers.
- Offers cloud, local external, and local embedded server modes.
Limitations
- Local operation adds resource and maintenance requirements.
- A local server may still use an external model provider; check both processing and storage.
How to Setup:
Install the provider, then select Hindsight and its deployment mode:
hermes plugins install hindsight
hermes memory setupExample: Retrieve the mitigation chosen for a service incident and the trade-off behind that decision.
6. Web Search Plus: For multi-provider search and fallback

Web Search Plus adds a configurable search and extraction layer to Hermes. It connects multiple providers behind dedicated tools and can route requests or try an alternative provider when a search cannot produce a useful result.
The main reason to consider it is control over how sources are discovered and retrieved. A documentation-research workflow may need provider choice and fallback without needing to interact with websites. Web Search Plus fits that requirement, while the agent still needs to evaluate whether the returned pages actually support its answer.
Pros
- Combines configurable search and extraction providers, with routing and fallback behavior.
- Adds dedicated search and extraction tools, quality information, and an optional research mode.
- Can start with one configured provider.
Limitations
- Provider charges and limits vary; fallback does not guarantee relevant or current sources.
- If another plugin also configures Hermes’s native web backend, decide which handles native calls.
How to Setup:
Configure provider access and restart Hermes after installation:
hermes plugins install web-search-plus --enable
hermes web-search-plus setup
hermes web-search-plus statusExample: Gather official technical documentation through the available providers, then check each page’s relevance and currency.
7. Google Meet: For meeting notes and transcription
The Google Meet plugin brings meeting content into a Hermes workflow. It joins a call through browser automation and builds a transcript from Meet’s live captions, giving the agent material it can use to prepare summaries and follow-up notes.
This is useful when the desired output is a record of decisions, owners, and unresolved questions rather than a long transcript someone must read afterward. Its caption-based approach also defines its limits: the quality of the notes depends on what the captions captured, so important commitments still need review.
Pros
- Joins calls through browser automation and derives a transcript from Meet’s live captions.
- Gives Hermes transcript material for summaries; optional speech output is available separately.
Limitations
- Missing or misrecognized captions carry into the summary; screen content may be absent.
- Requires appropriate meeting access and participant consent. Host approval may be necessary.
How to Setup:
Enable google_meet, prepare dependencies, and complete sign-in when required:
hermes plugins enable google_meet
hermes meet install
hermes meet setup
hermes meet authExample: Summarize decisions, agreed owners, and open questions, leaving an owner unspecified when nobody accepted the task.
8. Disk Cleanup: For keeping agent workspaces manageable
Disk Cleanup is a bundled maintenance plugin for eligible temporary files created during Hermes work. It tracks files within a restricted scope and provides both automatic cleanup behavior and commands for inspecting a manual cleanup.
It becomes useful when repeated experiments leave scratch scripts and intermediate outputs behind after the final result has been saved. The benefit is less housekeeping around those temporary artifacts. Because some eligible files can be deleted automatically, it fits workflows with a clear distinction between disposable scratch work and deliverables that need to be retained.
Pros
- Tracks eligible temporary files in restricted Hermes locations and excludes protected project trees.
- Provides status and dry-run commands for inspecting manual cleanup; eligible tracked test files can trigger automatic cleanup.
Limitations
- Its scope is restricted, so it is not a general disk manager.
- Automatic cleanup can delete eligible files without a prompt. Check the rules if temporary artifacts need to be retained.
How to Setup:
hermes plugins enable disk-cleanupInspect cleanup from Hermes chat:
/disk-cleanup status
/disk-cleanup dry-runExample: Save the finished analysis in its project location, then review the remaining scratch files for cleanup.
What to check before installing a Hermes plugin
Before making an extension part of a recurring workflow, check how it changes the agent’s access, data handling, and operating costs. These checks should follow the actual task: a search plugin and an application connector introduce different dependencies.
Check the source and the access it receives
Review the maintainer, required credentials, and capability disclosure. The Hermes catalog installs reviewed revisions, but catalog inclusion is not a security audit. For an application integration, confirm which accounts and projects it can reach and whether it can modify records as well as read them.
Follow the data beyond the plugin
Identify what each connected service receives. A search request contains queries and URLs; a memory provider may receive conversation context; tracing can capture details of model and tool activity. Check the configured destination and capture settings. For a local memory server, also check the model endpoint—local storage alone does not establish that processing stays on the machine.
Account for usage and unattended behavior
Separate the cost of the plugin from model calls and connected-service usage. A recurring workflow can multiply those charges, especially if it repeats requests after a failure. Decide which paid or external actions may proceed without intervention. For example, TinyFish’s default approval policy for Browser and Agent operations needs deliberate configuration before unattended use; removing a prompt is a decision about spending and authority.
Verify an outcome, not just a connection
Use a small task whose result can be checked independently. For retrieval, inspect the source and extracted fields. For an application action, confirm the destination record and its contents. For memory, test a known fact and then a correction. Also check what happens when a tool fails or permission is denied, so the workflow can report incomplete work clearly instead of presenting it as finished.
Get started with TinyFish for Hermes
For work that starts on the web, TinyFish brings search, page extraction, browser sessions, and goal-based website operations into Hermes. That makes it worth considering when a workflow needs to progress from finding information to interacting with the site that holds it.
Create a TinyFish account and follow the Hermes integration guide to connect it. Start with a source-linked comparison of a few public pages, then add browser or website-action capabilities when the next step requires them.
AI disclosure
Content on this website may be created or refined with the assistance of AI tools and is subject to human editorial review.



