Changelog

Manual cron jobs for relay-fronted platforms now correctly send requests to the running gateway for processing. This ensures messages are delivered through the appropriate channels and provides clearer error messages if the gateway is unavailable.

The Hermes Agent now more accurately estimates the size of data being sent to Codex sessions, preventing unnecessary local compression from being triggered. This ensures better performance and resource usage when interacting with Codex.

This update improves how Hermes manages Python on macOS, ensuring it correctly handles security permissions and prevents future issues that could prevent Python from running. It also makes Hermes more reliable when updating or fixing your Python environment.

Switching between bots now works more smoothly, preventing the bot selection screen from briefly appearing over your conversation. This makes the experience of changing bots feel more seamless.

Clicking on a bot in the list will now take you back to its existing open conversations instead of reopening a chat you previously closed. This prevents multiple instances of the same bot chat from appearing unexpectedly.

When you reopen a past bot chat conversation, Hermes will now automatically show you all the new messages that arrived while the chat was closed. This ensures you see the most up-to-date conversation history without missing anything.

Bot Mode has been redesigned to use the app's existing design elements, making it more consistent with the rest of the application and better integrated into the workspace. This change also expands the developer toolkit, allowing other plugins to use these common components instead of rebuilding them.

Session kernels are now the standard way local code execution works, simplifying how the agent manages code environments and ensuring consistent behavior. This change makes the agent's code execution more reliable and predictable by removing a confusing configuration option.

This update fixes an issue where typing commands in the desktop interface sometimes showed the wrong suggestion. Now, commands are managed more accurately, ensuring you always see the correct command when you type.

Hermes can now display brief, non-intrusive tips with an arrow pointing to specific elements on the screen. This allows the app to guide users through features without interrupting their workflow.

In-app tips, which remind you about useful features, are now enabled by default. This change ensures more users discover helpful tips without needing to actively opt-in.

When you manually run a scheduled task with specific instructions, those instructions will now be correctly delivered and used. This ensures that all details provided for a manual run are honored, even when routed through the gateway.

The project's code formatting and linting are now automatically fixed when you run the `npm run fix` command. This ensures code consistency and reduces manual effort for developers.

You can now turn off both helpful tips and guided tours from the Appearance settings. This gives you full control over when you see these interruptions.

Automatically fixed code formatting and style issues in the JavaScript parts of Hermes. This keeps the code cleaner and easier to manage.

Hermes Agent now supports the "Bot Mode" feature in Japanese and Chinese, making it easier for users who speak those languages to manage bots. This update ensures that key terms related to bots are correctly translated, improving the user experience.

Tests have been added to automatically detect and prevent performance regressions that slow down operations like streaming long replies or listing many sessions. These tests ensure that certain code paths, which have caused issues in the past, remain efficient as the project evolves.

The agent can now compress conversation summaries more quickly when specific conditions are met, using a faster path that limits output and disables complex reasoning. This change also improves how we track the time taken for these summaries to be generated and fixes how desktop applications handle session compaction.

When the summary process stalls and retries, this update prevents past attempts from interfering with newer ones. This ensures that user-generated summaries are correctly recorded and that the retry process functions reliably, even when the system is under strain.

The project now automatically fixes code formatting issues. This helps keep the code clean and consistent without requiring manual effort.

This update prevents deleted profiles from being accidentally recreated by the background scheduler. Now, when a profile is removed, it will stay removed even if the scheduler is still running.

This update improves how Hermes Agent handles compression, fixing a bug where it sometimes disabled a faster processing path incorrectly. It also ensures that timing information for this faster path is now properly recorded, giving us better insights into performance. Additionally, it resolves an issue where the agent would incorrectly set a limit on the number of tokens in certain situations.

Community-created skills are no longer incorrectly blocked just for mentioning configuration files. This change ensures that only skills with genuine intent to modify critical settings are flagged, making more helpful community extensions available.

The Qwen3.8-flash model can now be selected on OpenRouter and the Nous portal, making it easier to use this advanced model. This change ensures the model is correctly recognized with its full context length, offering a better experience for users.

Remote code execution now keeps your session running even when disconnected, similar to local execution. This makes remote operations more reliable and prevents lost work if the connection is interrupted.

The way the code execution tool describes its capabilities has been simplified and clarified. This makes it easier to understand how the tool works, especially how it handles reusing previous work instead of starting from scratch.

Tests that run together no longer interfere with each other, preventing certain model configurations from being incorrectly applied. This ensures that all models can be used as intended, even when multiple tests are executed in the same environment.

