A running log of what's shipping in Hermes Agent — merged pull requests from NousResearch/hermes-agent, browsable one day at a time with plain-English AI summaries of what changed. Checked every 30 minutes.
Last checked 21 Sept 2026, 05:29 UTC
Tool availability checks are now more efficient, speeding up API requests by reusing cached information unless you've specifically enabled advanced browser control features. This change prevents unnecessary recalculations and makes the system faster by default.
You can now drag a bot chat into a new pane to split your workspace. This makes it easier to organize and interact with your bot conversations by allowing them to exist independently from the main view.
Hermes can now find and use the community Corpus plugin, which provides access to research and business formation tools. This makes it easier to use these helpful features and includes important disclosures about data handling.
Afterforge, a new regression testing tool, has been added to the project's catalog. This update helps ensure that the tool is properly integrated and verified for use.
Hermes can now automatically install a new plugin that gives agents their own email address for sending and receiving messages. This makes it easier for users to integrate email functionality into their agents without manually copying code.
This update adds support for OpenRouter, allowing Hermes Agent to convert speech to text and text to speech using your existing OpenRouter API key. This makes it easier and more flexible to integrate voice capabilities into your applications.
A new plugin is available that lets you define your own rules for commands that shouldn't be run. This improves security by allowing you to proactively block potentially harmful commands.
Cron jobs now automatically use the latest main agent model when they run, making sure they always operate with the current settings. You can now explicitly "pin" a job to a specific model if you want to lock it to older settings, preventing unexpected changes.
A new plugin called "bot-forge" has been added, allowing agents to automatically create specialized bots with unique personalities and functionalities from a single command. This makes it easier to generate bots for specific tasks, such as writing social media posts.
The Hermes Agent now includes a new plugin that makes it easier to use the Tempo payment system. This new integration allows Hermes to automatically authorize payments if you provide the necessary Tempo API key.
You can now easily transfer files over your local network using the new LocalSend plugin. This adds a desktop interface to your chats, making it simple to send and receive files between your devices without needing an account or the cloud.
Group chat bots now show you more of the conversation history in each turn. This makes it easier to follow along and provide better context to the bot.
A new plugin, "Intelligent Tool Break," has been added to help manage tools that get stuck. This plugin allows you to break out of a stuck tool call with a note or retry it, preventing a full cancellation.
A new memory review feature has been added to the Hermes Plugin Catalog. This allows you to approve or reject staged memory writes before they are finalized.
Hermes Agent now shows your provider quota directly in the status bar, preventing unexpected request failures. This makes it easier to track your usage for services like Codex and Grok.
An RSS reader plugin has been added, allowing you to easily subscribe to and read your favorite news feeds within Hermes. This new feature offers enhanced reading capabilities like summaries and customizable subscriptions.
We've added a new "prompt snippets" feature to the plugin catalog. This makes it easier to use pre-written text snippets in your interactions, improving efficiency.
A new plugin called `prompt-enhancer` has been added to the project's catalog, which can improve how the agent interacts with your desktop. This plugin has been reviewed and is ready for use.
Hermes Agent now reuses cached recommendations instead of repeatedly fetching them, making it more efficient. It also requests compressed data when fetching, further reducing network traffic and improving performance.
A new community plugin called `source-tray` has been added, which helps you keep track of all the websites and web content the Hermes agent has accessed. This makes it easier to review or revisit the pages the agent has opened for you.
This update corrects a security vulnerability where Hermes Agent could run commands it shouldn't, even when restricted. The changes ensure that the agent properly enforces autonomy levels, preventing unauthorized command execution and making it safer to use.
A new plugin called "provider-copy" has been added to help users easily copy API keys between different bot profiles. This makes it simpler for those who use multiple bots by reducing the need to manually re-enter keys for each one.
You can now easily add sticky notes directly within the Hermes window to jot down quick reminders. This new plugin lets you manage these notes, stack them up, or drag them around for better organization.
The maintainer of the pstack plugin has updated their GitHub username. This change ensures accurate attribution and keeps the project's contact information up-to-date.
A flaky test that checked how Hermes handles repeated compression failures has been fixed. This makes the test more reliable by ensuring it accurately reflects Hermes' ability to recover from errors.
The messaging gateway now provides more helpful feedback when it loses connection to the AI model mid-conversation, suggesting you try again instead of wrongly saying the service is down. This helps you understand and fix connection issues more easily.
A new plugin called Adspirer has been added, allowing Hermes to manage paid advertising campaigns across major platforms like Google, Meta, and TikTok. This integration simplifies campaign creation and optimization by connecting to Adspirer's hosted service.
External-process and OAuth model providers are now correctly displayed in Hermes, allowing you to see and use them even if they aren't installed directly with Hermes. This makes it easier to integrate with custom AI models.
Hermes Agent now properly supports custom authentication methods for providers, allowing them to register, log in, and refresh credentials securely. This update ensures that your custom providers are recognized and managed correctly by the agent.
Model providers can now show their account usage details directly in the agent's usage displays. This makes it easier for users to understand their spending limits and plan status for different AI models.
Hermes can now use custom provider plugins to determine available models and whether they support image input during initial setup. This makes it easier for developers to integrate their own AI models without needing changes to Hermes itself.
The plugin guard now better identifies potentially unsafe code by improving how it recognizes test file names and understanding when sensitive information is being shared between agents. This reduces false alarms and strengthens security by more accurately flagging risky operations.
A new plugin for structured auxiliary models has been added to the catalog, improving how certain model information is handled. This update also clarifies the plugin's description regarding data disclosures and approvals.
You can now choose to hide the full code changes in edit history, displaying only the number of lines added or removed. This helps make long conversations more concise while still showing you the extent of file modifications.
Model providers can now declare their capabilities once, allowing the system to automatically understand what each model can do without manual configuration. This makes it easier to use different models for tasks like reasoning and handling images.
Model providers can now directly report API errors and manage their own credential refreshing. This makes it easier for them to recover from authentication issues and ensures the agent behaves more reliably when dealing with different model services.
External plugins can now be selected and correctly show their connection status when choosing a model. This makes it easier to use custom model providers that are not built into Hermes.
External plugins can now more easily integrate with services that use standard OAuth 2.0 for login. This simplifies the process by automatically handling the complex steps of user authentication, token management, and secure communication.
Hermes Agent on macOS now automatically replaces shorthand text with your saved shortcuts, like changing `->` to `→`. This makes typing faster by using your Mac's built-in text substitution features.
The Hermes Agent now remembers previous parts of a conversation when starting a new session with the Codex app-server. This fix ensures that when you switch models or encounter a lost conversation thread, the agent can still access the conversation history, preventing it from responding "blind" and making the OpenAI Codex provider work correctly again.
The installation of the `kiro-acp` plugin was failing because it was referencing a tag that wasn't a direct code commit. This change updates the reference to point to the correct code commit, allowing the plugin to be installed successfully.
The plugin list now sorts plugins solely by their popularity on GitHub, measured in stars. This change simplifies the catalog and removes the claim that plugins are reviewed by the Hermes team, focusing instead on community-driven contributions.
Messages from scheduled tasks that don't have their own Discord bot can now be sent correctly to Discord. This fixes an issue where these messages would fail to send because the system didn't know which Discord bot to use.
Slash commands are now more secure. Commands sent from a source with no specific chat type (like a direct message or a group chat) will now be properly checked against your admin settings, preventing unauthorized use of sensitive commands. This closes a loophole that could have allowed certain commands to be run even when restricted.
The Hermes Agent can now correctly handle messages even if an initial setup error occurs. This means that if a problem happens while restoring past events, the agent won't get stuck and will still process new incoming messages.
Hermes can now properly clean up temporary files left behind by Git updates on Windows, preventing disk space issues. Any files that still cannot be removed are now clearly flagged at a warning level for easier troubleshooting.
The agent will no longer accidentally send special control characters as part of its chat responses. This ensures cleaner output and prevents confusing messages from appearing in your conversations.
The process for logging into servers using OAuth via your browser now reliably completes. This fixes an issue where the browser trying to fetch a favicon immediately after the login callback would incorrectly interrupt the login process.
We've updated the documentation for a plugin to reflect that installing it now works correctly without needing manual steps. This ensures users get accurate instructions when adding new features.
Managed streams in the Relay Agent now reliably close and release resources, preventing indefinite waits and ensuring that errors are properly reported. This makes the agent more stable and predictable when handling communication streams.
The Hermes Agent now correctly identifies when a provider's content filter blocks a request due to existing content. Previously, these blocks were mistakenly reported as malformed requests, which could confuse users and potentially lead to incorrect retry behavior. This change ensures that such refusals are clearly labeled as content policy violations.
The agent can now fix incomplete or incorrectly formatted instructions it receives, ensuring more tool calls are processed correctly. This prevents lost functionality when messages from tools are slightly garbled.
The Hermes Agent now correctly handles OAuth connections when the authorization server's information is published at a specific path on the origin server. This allows for successful login and registration by ensuring the agent trusts metadata issued by the origin itself, even when targeting a specific path.
Hermes Agent can now correctly connect to your locally running Llama.cpp server. This makes it easier to use your own models without needing to configure Hermes to manage them.
A new plugin called Markifact has been added, which provides a pre-built package of skills and a server that doesn't require any coding. This makes it easier to integrate powerful new features into Hermes Agent without needing to write any new code yourself.
Hermes can now handle malformed configuration files without crashing. If a setting is incorrect, it will be fixed or skipped with a warning, allowing the update process to complete.
Hermes Agent can now prompt for approval when a plugin requests it during an API server run, instead of immediately blocking. This change allows for more interactive and controlled plugin actions within the API.
We've fixed an issue where a failed attempt to send data to a relay would be retried unnecessarily. This change ensures that failures are handled correctly the first time, preventing wasted effort. Additionally, we've resolved a rare error message that could appear when multiple operations were happening simultaneously within a relay session, making the system more stable.
Auxiliary tasks now correctly identify the correct client when using provider aliases like "opencode". This ensures that features like code generation and approval tasks work seamlessly with these services.
Local servers like `llamacpp` can now correctly connect to their specified addresses when used. This ensures that requests intended for a local service are routed properly, rather than defaulting to a generic or cloud-based endpoint.
Cron jobs run by external workers will no longer fail unexpectedly. This is because the acknowledgement file indicating a job's completion is now written atomically, preventing partial reads that caused errors.
The system will now correctly handle warnings during startup, preventing it from freezing and crashing. This ensures that essential functions like Discord messages and internal checks continue to work even when logging is temporarily busy.
When you configure tools with a specific list format, Hermes now correctly interprets and saves your choices, preventing custom settings from being overwritten. This ensures that your preferred tool configurations are preserved.
Login now successfully connects to servers that separate authentication from other services. It also provides more helpful error messages when the login process fails.
Previously, when a tool returned both a summary message and structured data, the structured data was sometimes lost. This update ensures that structured data is now correctly preserved in these cases, allowing the model to access all the necessary information. Duplicate JSON results are still only sent once to avoid redundancy.
We've fixed how long a hung stream is allowed to run. Now, a specific setting for a provider will directly control this timeout, instead of being influenced by other configuration levels. This change provides more predictable control over stream behavior and prevents unexpectedly long waits for stalled connections.
The desktop app now shows a clear indicator when you manually compress messages, just like it does for automatic compression. This makes it easier to see the progress and know when the compression is complete.
Gateways that only handle API requests will no longer show a warning about missing messaging settings. This change prevents unnecessary messages when the gateway isn't designed to connect to messaging platforms.
Tasks that were interrupted while running in the background will now finish more quickly and reliably, even if one of the tasks gets stuck. This prevents the entire system from freezing when an interruption occurs.
Cron jobs that get stuck sending data will now automatically finish after a set time instead of running forever. This prevents the system from getting bogged down and ensures that scheduled tasks can complete.
Hermes now correctly understands and documents which tools are automatically deferred. This prevents confusing warnings and ensures the configuration for deferred tools works as expected.
Hermes Agent can now better track and recover work done by its sub-agents even if the main agent process crashes. This means lost tasks will now include detailed information about their outcomes and where to find their logs, making debugging much easier.
When resuming a secondary chat profile, it now correctly uses its own custom provider instead of encountering an error. This ensures that your custom settings are preserved for all your profiles.
This update fixes an issue where Hermes Agent would incorrectly report that gateways needed to restart, even when they were up-to-date. This prevents unnecessary warnings and ensures that the update process completes smoothly.
The Hermes Agent will now shut down more reliably by performing a potentially long-running cleanup step in a separate thread, preventing the agent from getting stuck during shutdown. This ensures that other shutdown tasks and callbacks can complete successfully.
Servers that are temporarily offline or explicitly disabled will now be handled more quietly, preventing excessive error messages and unnecessary attempts to reconnect. This makes the system's behavior clearer and reduces log clutter when dealing with unavailable services.
The Langfuse plugin now allows you to configure how deeply nested information from tool usage is recorded, preventing important details from being cut off. This makes it easier to track complex tool interactions for debugging and analysis.
Subagents are now more reliably visible in the agent panel even after the user disconnects and reconnects. Additionally, child agents will no longer receive outdated instructions about how to communicate their role.
The `hermes update` command now correctly handles situations where you've staged a file that doesn't exist yet. This prevents the update process from failing unexpectedly and ensures your local changes are properly saved and restored.
Hermes Agent will no longer repeatedly remind you to restart its server if it cannot determine the server's startup time and the server process has actually stopped. This prevents persistent, unresolvable warnings from appearing.
Hermes now correctly identifies when a dashboard or serve process is being managed by macOS's launchd. This prevents unnecessary restart prompts and warnings, ensuring a smoother update experience for users on macOS.
This update ensures that older Hermes gateway services on macOS are properly restarted when you update. Previously, these older services might have been missed by the update process.
When you update the desktop app, Hermes will now properly stop the running application before replacing its files. This prevents the app from crashing later when it tries to load components that have already been removed.
Hermes Agent will no longer unnecessarily contact its AI model for approval when completing file paths in remote terminals. This prevents the AI from being unnecessarily activated and consuming resources when performing this routine task.
This update prevents malicious code injection by ensuring that credentials and sensitive environment variables cannot be unintentionally exposed to sandboxed environments. It strengthens security by making the system more robust against various ways of passing environment variables into Docker containers.
Docker containers will now correctly enforce resource limits like CPU and memory even if there's a temporary issue when Docker is first checked. Previously, a brief problem could cause these important limits to be ignored for the entire process.
Hermes will no longer accidentally stop containers that have just been restarted. This change ensures that only truly orphaned containers are removed, preventing disruption to running services.
Bots can now correctly reply to teammates on different machines without being accidentally woken up by their own responses. This improves the reliability of bot interactions, especially when using the default single-query setting.
This update ensures that messages with special characters sent from the bot on Windows are received correctly and that errors from background tasks are properly recorded. This means more reliable communication and better debugging for all users.
Hermes Agent can now better detect when potentially unsafe commands are run using different shells like zsh and dash. This update ensures that more security checks are applied, making Hermes Agent more secure when handling commands that execute remote scripts.
Hermes Agent now correctly identifies inline script execution in Bun and Deno, just like it does for Node. This prevents potentially risky commands from running without explicit approval.
The Hermes Agent now prevents you from accidentally saving environment variables that could be used to control how other programs run. This update enhances security by blocking potentially risky configuration settings.
When you restart or stop the Hermes Gateway using systemctl directly, it now correctly registers as a planned shutdown instead of an error. This prevents unnecessary restarts and ensures that the system logs the gateway's status cleanly.
The update process now correctly checks for critical modules, preventing issues where an old installation might falsely indicate success. This ensures a more reliable update by not relying on outdated environment paths.
The model picker now correctly displays available models when you use the same service both automatically and as a custom provider. This ensures you don't lose access to models you expect to see.
This update improves security for self-hosted OpenID Connect authentication by ensuring that discovery documents are only accepted if they come directly from the configured issuer's server. This prevents attackers from tricking the system into using malicious endpoints by redirecting requests to a different server.
Previously, setting a negative value for session retention days would incorrectly delete all ended sessions. This change prevents that by enforcing a minimum retention of zero days, ensuring your session data is not accidentally lost.
Changes ensure that settings for data compression in your sessions are applied correctly without causing errors. This means you can now reliably adjust compression settings on the fly.
Hermes now correctly logs when local changes are stashed due to conflicts during an update, preventing updates with stashed changes from being falsely reported as a complete success. This ensures you know when changes were set aside and why.
Hermes Agent now more securely handles redirects by ensuring configured headers are removed during cross-origin redirects, which is important for protecting sensitive information. This update also fixes an issue where the content-type check was not properly stripping headers, making it less secure.
When a notification fails to be claimed properly, the agent now correctly releases the session's turn. This prevents the chat from getting stuck and ensures its ongoing operations aren't halted until a restart.
Delegate and branch children now correctly avoid inheriting routing information when their parent session is compressed. This prevents unintended data sharing and ensures each session maintains its own distinct communication channel.
Sessions that were initially hidden, like in bot mode, will now correctly stay un-hidden after you un-hide them. This fixes a bug where they would revert to being hidden after the next message.
This update prevents old workers from incorrectly marking tasks as done when a newer worker is already in charge. This ensures that only the active worker can manage a task's status, preventing accidental data corruption.
This update makes internal housekeeping tasks run more efficiently by performing them separately for each hosted profile, preventing unnecessary errors. It also stops repetitive error messages when certain servers are temporarily unavailable.
When you enable a platform from the command line, Hermes now correctly saves the setting so the gateway can use it. This ensures that enabling a platform actually turns it on for the gateway.
Hermes Agent no longer unnecessarily resets idle timers when a compression attempt fails to produce data. This prevents overly long waiting periods when requests are made but no response content is received.
The Hermes Agent can now correctly detect if a process is still using a database file even when the Hermes home directory is accessed through a symbolic link. This prevents potential data corruption by ensuring that a new database file is not accidentally created alongside an orphaned one.
Operations like optimizing or rebuilding the search index no longer fail if the database is closed at the exact same time. This ensures that important data can still be added to Hermes after a clean shutdown.
The Hermes Agent can now adjust its reconnection speed based on the settings for each individual profile without needing to restart. This means if one part of the agent is having trouble reconnecting, it won't unnecessarily slow down other parts that are working fine, and changes to reconnection settings will take effect immediately.
Credentials with different casing will no longer bypass security checks. This prevents sensitive information from being exposed unintentionally.
Sessions using custom AI providers will no longer incorrectly report errors when the AI finishes a turn. This fix ensures that the system accurately recognizes when the correct custom AI was used, preventing unnecessary interruptions.
The system now warns only once when a notification can't be delivered because the route is set up incorrectly. This stops the system from repeatedly showing confusing debug messages and instead provides a single, helpful warning with instructions on how to fix it.
The Hermes Agent can now handle sessions that have new, unrecognized binary data in their message history. This prevents crashes and ensures that session transcripts can still be retrieved even if the database schema has been updated.
Commands that fetch usage and billing information now exit promptly after a short timeout if the system they connect to becomes unresponsive. This prevents the commands from hanging indefinitely, ensuring a better user experience and more reliable operation.
This update improves how the agent handles complex reasoning with Bedrock models. It now correctly replays thinking steps, preventing errors and ensuring conversations continue smoothly even when dealing with different regions or model types.
The Hermes Agent can now handle certain comments or error messages that were previously causing it to crash. This means your tasks will continue processing even if some comment data is corrupted, preventing disruptions.
The OpenCode Zen model `x-preview-f-free`, which is no longer supported, has been removed from all model selection lists. This prevents users from trying to use a model that will cause errors.
Web search tools will no longer incorrectly appear to be configured when only xAI credentials are provided. This prevents errors and ensures the tools are only offered when a functional backend is actually available.
Ensuring data durability when writing files, especially when overwriting existing ones, has been improved. This change makes sure that when a new file replaces an old one via a symbolic link, the correct directory containing the new file is properly synchronized to disk, preventing potential data loss.
The way the current working directory is handled when launching profiles has been corrected. This ensures that launch profiles use the correct directory, preventing unexpected behavior when working with different project configurations.
When you lack credits for a paid model, Hermes will now switch to a backup model sooner and log a warning. This prevents unnecessary retries and helps you understand why the model change occurred.
The tools that manage your project boards now correctly report errors when you use misspelled commands, instead of silently ignoring them. This change makes it easier to identify mistakes and ensures your board changes are applied as intended.
The Hermes Agent now uses a more efficient process for capturing and analyzing images, directly sending them to the vision model instead of converting them to text first. This change reduces processing time and improves performance when using compatible vision models.
Previously, an old API key could interfere with newer authentication methods. This change ensures that removed API keys are properly ignored, allowing the correct authentication method to be used for various AI services.
The Hermes Agent can now reliably turn off its reasoning process, even with certain providers like DeepSeek that always try to enable it. This prevents unnecessary processing and ensures the agent uses resources more efficiently.
The "done" column on the Kanban board now shows the most recently completed tasks first, making it easier to see what just finished. You can also use a new command-line option to sort tasks by completion date.
The agent now correctly identifies placeholder API keys, like "your_key_here," as invalid. This prevents the agent from attempting to use these placeholders and provides clearer error messages when actual API keys are missing.
The `hermes hooks test` command now clearly shows whether a hook blocked a request due to an error or timeout, or if it simply didn't contribute any decision. This makes it easier to understand why a hook might have failed and to distinguish between different failure scenarios.
Messages in Discord threads that the bot has already joined will now be processed correctly, even if they only mention other users. Previously, these messages could be silently ignored, but now they will be handled as expected, with debugging information available if a message is still dropped.
The way custom reply prefixes are set for WhatsApp messages has been fixed. This means you can now easily customize or disable the reply message header directly in your configuration file.
If a background task fails during a conversation turn, the agent will now correctly recover and allow the next user prompt to proceed, instead of getting stuck. This ensures conversations remain responsive even if a specific background process encounters an error.
Hermes now provides clear error messages instead of crashing when your vault configuration is malformed. This makes it easier to fix issues with corrupted vault files or incorrectly edited configuration settings.
The Hermes Agent update process on Windows will no longer fail if another service on your system has restricted access. This ensures updates can proceed even when encountering unusual service configurations.
The Hermes Agent now correctly identifies when verification scripts are run using different Python interpreter paths or versions. This prevents unnecessary "unverified" warnings after successful verification runs.
Slash commands like `/approvals` now work correctly on the launch profile after switching between profiles. The desktop interface also provides clearer error messages when these commands fail.
Hermes now correctly handles files with special characters, ensuring the language server's understanding of your code always matches what's on disk. This prevents confusing errors by accurately tracking changes, especially at the end of lines.
You can now create kanban issues with multi-line descriptions directly from a file or standard input, ensuring your entire brief and subsequent arguments are captured correctly. This addresses an issue where shell limitations would previously truncate long descriptions.
The voice mode now correctly plays audio files, even when they are saved in a different format or location than initially expected. This also ensures that temporary files are cleaned up properly, preventing unnecessary clutter.
Hermes Agent now asks for permission before making changes to sensitive files like `.env` when multiple files are being modified at once. This prevents accidental changes to important configuration files.
Commands to manage Hermes gateways now correctly identify which gateway belongs to a specific profile. This prevents accidentally stopping or restarting the wrong gateway when multiple profiles are configured.
Hermes Agent now ensures that child processes always receive a HOME directory setting, even if the main system environment lacks one. This prevents scripts that rely on the HOME variable from failing unexpectedly.
Updates on Windows will now work correctly, preventing crashes that happened when a new symbol was added to a core module during the update process. This ensures that all parts of the update, including restarting the agent, complete as expected.
Messages sent by another Hermes bot in a Telegram group, like when it's mentioned or quoted, will now be correctly recorded and processed instead of disappearing. This prevents lost conversations when multiple Hermes bots are active in the same chat.
On touch devices, tapping a kanban card now correctly opens it instead of accidentally moving it to another column. This change prevents minor touch movements from being mistaken for a drag, ensuring a smoother user experience.
Language servers that take too long to start will now be properly stopped instead of running in the background unnoticed. This prevents resource leaks and ensures the system accurately reflects active language server processes.
The colors for warnings and errors in the Kanban board now adapt to your dashboard's theme settings. This improves consistency and readability across different visual styles.
When you start the Hermes Dashboard, it now correctly uses the session token provided by its parent. This prevents the dashboard from rejecting your connection with an error when it tries to authenticate.
The warning message and documentation for Telegram's direct message topics have been updated to accurately reflect how to enable threaded mode in BotFather. This ensures users can correctly configure their bots to use this feature.
When updating Hermes on Windows and the agent is already up to date, it will now correctly report any issues with restarting the gateway instead of crashing and repeating the error. This prevents confusing double error messages and ensures a smoother update experience.
Your Hermes Desktop projects are now correctly organized in the sidebar. This change ensures that your editor sessions store their current working directory and Git information, allowing Hermes to group them by project. Existing sessions will also be updated to reflect this new organization.
The Hermes Agent now correctly handles Git repositories with non-ASCII characters in their names on macOS. This prevents tasks from failing unexpectedly when dealing with paths that contain special characters.
Direct messages in Matrix will now be automatically identified and treated differently by the Hermes Agent. This means that small, private conversations will bypass certain communication restrictions, making them behave more like typical direct messages.
The BlueBubbles guide now clarifies how to set up and verify Hermes's connection for receiving messages. It also helps troubleshoot why messages might not be arriving or why you might be getting duplicate replies.
The Hermes Gateway now correctly recognizes and enables the A2A platform when it's specified in the configuration. This ensures that the A2A platform is loaded and functional, rather than being silently ignored.
The search functionality now correctly follows symbolic links when searching for files or content, ensuring that results are found even when directories or files are linked. This improves the accuracy of file searches, especially in complex directory structures.
Hermes Agent will now try to use your GitHub CLI login if your `.env` file has an expired GitHub token, allowing private projects to download successfully. This change prevents a dead token from blocking you when a valid login method is available.
Commands like resetting the session or changing the model will now wait their turn if the agent is busy. This prevents accidental data loss or disruptions by ensuring these actions only happen when the agent is idle.
Installing and updating plugins from the dashboard now works correctly on hosts with multiple profiles. This fix prevents errors by ensuring that plugin operations are performed within the correct profile's secure environment.
Hermes Agent can now send messages to Discord channels when you provide a direct link to the channel, instead of failing silently. This makes it easier to configure and use Hermes Agent with your Discord servers.
Google AI Studio keys starting with "AQ." now work correctly, preventing them from being sent to the wrong service and causing errors. This change ensures that AI Studio keys are used with the intended service, improving reliability for users.
The Hermes Agent no longer reads hint files that are shortcuts to files outside of the project or to sensitive configuration files. This prevents accidental exposure of private information and ensures that only intended hint files are used.
Tests can now handle very large numbers of files by reading them from a separate file, preventing errors that occurred when the list of files was too long. This change makes it easier to run all tests efficiently.
The Hermes Doctor now checks if background processes are pointing to old software versions that no longer exist. This prevents crashes by guiding you to update these references to use the latest version.
Pasting images into the TUI from your clipboard now works again on Wayland. This fix ensures that image copying and pasting functions correctly by providing the necessary input for the clipboard tool.
The documentation for skills is now automatically cleaned up to remove outdated pages and prevent errors. This ensures that the documentation accurately reflects the available skills and avoids confusion for users.
The text-to-speech system now prevents malicious paths from being used to inject unintended commands or files. This change makes the system more secure by ensuring that only valid file paths are processed.
When setting up the Hermes gateway on Windows, the installation process now correctly asks for your preferences only once and proceeds smoothly after you approve the User Account Control prompt. This prevents redundant questions and ensures the gateway starts as intended.
You can now switch between tabs using keyboard shortcuts like Command+Option+Left Arrow without needing to click elsewhere first. This makes navigating between different sessions much smoother and faster.
Hermes Agent can now correctly use custom endpoints for model providers when configured through user plugins. This ensures that when you specify a different endpoint for a model provider, your requests are actually sent to that custom location.
The Hermes Agent can now correctly handle Windows accounts with non-standard characters in their paths, preventing errors when managing the agent and ensuring localized error messages are properly understood. This means the agent will install and update more reliably for a wider range of users.
The documentation now accurately lists the tools that are actually available and used by Hermes. This helps users find and understand the correct tools for their tasks.
The Hermes TUI gateway will now shut down cleanly when its terminal is closed, preventing it from unexpectedly restarting. This makes the TUI more stable by avoiding unnecessary restarts when the terminal environment is lost.
When you send a message to a bot that has an open chat window on your desktop, that message will now be correctly answered by the open chat, and you will receive the bot's reply across all communication methods. This ensures a consistent and predictable experience when interacting with bots.
When a language server fails to start, it now provides more helpful information by showing its exit status and the last few error messages. Previously, these failures were silent, making it hard to diagnose why a server wasn't working. Also, if a project is skipped because of a previous error, you'll now see an informational message explaining why.
Running the `hermes dashboard` command from a shell now correctly displays the web-based dashboard instead of the limited desktop-only interface. This improves the experience when launching the dashboard from integrated tools or terminals.
The Hermes Agent now correctly reports when media attachments fail to send, instead of pretending everything was successful. This change ensures you are properly notified about incomplete messages and that the system exits with an error code, preventing silent failures.
The godmode tool's internal references have been updated to correctly point to its new location. This ensures that godmode and other optional skills can be installed and used properly, preventing errors.
Models you download for local use now work correctly when you try to use them. Previously, the program would get confused and think you didn't have the model even after you downloaded it.
Hermes Agent Windows updates no longer briefly show a console window when starting. This makes the update process smoother and less intrusive for users.
On macOS, pressing Ctrl+D when the message composer is empty will now correctly exit the TUI, just like on other platforms. This makes the TUI behave more consistently with the standard command-line interface.
Tests for testing code execution have been improved to prevent background threads from consuming excessive resources after tests finish. This change ensures cleaner test runs and better resource management.
Hermes Agent now correctly recognizes and uses external AI model providers, even when they are configured with a runtime-determined endpoint. This change ensures a more consistent experience when switching between different models, whether through the command line, the desktop interface, or the `hermes model` command.
Model provider plugins can now use their own custom communication methods. This means plugins can define their specific API modes and have them correctly used by Hermes Agent, rather than being forced to use the default chat completion method.
The manual `/compress` command now correctly compresses sessions even when multiple profiles are active, preventing errors. It also accurately reports missing credentials for the specific provider you requested, rather than an unrelated one.
Videos sent through Telegram now keep their original shape and show a preview frame, making them look much better than before. This change helps preserve the intended look of videos regardless of their size.
Group chats now show the specific reason why a member failed, making it easier to understand and fix problems. Previously, all failures looked the same, making it hard to tell if a bot had a minor issue or a major crash.
The Hermes Agent can now find and install skills that are located directly in the root of a GitHub repository, making it easier to manage and use these skills. This also ensures that skills with a more complex directory structure are still handled correctly.
This update improves a test for compression by ensuring that a temporary retry doesn't hide a problem where the system fails to escalate properly. Now, the test accurately catches regressions that make escalation more difficult.
The way pinned conversations are displayed in the sidebar has been fixed to match the appearance of recent conversations. This ensures a consistent and cleaner look by preventing mixed row heights.
The Windows update button now works correctly without unexpectedly stopping the application. This fix ensures that when an update is ready, the application can properly hand off to the update process and close gracefully.
Hermes will now properly close on Windows when you close the last window. Previously, the application might have stayed running in the background even after the window was gone, and this update ensures it exits cleanly.
Shell scripts like `.sh` or `.py` files can now be run directly on Windows. This fixes an issue where these commands would fail on Windows, preventing tools from running correctly even when they were meant to succeed.
The tool now correctly starts the CUA driver without opening an unnecessary blank window on Windows. If permission to start the driver is denied, it will now provide a helpful warning instead of failing the entire installation.
Files created by the terminal in SSH mode now have normal permissions again, making them easier to manage. Previously, these files were created with overly restrictive permissions, causing unexpected issues.
When you open a project with multiple folders that hasn't been used yet, you'll now see the expected options for each folder instead of a blank screen. This makes it clearer that you can start working in any of the project's declared locations.
Plugins can now be installed even if they reference environment variable names containing secrets, as the system has been updated to distinguish between secret names and actual secret values. This prevents legitimate plugins from being blocked incorrectly during installation.
The "Waking up..." message no longer gets stuck on the screen after switching profiles. This ensures a smoother experience when navigating between different user profiles in the desktop application.
Hermes now correctly informs you when a peer has received your message but is still processing their turn, preventing accidental duplicate messages. This improves clarity and avoids unnecessary resends when a peer is busy.
Now, when you select multiple options in a clarification question and type a custom answer, your selections are remembered along with your text. This makes it easier to provide detailed feedback without losing previous choices.
The way your chosen AI model is saved when chatting with a bot has been improved. Now, if you select a specific AI model for a bot chat, it will remember your choice even if you switch to a different bot or come back to the chat later. This prevents the bot from reverting to its default model unexpectedly.
Teammate direct messages now send completely, even if they are very long. If a background task's output is cut, you will be clearly notified and told where to find the full text.
When an approval is needed, clicking the floating arrow now correctly scrolls you directly to the pending approval, even if there's newer conversation text below it. This ensures you don't miss important approval requests.
The first and last prompts in the sidebar now correctly display their preview tooltips when you hover over them, making it easier to see what each prompt is about. This change ensures a consistent user experience across all prompts in the sidebar.
Messages you've just sent will now stay visible even if the app quickly refreshes before the server confirms they were received. This prevents losing your sent messages during app reloads.
When renaming a session, you can now select text within the input field without accidentally dragging or interacting with the session list. This makes editing session names much smoother and prevents unwanted actions.
Direct messages relayed by the desktop app will now arrive in your bot chat even if the recipient's gateway requires you to be logged in. This fix ensures these messages are delivered correctly, instead of being blocked and lost.
Attachments like spreadsheets and documents that were saved with a path relative to your user's home directory can now be opened for preview or download. This fixes an issue where these files would incorrectly show as "not found."
The age displayed for bots in your contact list now accurately shows the last time the bot was active, whether it was through a chat or by performing background tasks. This change ensures you have a more up-to-date view of bot activity.
Office documents and other Microsoft file types sent in chat will now correctly appear on the Artifacts page, making it easier to find and review them. Previously, these types of files were not recognized as artifacts.
Hermes now correctly sends messages to Bot Chat even if the scheduler is in a deleted directory. It also prevents the command-line tool from crashing if you start it from a directory that no longer exists.
Tests that check how Hermes updates npm dependencies now run much faster by preventing them from actually calling out to the internet. This speeds up the testing process without changing how Hermes works in production.
The Hermes Bot Chat can now handle damaged mailbox tickets without getting stuck, ensuring other messages can still be delivered. This update also makes the bot more efficient by avoiding unnecessary file system operations.
You can now scroll up to reread previous messages while the assistant is generating a response without being pulled back to the bottom. This makes it easier to review the conversation context when waiting for the agent's reply.
The undo function in the desktop editor now correctly reverts text that was cut or dragged. This fix ensures that you can easily undo these common editing actions to restore your content.
Currency amounts with prefixes like "R$" or "US$" will now display correctly in the desktop app, preventing them from being misinterpreted as mathematical formulas. This ensures that monetary values are shown as intended for users outside the US.
The local model server will no longer accidentally receive sensitive information, preventing a crash on Windows and improving security. This change cleans up the environment passed to child processes, ensuring only necessary details are included.
Keybindings you assign to actions from plugins will now be remembered even after you restart the application. This prevents your custom shortcuts from being lost when a plugin is temporarily unavailable.
Commands like `/context` are now correctly grouped and handled as built-in features, even when the system is offline or just starting up. This ensures these essential commands are always available and recognized.
When a bot chat is already open in the desktop app, commands sent to that bot now correctly go to the open chat instead of starting a new one. This ensures messages and replies are all in one place and prevents the API from running duplicate processes.
Hermes will no longer ask for permission to replace tools if a plugin doesn't declare any capabilities. This clarifies the process and avoids unnecessary prompts for plugins that cannot perform such actions.
When you highlight text in the chat while a new message is being sent, your selection will now stay put. The chat will automatically resume scrolling to the latest message once you're done selecting text.
When you search for a specific session ID in the sidebar, that session will now reliably appear at the top of the search results. This makes it much easier to quickly find and jump to the exact session you're looking for.
The agent now handles large files and folders more efficiently by only reading necessary parts before applying size limits. This prevents the agent from consuming excessive memory when processing big files or extensive folder structures.
Skills installed from the Bot Mode Skills Hub now correctly install to the bot they belong to, even if that bot is managed by another connection. This prevents installation errors and ensures skills are applied to the right place.
When you send a message with attachments that gets interrupted, like by switching chats, it will now correctly send those attachments to the chat you originally intended, not just the one you're currently viewing. This fixes a bug where interrupted messages might go to the wrong conversation.
When a relayed direct message to a teammate's bot chat is open on desktop, you'll now see their actual reply instead of just a confirmation that the message was sent. This makes cross-device communication feel more natural and seamless.
Hermes Agent now correctly removes disbanded bot mode group chats. This prevents old chats from reappearing even if one of the connected services misses the deletion notification.
When you stop or cancel an action, Hermes will now correctly show an "Interrupted" message instead of "Result unavailable." This makes it clearer when an action was stopped by you versus when it failed on its own.
You can now choose to hide the timeline bars in your conversations from the desktop appearance settings, which can help declutter your view. This change makes the interface more customizable by allowing you to remove navigation elements you don't need.
Installing the Hermes Agent on Termux no longer automatically tries to build a complex networking library called uvloop, making installations faster and simpler. You can still choose to install uvloop if you need it, but it's now an optional extra.
When you use the `/resume` command while viewing a specific Bot's chat, your resumed conversation will now correctly open within that Bot's dedicated workspace, instead of disappearing to the main chat list or leaving an empty Bot window open. This makes it much easier to keep your Bot conversations organized and accessible.
Plugin-added actions in the chat composer now appear next to the send button when composing multi-line messages. This makes it easier to find and use these custom actions.
Group chat turns are now more reliably handled, preventing lost progress and ensuring members have more time to respond. The system also now provides clearer error messages when too many bots are running.
The disk cleanup feature now correctly identifies files within Git worktrees as managed by Git, preventing accidental deletion of important test files. This ensures that your Git repositories are kept clean while still removing temporary files that are no longer needed.
The update checker now correctly identifies when your local code is up-to-date, even if you have local changes. It also shows you the actual commit messages for any available updates instead of a generic placeholder.
Checkpoints will now automatically clean up temporary files left behind by interrupted processes, preventing unnecessary disk space usage. This ensures that the system remains efficient and doesn't fill up with old, orphaned data.
Skills that link to documentation files located above their own directory can now be installed correctly. This change ensures that these skills are not mistakenly rejected during installation, allowing them to be used as intended.
The process manager now correctly handles cases where a kill command doesn't fully stop all related processes. This prevents leftover entries from inaccurately showing as "killed" and ensures the system accurately tracks which processes are still running.
The Hermes Agent now speaks the last sentence of a completed thought immediately, even while it's still processing a request, making the audio output more natural and responsive. This change ensures that narration you hear is more timely, rather than waiting for the next piece of information to arrive.
The initial setup now ensures that common AI models are available offline, improving reliability. Additionally, the agent is more robust by preventing unnecessary upgrades of certain AI model types and by handling errors more gracefully when interacting with plugins.
The project's dependencies have been updated to remove security vulnerabilities. This makes Hermes Agent more secure by addressing potential risks in libraries it uses.
The Hermes Agent now correctly closes its database when shutting down, even if a request was canceled. This prevents the database from being left open unexpectedly after a shutdown.
Hermes Agent now correctly prevents profiles from using your main cloud credentials when they don't have their own. This ensures better security by preventing accidental credential sharing between different services.
When a temporary error occurs while sending a direct message to a peer, Hermes will now retry the message once to increase success rates. Additionally, if a peer bot responds with a "silent" marker, Hermes will no longer treat it as a reply and will instead correctly indicate no response was received.
Allowlists for Discord, WhatsApp, and DingTalk platforms will now correctly recognize chat and user IDs when configured as a JSON list string. This fixes an issue where these allowlists were previously ignored, preventing users from being added to specific conversations or groups.
Teammates in bot relay mode are now displayed using their connection names, making it easier to identify who is online. This change improves clarity by showing friendly names like "My Computer" instead of technical IDs.
When Hermes waits too long to write to its database, the logs will now show which specific Hermes process was holding the lock. This makes it much easier to figure out why database operations are failing.
Messages relayed by bots will now correctly report their status when they finish, even if there's a slight delay. This prevents false errors and ensures you see the bot's actual response.
When a bot assistant sends a message, you'll now see the full reply, not just a shortened version. If the message is too long to display completely, it will clearly indicate that it was cut and where to find the complete log.
The chat interface no longer types a stray 'l' when resuming or restoring a dashboard session. This makes the input box behave as expected after these actions.
You can now create a new bot on a different machine starting with a clean slate. Previously, you were forced to copy an existing bot, but now you have the option to start completely fresh.
Replies sent in group chats now correctly show which machine sent them, even for local members. This makes it clearer who is speaking in shared rooms, especially when multiple people are using different computers.
The Bots roster now only refreshes when there are actual changes, preventing unnecessary updates every 5 seconds. This makes the application more efficient and prevents potential glitches.
The `/undo` and `/retry` commands now work correctly even after the assistant fails to respond. This ensures that you can reliably revert or resend your messages in all situations.
Renaming your bot in Bot Mode no longer breaks existing group chats. Your bot's old username will still work in older conversations, so you won't lose your chat history or need to re-add your bot to groups.
Mobile keyboards on Android will no longer duplicate text in the chat terminal. This change ensures that words typed on mobile are sent accurately, preventing common input issues like repeating words or backspace problems.
The API now shows when a run is starting to shut down, so you can see if it's still being processed or waiting to finish. This helps monitor runs more accurately when they are being stopped or restarted.
The names of the "Sessions" and "Bots" tabs in the sidebar now correctly switch to your chosen display language. This makes it easier to navigate the application when using languages other than English.
Bots on remote machines can now be contacted using their descriptive titles, and messages they send back will show a reply-friendly sender. This makes interacting with remote bots more intuitive and reliable.
Clicks and scrolling within the file preview now accurately target the intended elements, even when the page is zoomed in or out. This ensures a smoother and more reliable user experience when interacting with previews.
Hermes doctor now checks if your GitHub token is valid. If it's expired or revoked, it will tell you which file contains the bad token so you can fix it.
The tool for archiving old conversations now correctly handles live chats. Previously, it could accidentally hide active chats if their older history happened to match the archive criteria.
Sending and editing messages in Telegram now uses a shared timing mechanism, preventing "flood" penalties and ensuring smoother message delivery. This change also makes sure that edits don't break mid-word and properly respects Telegram's waiting times.
Hermes now correctly handles situations where a large data store might cause a lengthy startup check. This prevents the system from repeatedly restarting and ensures large stores can boot successfully.
The text-based interface now correctly keeps connections open while actively streaming data, preventing unexpected disconnections during ongoing operations and ensuring a smoother user experience. This change ensures that the interface behaves like other clients by recognizing any incoming data as a sign of activity, rather than prematurely closing connections.
When the Hermes Agent starts up, it now clearly shows which specific servers failed to connect and the exact error, instead of just a general count of failures. This helps users quickly identify and fix connection issues with their servers.
This change improves performance on Windows by preventing the system from getting stuck when checking active user sessions. It makes the agent more responsive and prevents certain tasks from failing due to delays.
Hermes Agent can now restart more quickly even if a scheduled task gets stuck. Previously, a stuck task could delay restarts for a long time, but now it will be recognized as stuck and skipped, allowing the restart process to continue without unnecessary delays.
The application menu on macOS now correctly appears only after the first window is ready, preventing crashes during app updates. This ensures a smoother user experience by avoiding issues where the menu tries to load before the application is fully prepared.
The desktop app's update checker now correctly uses your network's proxy settings when checking for updates. This prevents the update check from failing when you're behind certain corporate firewalls.
The "Open containing folder" option now correctly shows a message if the file is not on your current computer, and it's only offered when you're working with local files. This makes the feature more reliable and prevents confusion.
This update ensures that Copilot's internal AI providers consistently use a specific way of communicating, even when switching to a fallback system like GPT-5. This prevents errors and keeps the service working smoothly for users.
Typing Enter in the bot roster section now works as expected, preventing accidental submissions while composing text. Additionally, toast notifications for bot activity will only appear once, even if the activity status hasn't changed, reducing repetitive alerts.
The way the bot manages its private chat has been improved so that messages always go to the correct, hidden chat. This fixes a bug where messages could incorrectly go to a different, numbered chat, preventing the bot from responding.
The project now only attempts to get a special Copilot token when Copilot is actually selected, and it will only warn you once if there's a problem with that token. This prevents unnecessary warnings and speeds up performance when you're not using Copilot.
The "Open containing folder" option is now hidden when working with remote files, preventing confusion. If you try to open a folder that doesn't exist on your computer, you'll now receive a helpful notification instead of nothing happening.
When a desktop agent quits or crashes during a group chat, its unfinished turn is now saved and re-submitted later instead of being lost. This ensures that replies are not lost and the agent is not asked to repeat work it has already started.
The dashboard will now correctly resume your chat after a restart, ensuring you don't end up in an invisible conversation thread. This fixes a bug where restarting the gateway could cause your chat history to become inaccessible.
Bot chats now use the Bot's own unique voice for speaking. This makes conversations with bots feel more personal and distinct.
Bot Mode now allows you to compress individual members' hidden room histories, preventing issues where they might stop responding. This fix makes it easier to manage and recover those hidden conversations.
When logging into MCP, the process will now correctly wait for the full OAuth approval time you've set. If it still fails, you'll get a clear message explaining why instead of just a blank error.
Conversations with bots now end properly even if your app disconnects unexpectedly during a critical moment. This prevents old conversations from blocking new ones.
Notifications for a pinned profile that doesn't have a specific platform's adapter will now be reliably sent through the main bot. This ensures that messages intended for that profile reach their destination, even if the profile uses adapters for other platforms.
The Hermes CLI now correctly recognizes and uses platform toolset configurations that were previously misinterpreted. Additionally, when certain configuration steps are skipped, the tool will now log a warning instead of silently ignoring them. These changes improve the accuracy and transparency of how Hermes manages your development environment and tools.
The approval process for plugins has been updated to better understand specific error types from network requests. This change helps Hermes Agent recover more effectively from issues like authentication problems or being rate-limited.
Desktop cron jobs listed across all profiles now correctly display their actual run history and allow actions to be performed on the job's original profile, preventing errors. This ensures that when you view all your cron jobs, their associated data and management functions are accurately linked to where they are actually configured.
The way bots are mentioned in messages has been improved. If two bots have the same name, the system will now clearly distinguish them by adding connection information, and bots will be recognized even if you haven't opened the bot list before.
The Hermes Agent now warns only once if you set an invalid value for the Langfuse maximum depth, instead of warning every time it processes data. This makes the system more efficient by reducing unnecessary warning messages.
The Hermes update process now correctly identifies and uses your project's virtual environment, even if it's located outside the main code directory. This ensures that necessary tools are updated properly and prevents errors during the update process.
Hermes on Windows will now correctly identify and remove leftover background tasks and startup items from older installations when checking status or uninstalling. This ensures a cleaner process and prevents old entries from causing issues.
We've updated a core component of Hermes to its latest major version, which improves how credentials are managed internally. This update means you'll need to re-authenticate your credentials the next time you use this component.
Previously, if the tool for controlling the browser became unresponsive, it would fail repeatedly. Now, it will attempt to restart the unresponsive tool once, allowing subsequent commands to succeed without manual intervention. This prevents workflows from getting stuck due to temporary browser tool issues.
The dashboard no longer freezes when dealing with a large database. This change ensures that searching, viewing statistics, and inspecting individual sessions won't cause the entire interface to become unresponsive.
When a conversation is interrupted and then redirected, Hermes now correctly quotes the message that initiated the redirect. This ensures that replies are sent to the most relevant part of the conversation, making interactions smoother.
The Hermes Agent now correctly detects when Deno's `eval` command is used, even when quiet or logging flags are included. This ensures that potentially risky code executed with `deno eval` is always properly flagged for approval, preventing security oversights.
Custom routes using Anthropic's API for Claude Code will now correctly send OAuth identity information, preventing rate limit errors and ensuring proper initialization of the AI agent. This fix allows the agent to function reliably with these custom API configurations.
The computer-use doctor and status checks now correctly identify when the cua-driver daemon isn't running and provide specific guidance on how to fix it, rather than showing everything as okay. This improvement is crucial because previous checks only looked at the program's availability, not whether it was actually active and responding.
Messages written by bots or tools into a member's session within a group chat now appear in the main room log for everyone to see. This ensures a complete conversation history, including bot interactions, is preserved and accessible even after restarting the application.
This update ensures that data stored as bytes in specific message fields is preserved and accessible. This prevents errors when processing or displaying messages that contain this type of data.
Hermes now correctly signals a running process to restart on macOS, preventing long delays when updating multiple profiles. This ensures that updates finish much faster by avoiding system-imposed pauses.
The Hermes Agent can now use the new Hermes Herald plugin. This plugin allows different Hermes agent profiles to communicate and share work, making them more powerful and collaborative.
Messages that were sent but not delivered are now re-offered automatically instead of being lost forever. The system now also ensures that the first valid response received is kept, preventing later incorrect replies from overwriting it.
The Hermes Agent now includes Handflow, a new planning tool that helps users break down tasks into steps and track their progress. This feature allows the agent to create a plan before starting work, update step statuses as it progresses, and even adjust the plan mid-execution, improving organization and control.
The Hermes Agent now correctly handles expired or failed sign-in attempts by re-minting the authorization process, allowing users to complete their sign-in from the dashboard. Previously, such attempts would break the connection, requiring a restart.
This update ensures that each chat tab in the Hermes dashboard gets its own dedicated terminal session, preventing tabs from interfering with each other. This means you can now open multiple chat tabs simultaneously without issues.
The Hermes desktop application now uses CPU much more efficiently when idle. It previously checked too often if other processes were still active, but now it checks at a more sensible pace, like most other background tasks.
The Hermes Agent's `/model` command now loads provider information much faster by using a saved cache instead of waiting for live updates. This change prevents long delays for users when they access model information through chat platforms.
Custom model settings are now correctly applied to their context length, preventing unnecessary delays when starting up the agent. This means the agent will use your defined context length for custom models without needing to contact the provider's API on every startup.
Hermes Agent now stops unnecessary background activity for hidden chat tabs, significantly reducing resource usage. This change ensures that only actively viewed chats consume system resources, making the application more efficient.
Hermes Agent now better manages the display of chat conversations when multiple chat windows are open. This change ensures that the total amount of visible conversation content across all open windows stays within a reasonable limit, preventing performance issues and making the app smoother to use.
The way Hermes starts up a backend for your profile has been improved. Previously, just hovering over your profile could unnecessarily start up a backend, but now it only happens when you actually move your mouse over it, saving system resources.
Typing in the desktop composer is now smoother because it no longer blurs the background with every keystroke. This change improves performance by simplifying how the typing area is displayed.
Free-tier accounts can now access subscription-billed AI models without seeing confusing error messages. This change ensures that the agent correctly identifies and allows access to these models, improving the user experience.
When the conversation becomes too long for the model to process, Hermes now immediately guides you to start a new session instead of getting stuck. This prevents long waits and freezes that could occur when the agent tried and failed to compress the conversation.
You can now sign back into a remote gateway from the Gateway settings screen if your session expires, even if the gateway address is fixed by your environment. This makes it easier to reconnect without needing to restart the local gateway.
The BrowserClaw plugin has been updated to version 2.9.3, which includes significant improvements for handling web sessions, navigating complex web pages, and enhancing security. This update ensures a more stable and robust experience when interacting with websites.
Animated effects on desktop are now more efficient by moving their code to a central stylesheet, reducing unnecessary recalculations. This should lead to smoother performance, especially when switching between different parts of the application.
The Hermes Agent will now be more resilient to brief connection drops, preventing rapid, resource-intensive reconnections. This means the dashboard will remain more stable and responsive even if the connection is temporarily unstable.
Messages sent through WhatsApp and Weixin will now reply more quickly without long delays before each message. The default waiting times have been updated to match Telegram's faster sending speeds, making your interactions feel more responsive.
Faster AI models that use your graphics card will now work correctly when Hermes is run as a background service. This is because the service configuration now includes the necessary library paths for your graphics card, ensuring these tools can find their required components.
When a batch of operations fails, Hermes Agent now sends back a much smaller error message instead of the entire memory store. This prevents repeated failures from overwhelming the system with unnecessary data, making it more efficient and stable.
Hermes Agent now correctly uses your configured package mirror when installing dependencies, preventing long delays. This ensures that essential components install quickly, even if your network blocks access to the default package source.
This update improves performance when sending large amounts of data to the AI by having auxiliary communication channels bypass a slow data processing step. This makes the agent faster and more efficient when handling complex requests.
The program now correctly archives only new messages when rewinding, preventing unnecessary duplication of past conversations. This change significantly reduces the memory and storage space used by long conversations.
The Hermes Agent now intelligently skips unnecessary dependency installations when your project files haven't changed. This speeds up the build process by avoiding redundant work, saving you time.
The spacing at the top of the chat preview has been fixed to ensure consistency. This update makes the chat interface look more balanced and professional.
Settings are now better organized into clear sections, making it easier to find what you're looking for. Navigation is also improved with more consistent breadcrumbs and independent controls for expanding and collapsing menus.
We've improved how Hermes handles displaying many split panes on desktop. This change ensures that even with a large number of panes, the interface remains responsive and usable.
The Hermes Agent now clarifies why it forwards the SIGUSR2 signal. This helps users understand how the agent's error reporting mechanism works during startup.
A new community plugin for sketching directly in Hermes has been added, allowing you to draw with your mouse, confirm your creations, and have them automatically sent as an image with your next message. This makes it easier to visually share ideas and annotations without needing API keys.
Jobs that were stuck running indefinitely due to a worker becoming unresponsive can now be properly resumed. This prevents a single stuck worker from blocking other jobs from starting.
Hermes now ensures that alerts for cron jobs failing to deliver to bot chat within the timeout are not lost. Instead, a special marker will be sent, letting you know that an alert exists but its full details couldn't be delivered.
Messages sent to Telegram will now automatically give up if they get stuck, preventing one slow message from blocking all others. This ensures that even if a connection is temporarily problematic, other chats can continue to send messages without delay.
The Hermes Agent can now correctly find the Claude Code command, even when launched from the graphical interface. This prevents errors that previously occurred when the agent couldn't locate the up-to-date version of Claude Code.
The system now correctly checks who is inviting you to a Matrix room before automatically joining you, preventing unauthorized users from adding you to groups you didn't explicitly accept. This improves security by ensuring only trusted contacts can initiate direct messages or add you to rooms.
The project now includes support for interacting with reMarkable tablets and their cloud service, allowing for easier document management and backups. This integration is optional and adds various tools for transferring files, managing notebooks, and previewing content without altering core Hermes functionality.
The agent now releases excess memory back to the operating system after processing large tool results. This prevents memory from accumulating and improves overall performance and stability.
The `hermes skills check` command now avoids downloading every installed GitHub skill's files if there haven't been any changes. This makes checking for updates much faster and uses less data.
The Hermes dashboard no longer starts unnecessary background processes when it's first launched without any active users. This change prevents excessive disk activity and log file growth, especially on systems like NAS devices. Now, these background processes only start when a user actually connects to the dashboard.
The RSS reader plugin has been updated to a new version, which improves how it manages saved articles and allows you to arrange your feeds in a custom order. This makes it easier to keep your reading list tidy and organized.
When Hermes Agent is stopped abruptly on macOS, it now ensures that its internal processes have enough time to finish cleanly. This prevents the agent from being forcibly terminated before it can complete its shutdown procedures, leading to more reliable operation.
Hermes Agent now writes its status to disk in the background, so a slow disk will no longer freeze the entire system. This change ensures that Hermes Agent remains responsive even if disk operations are slow.
Tests that were previously crashing due to excessive memory use now run correctly. This also prevents tests that fail from being repeatedly restarted, which could cause further problems.
A new plugin is available that allows the agent to perform image manipulation tasks like resizing, cropping, and converting image formats directly. This makes it easier and more efficient for the agent to work with images without needing to run external programs.
The tool no longer repeatedly asks you to choose a browser provider after you've already set it up. It also now correctly prompts you to select a browser provider if you haven't configured one yet.
When you switch chats after typing a correction, it will now stay with the correct chat. This prevents unexpected behavior where a correction might apply to the wrong conversation.
Dismissed preview chips will now stay hidden even after navigating, reloading, or reopening the application, which helps keep your workspace tidy. Additionally, the agent will no longer incorrectly treat read-only files or old package files as actionable items.
We've added four new plugins to our catalog: xmemo, covision, meeting-overlay, and profile-pane. These plugins provide new capabilities for memory management, visual collaboration, meeting enhancements, and user profile management, making Hermes Agent more versatile.
The plugin installer now has fewer false alarms for certain types of code that aren't actually a security risk. This means you'll see more accurate warnings about potential security issues without being bothered by irrelevant ones.
We've added a troubleshooting guide for when the agent appears to forget things between sessions. This new section helps users understand why their saved information might not be available in a new conversation.
This update fixes an issue where background threads in tests were not properly shut down, causing the program to crash. The changes ensure these threads are cleaned up correctly, preventing crashes and improving test stability.
The new `z-ai/glm-5.3-flashx` model is now available to use, giving you access to a faster version of the `glm-5.3-flash` model with a larger memory capacity. This means you can process more text and get responses more quickly when using this model.
The command-line interface footer will no longer incorrectly display "Window too small..." messages. This ensures the footer remains visible and functional regardless of your terminal size.
Voice boundary tests are now passing, fixing an issue that was preventing other changes from being merged and unblocking all ongoing desktop development. This ensures that the project's main branch remains stable and all new features can be integrated smoothly.
You can now install plugins directly from the public catalog using a link. If the plugin is found in the catalog, it will open the familiar install dialog; otherwise, you'll receive an error message.
The `/branch` command now creates a new, separate chat thread by default on platforms like Discord and Slack, preserving your original conversation. You can still choose to branch within the same chat if you prefer using the `--here` option.
External tools that provide AI models can now be installed and managed as separate plugins. This makes it easier to integrate new AI providers and keeps the core project cleaner.
Background terminal processes are now visible in the main interface, making it easier to track their activity and status. This change allows you to see and manage these background tasks alongside other agents, providing a more complete view of what's running.
When using a local server for custom settings, the automatic conversation title is now generated only after the agent's response is complete. This prevents the title from accidentally being included as part of the conversation reply, ensuring a cleaner chat history.
The documentation for the security-godmode skill has been updated to fix an automated check that was failing. This ensures our documentation remains accurate and up-to-date without requiring manual intervention on every change.
When a command used with `@` references outputs too much data, it will now be correctly reported as an error. This ensures that truncated output isn't mistakenly treated as a successful result.
When you don't specify the reasoning effort, Hermes Agent now defaults to a "medium" setting for custom OpenAI-compatible services, similar to how it works with other services. This ensures consistent performance and prevents some services from using a much slower default.
Previously, some tests that simulated process behavior were unreliable because they sometimes failed due to the test environment's timing rather than actual code errors. These changes fix that by making these tests more robust and less prone to timing-related failures.
The plugin installer now correctly handles annotated tags when you specify a tag name for installation, ensuring plugins are installed from the exact commit a tag points to. This makes installing specific plugin versions more reliable.
The installer now correctly recognizes if you've already installed essential tools like `rg` and `ffmpeg` in your user's local bin directory. This prevents the installer from unnecessarily prompting you to install them again, making the setup process smoother.
The WhatsApp bridge process will no longer accidentally stop when its identifier file contains a path that coincidentally matches another running process. This prevents unintended interruptions by ensuring we only target the correct bridge process.
The agent now correctly shows the contents of folders referenced with `@folder:` even if they are outside the current working directory, as long as they are within a wider allowed area. This makes it easier to refer to and review shared code or files located in related directories.
We fixed a bug where compression operations could interfere with each other, causing data loss during simultaneous compressions. This ensures that newer compression tasks will correctly maintain their progress, even if older ones finish at the same time.
You can now switch models when using pooled credentials that don't have a specific server address defined. This prevents errors by automatically finding the correct server for your chosen model.
The Hermes Agent now checks process information more efficiently on macOS and BSD systems. This change prevents unnecessary process forking, improving performance by avoiding the creation of multiple 'ps' processes for each connection.
Plugins that unexpectedly try to exit the program will now be safely handled, allowing other parts of the process to continue running. This prevents a single plugin error from stopping the entire operation, making Hermes Agent more robust.
Hermes Agent now correctly identifies and blocks or allows URLs when they use a specific IPv6 format that embeds an IPv4 address. This ensures more consistent security checks for network requests, preventing potential issues where certain types of fake IP addresses were not being properly recognized.
Hermes now correctly rejects models from a provider's custom model list that aren't actually in that list, even if a general model listing would have accepted them. This ensures that a provider's specific catalog is the ultimate authority for its own models, preventing unexpected acceptances.
The Kanban board's automatic card parking has been improved to prevent healthy cards from getting stuck unnecessarily. This means the system is less likely to misinterpret ordinary text or error messages as reasons to halt a card.
Models using a specific type of expert tensor (MXFP4) will now load correctly, showing a preset instead of an error. This allows users to more easily use these powerful models.
Previously, the agent could sometimes keep outdated information after making changes to conversation history. This update ensures that all edits to persisted messages are correctly saved, so the agent always uses the most up-to-date conversation context. This prevents potential confusion or incorrect behavior due to stale data.
A fix ensures that if a primary compression process times out, a leftover attempt won't incorrectly overwrite the summary created by a backup process. This prevents stale data from interfering with the conversation's memory.
The system now correctly identifies when sensitive information might be sent to an operator, preventing accidental data leaks. It distinguishes between sending data to a general operator and sharing necessary context with specific workers or sub-agents.
Previously, a temporary unavailability message from CommandCode would incorrectly cause the agent to stop using its API key. This update correctly identifies that message as a temporary overload, preventing unnecessary downtime and ensuring the API key remains healthy.
The agent now correctly understands when advice is outdated, preventing it from unnecessarily repeating tool calls it has already made. This improvement ensures the agent acts more efficiently and avoids redundant actions.
Hermes Agent now more strictly checks Python code that attempts to read secret files like `~/.hermes/.env` or `~/.ssh/id_rsa`. This change ensures that plugins attempting to access sensitive credentials are flagged as a critical security risk.
Hermes Agent now automatically cleans up idle kernel processes that are no longer in use, preventing them from consuming resources. It also removes old temporary directories left behind by crashed hosts, ensuring a cleaner system.
Hermes Agent will now correctly distinguish between safely deleting a merged Git branch and force-deleting a branch. This prevents unnecessary warnings when using the safe deletion command, making the tool more user-friendly.
The system will now warn you when a smart approval tool provides an empty response, instead of silently moving to a higher escalation level. This change makes it clearer when an approval step might not be working as expected.
Searches on macOS now correctly return results even if the search hits its limit, instead of showing an error. This ensures you always get the information you need, even when dealing with complex system behaviors.
Hermes Agent will now correctly identify running jobs even if their start times are slightly out of sync. This prevents accidental termination of active processes due to minor timing discrepancies.
Sensitive information from commands run in the TUI is now better protected. This change prevents secrets from being accidentally exposed when running shell commands through the TUI.
The Hermes Agent can now correctly report any newly registered attachments when a task is completed. This ensures that workers accurately see all generated files after a task finishes.
Hermes updates now correctly handle gateways running from separate code checkouts, preventing them from being mistakenly marked as "stale" and causing the update process to hang. This ensures that the update process recognizes these external gateways and doesn't incorrectly flag them for an unnecessary restart.
The terminal now clears cleanly when exiting, without flashing a console window. This prevents unnecessary pop-ups, especially in environments where the "clear" command might not be available.
The scratch directory used by Hermes Agent now correctly respects your system's permissions and any custom settings you've defined. This ensures that sensitive data stored in the scratch directory is handled more securely and flexibly, especially on managed systems like NixOS.
Hermes Agent can now automatically retry starting certain profiles if they fail temporarily, preventing them from getting stuck. This change ensures that profiles with minor startup issues will be tried again instead of being ignored.
The Hermes Doctor tool will now correctly identify and report npm vulnerabilities without suggesting fixes that are immediately undone by updates. This ensures the agent's dependencies remain secure and up-to-date.
When two Hermes agents start simultaneously, they now correctly share a single router instead of attempting to start two. This prevents conflicts and ensures a smoother startup experience.
Screenshots with transparent backgrounds can now be sent properly. Previously, these images would fail to send, but now they are correctly converted to a format that can be sent as a thumbnail.
Commands like "stop" when used inside code blocks or quotes in group chats will no longer incorrectly trigger bot actions for a member. This ensures only plain commands correctly control bot behavior.
The system now better detects when a delegated agent is stuck by timing out based on inactivity rather than total runtime. This change provides more precise information when a timeout occurs, helping to diagnose issues more effectively.
The agent will now correctly handle Thai language reasoning by preventing incomplete or awkward responses from being shown to the user. This update ensures a smoother and more accurate experience when the agent is communicating in Thai.
Plugins that use certain phrases in their text or comments can now load correctly, preventing accidental import errors. This ensures that plugins with UI labels or descriptive comments are not incorrectly treated as code.
The Hermes Agent now correctly identifies when a provider quota is exceeded, distinguishing it from authentication failures. This change ensures that Kanban workers temporarily exit with a specific rate-limiting code, preventing them from being incorrectly marked as failed and tripping system breakers.
This update ensures that on Windows, skill checks correctly report when a skill is up-to-date, preventing them from falsely indicating an update is available after installation. This resolves an issue where file encoding differences caused skills to be repeatedly re-downloaded.
Audio messages and voice notes can now be sent correctly through platforms like Matrix, LINE, Mattermost, and Weixin. Previously, these messages were rejected due to an error when trying to send them.
The systemctl reload command for the gateway now correctly informs you that it performs a graceful restart rather than an in-process configuration update. This change clarifies how restarting the gateway works and improves its logging.
The desktop app will now correctly skip backing up your settings when you've turned off the automatic backup feature. This prevents unnecessary disk space usage and speeds up updates when backups aren't needed.
Scheduled bot chats will now correctly use the environment and credentials of the profile they are sending to, instead of accidentally using the sender's settings. This ensures bot chats function as expected when interacting with different profiles.
Slack reminders set to go off within an hour will now appear in the same chat thread where you asked for them. This makes reminders more helpful and less disruptive.
The Claude subscription plugin now installs from a trusted source, ensuring it's officially recognized and managed. This change provides a more secure and reliable way to use the plugin, which helps integrate Claude's capabilities with Hermes.
Hermes Agent now uses Git Bash for running shell commands on Windows, ensuring commands that fail silently are correctly reported instead of being treated as successful. This makes it easier to diagnose problems with shell scripts.
You can now properly categorize a task that was previously unclassified after a failure. This makes it easier to track and manage your tasks in the Kanban board.
The way Hermes finds commands has been improved to prevent unintended changes to your system's search paths and to correctly handle when a command isn't found. This makes the process more reliable and secure.
The "typing..." indicator in Telegram will now correctly stop when a message fails to send, instead of staying on indefinitely. This prevents confusion by ensuring the indicator only shows when messages are actively being sent.
Hermes Agent now sends scheduled reminders immediately instead of waiting up to a minute. This ensures you get important notifications without delay, even if the system restarts.
Hermes Agent now correctly remembers its previous answers for ongoing tasks, ensuring better continuity even when prompts become very long. This fix prevents important information from being lost between runs, making complex, multi-step jobs more reliable.
This update ensures that when you switch between AI models or change desktop configurations, the agent remembers your preferred context length setting. This prevents the agent from silently using a much larger context window than you intended, keeping your settings consistent.
You can now edit the title, body, and priority of kanban tasks using the command line, and the cron list command will show paused jobs instead of saying there are no scheduled jobs. This makes it easier to manage your tasks and see all scheduled work, even if it's temporarily paused.
Previously, agent tips that you closed would reappear in new conversations. Now, when you close an agent tip, it will stay closed and won't bother you again. This makes the agent experience less intrusive by remembering your preferences.
When you talk to a bot in a chat, it will now use its own special voice for AI conversations. This ensures each bot sounds unique and is set up correctly for its own AI chat experience.
The internal tool for approving changes has been updated to a newer version. This update allows for more flexible configuration of secure connections and improves how audit logs are recorded.