The desktop app now has a dedicated "Plugins" tab to discover and install plugins. This makes it easier to find and install plugins for both your local application and your connected agent, and it will alert you if a plugin's agent component is missing.

Sessions now restart correctly even if a provider has been deleted or renamed. Bot Chats will also always use the current settings of your profile, ensuring a more consistent experience.

The way the application selects your primary device has been improved to prevent unexpected switching between local and remote gateways. This change ensures that when you explicitly choose your local device as the default, it will consistently remain your local device, even when other remote services are active.

Hermes Agent can now save large code outputs to a file instead of losing them. This means you can see the full result of your code, even if it's very long, by accessing the saved file instead of re-running the code.

The way Hermes Agent handles large code output has been improved. Instead of silently cutting off output after a certain limit, it now saves the full output to a file and provides a link to it. This means you won't lose any important information from your code.

Hermes Agent will no longer hang indefinitely when updating if it needs to add the official repository as a remote but is not running interactively. The update process now correctly skips this prompt in automated environments or when explicitly told to proceed without interaction, preventing unnecessary delays.

The way we describe what image generation models can do has been significantly simplified. Now, only the features a model actually supports will be shown to you, making it clearer and more efficient. This change reduces confusion by removing descriptions of capabilities that aren't available for the specific model you're using.

The agent now recovers from sessions that encounter corrupted image data, preventing the entire conversation from breaking. Instead of failing completely, it intelligently removes the problematic image parts and retries the request with text only.

The skills scanner is now smarter and less likely to block legitimate community projects. It will correctly identify less risky code patterns and will only flag truly concerning behavior.

The system now correctly removes outdated model or provider information when saving a chat session. This prevents conversations from being accidentally routed to the wrong service, ensuring a more reliable experience.

Deleted bots will no longer reappear as empty profiles after restarting the application. This fixes an issue where remnants of deleted bots could cause unexpected behavior.

The Hermes Agent can now automatically retry sending media that is too large, instead of failing entirely. This prevents sessions from becoming unusable when media files exceed size limits.

When resuming a build that previously failed, selecting a new model now correctly resets the failed state and restarts the build. This prevents sessions from becoming permanently unusable after a build error.

The Windows installer now correctly checks your npm version before starting to build your app, preventing installation failures. This ensures that if your system's npm is incompatible, the installer will use its own reliable version instead.

Changes ensure that the agent's capabilities, like image generation limits, are updated during long-running chats. This means configuration changes you make mid-session will now be reflected.

The agent can now handle a specific error message from some image generation services. This means that if the service returns an error indicating an unexpected item type, the agent will automatically remove any images and try again with just text, preventing the conversation from getting stuck.

Messages from the assistant that previously included images could cause errors in future interactions. This update ensures that images from the assistant are properly handled, preventing session disruptions and allowing conversations with images to continue smoothly.

Screenshots captured by Hermes Agent will now remain uncorrupted, ensuring they can be correctly processed by other tools. This fixes an issue where sensitive data redaction accidentally damaged image files.

Hermes will now automatically reject images that are corrupted or incomplete before trying to process them. This prevents errors and ensures a smoother experience when using image analysis features.

Installers will now correctly use Hermes's built-in Node version when an unsupported version of Node.js is detected, preventing installation failures. This ensures a smoother setup experience by avoiding crashes later in the process.

The way Hermes Agent describes video generation options has been improved. It now only shows you settings that your chosen model actually supports, making it simpler and more efficient. This change also reduces the amount of information processed, leading to faster performance.

The project's automated process now automatically fixes code formatting and style issues. This helps keep the code clean and consistent without manual intervention.

When you start a chat session with a specific question, it now keeps the conversation going instead of just answering and closing. This makes it easier for other tools to launch Hermes with a pre-set prompt for an interactive chat.

When images are removed from past conversation turns, the agent now correctly cleans up associated data. This prevents previously removed images from reappearing in future turns, ensuring a smoother and more reliable chat experience.

Assistant messages that only contained images but also had tool calls will now be preserved instead of being deleted. This prevents errors by ensuring that tool responses are still correctly matched to their original requests.

The Desktop MCP tab will no longer crash the entire workspace if the configuration file has a missing or malformed server entry. This change ensures that only valid server entries are processed, preventing unexpected errors and maintaining the stability of the application.

Deleted profiles now stay deleted, preventing old processes from accidentally bringing them back. This makes managing your profiles more reliable.

Hermes Agent now correctly displays installation paths on Windows, preventing confusing mixes of forward and backslashes. This ensures all users see clear, usable path information when interacting with the agent.

The system now uses the built-in "patch" tool more efficiently, reducing the amount of code it needs to process by 17%. This makes the system smarter by avoiding redundant instructions and clarifying how to specify file paths within skills.

The agent can now properly remove old image data from conversations, preventing errors when dealing with large messages. This ensures that older images are cleared out, freeing up space and improving performance.

The system will now allow file operations between different profiles without an unnecessary warning, making it simpler for the agent to manage your files. This change streamlines operations and slightly reduces the complexity of the agent's instructions.

Previously, when connecting to a remote service, local tools on your computer would disappear. This update fixes that so you can see and use your local tools again, even when connected remotely.

This update cleans up how the agent handles tool messages, preventing errors caused by extra spaces in tool IDs and ensuring that incomplete or outdated tool information is properly removed. This makes the agent more reliable and consistent when processing tool interactions.

The project now uses a more efficient way to handle file analysis, reducing its size and improving how it works with documents that need OCR. This means better performance and clearer error messages for scanned documents.

The agent now correctly measures the actual size of data to reduce when a request is too large, rather than relying on an inaccurate estimate. This prevents the agent from getting stuck when trying to recover from errors involving large image files.

Models that use strict tool message ordering will now correctly process conversations even if tool results are slightly out of order or repeated. This prevents errors and ensures smoother interactions with these advanced AI models.

The event loop in the Hermes gateway no longer freezes during operations like sending webhooks or restarting the agent, making it more reliable. This improvement was achieved by preventing blocking code from running in asynchronous parts of the application and adding checks to catch future issues.

Hermes now stores temporary session files on your disk instead of in the computer's temporary memory, preventing issues on systems with limited memory. These files will be automatically cleaned up after 72 hours.

The agent now uses exact token counts reported by the AI provider for most of the conversation history. This significantly improves the accuracy of how much context the agent uses, reducing past estimation errors.

The project's code formatting and linting rules are now automatically applied and fixed, ensuring consistency and improving code quality. This change simplifies maintenance by automating routine code cleanup.

The way we describe to-do items has been simplified, removing redundant information. This makes the agent more efficient by reducing the amount of text it needs to process.

The way the tool describes actions has been streamlined, making it more concise while clarifying how to use the "write" versus "submit" commands to avoid common errors. This change reduces the amount of data the tool sends and receives, making it more efficient.

This update makes switching between conversation sessions smoother by preventing a flickering effect when loading past messages. It also improves how long conversations are loaded after restarting the app, showing a loader and then gradually displaying messages instead of a jarring flash.

You can now perform multiple skill management operations in a single command, even across different skills, with confidence that either all changes will be applied or none will be. This makes managing skills more efficient and reliable by preventing partial updates and unintended data loss.

The handoff feature now correctly works even when you have multiple profiles set up. Previously, a problem with one profile's handoff could block others, but this update ensures each profile's handoff is handled independently and reliably.

The Hermes Agent now prioritizes using a specified vision model for image analysis, making it the default choice whenever you provide one. This change also streamlines the underlying logic for handling images, making it more efficient.

Code formatting has been automatically improved to keep the project clean and consistent. This helps ensure that the code is easier to read and maintain.

Installing Hermes Agent now correctly verifies dependencies, preventing security risks from outdated versions. It also ensures compatibility with newer Node.js versions, avoiding installation failures.

The installation process now correctly handles locked package updates in both Unix installers, ensuring that project-specific settings are used without interference from your personal configurations. This prevents potential security issues and guarantees that your project's dependencies are installed as intended.

The Heads-Up Display (HUD) can now be dragged onto different monitors, even on macOS and Windows with different display scaling. This makes it easier to position the HUD exactly where you want it.

The way Hermes handles code patching has been simplified. This change makes the system more efficient by reducing unnecessary operations for most models, saving processing power and cost.

The Hermes Agent now only enables special peer-to-peer communication tools when they are actually configured and needed, which saves processing time and cost for users who don't use this feature. This change ensures these tools are only active if you've set up connections to other agents or enabled the A2A communication feature.

The project workspace pane no longer flickers unexpectedly when no agent or profile is selected. This flickering happened because the application was trying to display information for a workspace that wasn't properly assigned, causing visual glitches.

Automated tools now automatically fix code formatting and style issues. This keeps the project's code clean and consistent without manual effort.