Changelog

The Hermes Agent now correctly asks for confirmation before switching to a new model if it's potentially expensive. This prevents unexpected model changes and ensures users are aware of any associated costs.

This update improves security by ensuring that only explicitly allowed environment variables can be submitted when installing catalog items. This prevents malicious actors from injecting harmful commands or compromising sensitive settings through the catalog installation process.

The agent now correctly avoids unnecessary disconnections when the underlying platform handles machine suspension. This prevents wasted resources and ensures connections remain stable until the platform itself initiates a shutdown.

Hermes Agent can now detect when a backend task takes too long to complete and mark that backend as "suspect" for recycling. This prevents the agent from reusing a potentially unresponsive backend, making the system more robust.

Projects that are only identified by their repository root will now correctly appear in the project drill-down view. This ensures that your opened project's session stays up-to-date with the project overview.

The agent now properly handles situations where the summarizer might return empty content. Instead of losing important conversation history, the agent will now preserve the session and allow for retries. This also improves how the agent handles certain invalid responses from the language model.

The Hermes Desktop app will now correctly handle corrupted or incomplete icon files. Previously, an invalid icon could crash the app, but now it will simply use a default icon instead.

Previously, invalid characters in tool names within past conversations could cause the agent to fail and require a restart. Now, these tool names are automatically cleaned up, allowing conversations to continue without interruption. This also improves how the agent matches tool outputs to their original requests.

The in-app updater on Windows can now automatically recover if it encounters a specific error that previously could make it un-updatable. This change prevents a rare situation where the updater would get stuck in a loop, ensuring smoother updates for users.

Hermes Agent now keeps background task messages from sub-agents out of your main chat by default. You can still choose to see these messages by enabling an opt-in setting.

This update ensures that when multiple gateways are used, each gateway's identity is kept separate, preventing connections from being mixed up and improving session reliability. It also fixes issues where connections might not be found or where old session data could interfere with new ones.

Resources are now correctly handled by their specific gateway, preventing issues where operations intended for one connection were misrouted. This improves reliability for features like SSH, file uploads, and data deletion.

Secondary gateways now correctly report their status, ensuring they only connect when active and preventing issues when switching between different modes or when cleaning up old connections. This makes the background operations of Hermes more reliable and efficient.

Hermes Agent can now automatically recover from initial connection failures on secondary profiles, ensuring the agent remains operational without needing a restart. This means if a secondary connection briefly falters at startup, it will now retry and re-establish itself.

This update improves Hermes Agent's reliability by ensuring that when the connection drops and reconnects, your conversations, unfinished messages, and connected services are preserved and function correctly. This prevents lost progress and ensures that the agent always uses up-to-date information.

This update ensures that important authentication information and backend processes correctly stick with their intended network connections, preventing errors and improving stability. This matters because it fixes issues where connections might be dropped or users would see incorrect error messages, leading to a smoother experience.

The updater on Windows now more precisely targets only the correct Hermes process to stop, preventing accidental termination of other running Hermes instances. This change ensures that your Hermes installation is updated without interfering with any other instances you might be running.

This update fixes issues where your settings and connections could get mixed up between different profiles or gateways. Now, your chosen profile and connection states will stay separate and reliable.

The way routed conversations work has been improved so each conversation now correctly uses its own history. This also ensures that authentication stays with the original owner, preventing issues for shared bots.

The microphone now works when launching the desktop app from the macOS setup. Previously, the app wouldn't ask for microphone permission, but now it correctly requests access.

The Bots roster will now load more reliably, preventing it from getting stuck and showing an error message if it fails to load. This means you'll have a smoother experience accessing your bots.

The `hermes doctor` tool now helps macOS users identify and fix persistent permission issues that cause applications to keep asking for access. It provides specific instructions to resolve these broken grants, which can occur when application updates create inconsistencies.

Hermes Agent now automatically updates its Windows driver without user intervention, completing much faster. This change also ensures that it quickly stops trying if an update fails, preventing long delays.

Hermes Agent now prevents macOS from forgetting your terminal permissions whenever Python updates. This means you won't have to re-grant access to your files or photos every time a minor Python version is released.

Tests that check how timestamps are displayed now work correctly, even when they run around midnight. This fixes a bug where tests failed because the time was showing as "Yesterday" instead of "Today."

Tooltips now appear instantly when you move your mouse between adjacent items, making navigation smoother without unnecessary delays. This change prevents tooltips from flashing briefly when you're quickly moving your cursor across the screen.

The project's code formatting is now automatically cleaned up when you run `npm run fix`. This ensures code consistency and reduces manual effort for developers.

The macOS updater now ensures your saved login details are never lost. It also makes sure that any fallback processes are strictly verified to keep your data secure.

The agent now automatically disables a visual overlay on Linux desktops that use X11. This prevents the desktop from becoming unresponsive due to a stuck overlay window, which could happen if the agent's capture was interrupted.

The cronjob tool now uses significantly less data to describe its capabilities, making the agent more efficient without losing any important instructions. This change also simplifies how users interact with and monitor cronjobs.

Hermes Agent will now correctly disable screen overlays during certain unrestricted sessions, preventing potential system freezes. This fix ensures that the option to turn off overlays is respected even when the agent runs with elevated permissions.

Hermes on macOS now clearly explains why it needs access to your calendar, reminders, screen, local network, and music. This means you'll see understandable prompts instead of silent denials when Hermes requests these permissions, improving transparency and user control.

The project's code formatting and linting rules are now automatically fixed, ensuring consistency and preventing style-related issues. This helps keep the codebase clean and easier for everyone to work with.

Hermes Agent updates on Windows will no longer fail during the first attempt. This change ensures that the update process correctly waits for background tasks to fully close before proceeding, preventing unnecessary retries.

The project's code formatting and style have been automatically cleaned up. This ensures a consistent and readable codebase for all developers.

Clicking on a bot in the Bots roster will no longer automatically start a conversation with an unnecessary "Hey, tell me about yourself!" message. This change ensures that intro messages only appear when you're creating a brand new agent, saving you from unwanted prompts.

Automated code formatting tools have been updated to automatically fix common code style issues, making it easier to keep the project's code clean and consistent. This change helps ensure all developers are working with a unified code style, improving readability and reducing potential errors.

Hermes now includes identifying information in its requests to OpenViking. This allows OpenViking to recognize Hermes as the source of the requests, improving clarity and potentially enabling better management of these interactions. Anonymous probes will not include this identifying information to maintain security and privacy.

This update fixes an issue where the Hermes Agent would incorrectly reference a non-existent variable when running on macOS. This prevents potential errors and ensures the agent functions properly on that operating system.

The project's code formatting is now automatically corrected by a new tool. This ensures the code stays clean and consistent without manual effort.

The cron job tool now correctly saves whether a job should be allowed to resume. This ensures that your jobs can be continued after they are interrupted.

Hermes Agent now better captures conversations from automated tasks that don't start in a specific chat. This makes it easier to follow and reply to messages from these tasks, even if they were initially sent to a general channel.

Hermes now provides clearer error messages when cron jobs fail due to the agent running outdated gateway code. This update makes it easier to identify and fix such issues with a simple restart command.

Hermes Agent on macOS will now correctly remember your screen recording and accessibility permissions between updates. This is because the program now uses a properly signed helper application, preventing it from losing these permissions every time it's rebuilt.

The agent's ability to interact with your computer is now more honest about its background operations and significantly more efficient. This means it uses less processing power for each action it takes, making it faster and more responsive.

Renaming a bot's primary conversation is now prevented to avoid losing its entire history. This change ensures that a bot's core chat remains uniquely identifiable and preserves all past interactions.

Session ownership is now reliably kept across different connections, ensuring your chat data stays connected to the correct user even if you switch between gateways. This makes sure that your session data is more stable and predictable.

Code formatting has been automatically cleaned up to improve readability and consistency. This helps ensure the project remains well-maintained and easier for everyone to contribute to.

Commits that were mistakenly attributed to an incorrect email address are now correctly linked to the contributor's actual GitHub identity. This ensures that contributor tracking and reporting tools accurately reflect who made these changes.

macOS permissions on your terminal will no longer reset after security updates. This makes it easier to keep your settings intact and your environment running smoothly.

The "Update now" button and other dashboard actions now work correctly on SSH remote servers, preventing them from crashing. This fix ensures that remote software updates can be performed successfully through the dashboard.

When two people try to start a chat with the same bot at the same time, the program now correctly joins the existing chat instead of creating a duplicate one. This prevents confusing situations where a new, empty chat would be created unnecessarily.

The rollback command now correctly preserves large files that were excluded from checkpoints, preventing accidental data loss. Additionally, the output now accurately reports which files were kept due to their size and acknowledges when a file deletion fails.

Hermes Agent will now correctly detect new releases even if a network issue temporarily prevents it from checking. Previously, a failed check could mistakenly report the agent as up-to-date, hiding important updates for hours.

Connections now reconnect more reliably and instantly appear in your saved list. This stops Hermes from freezing indefinitely or sending excessive error messages, ensuring a smoother experience.

Hermes will now automatically retry sending messages that temporarily failed during a network issue when the connection is restored, rather than requiring a full restart. This ensures that messages are less likely to be lost and are delivered more reliably.

Hermes Agent now automatically reconnects SSH tunnels after your computer wakes from sleep, preventing "Gateway offline" errors. It also ensures that when multiple windows try to connect simultaneously, only one connection is established, avoiding duplicate processes.

The terminal now handles situations where macOS prevents it from accessing its current working directory without crashing. This prevents excessive logging and keeps the terminal running smoothly even when access to a specific folder is blocked.

The Hermes Agent desktop app no longer triggers annoying macOS privacy prompts when scanning your home directory for projects. This means the app will smartly avoid protected media folders by default, ensuring a smoother experience without interrupting you for unnecessary permissions.

Dashboards will now automatically recover and display correctly after a new build is applied, even if they were initially broken. This prevents the need to restart the server when an update occurs, ensuring a more stable user experience.

We've made our code automatically cleaner and more consistent by fixing formatting and linting issues. This ensures our JavaScript code is easier for everyone to read and maintain.

Checkpoint restores now consistently report files that were too large to skip or failed to delete, making it easier to understand what happened during the process. This change ensures you are always informed about all relevant outcomes.

The desktop application can now correctly detect when an SSH connection's underlying environment has been replaced and will no longer try to reuse a broken connection. This prevents unexpected errors and ensures a stable experience when reconnecting.

Restoring a database snapshot or updating the agent will now prevent data corruption by ensuring it doesn't try to replace a database file that is currently in use. This fix prevents situations where an active process could be left working with an outdated or corrupted database.

Rooms with members named in older ways will now correctly show only one bot instead of duplicate ghost bots. This fix ensures that the bot list in group chats is accurate, preventing issues with finding and interacting with bots.

Searches that span many files on macOS will no longer trigger privacy warnings. This makes it easier to find things without interruptions, while still protecting sensitive user data.

macOS users will now be guided to grant full disk access just once, which covers all needed folders and prevents repetitive prompts. This makes setup easier and ensures Hermes can access necessary files reliably, even after updates.

Hermes commands on macOS will now work correctly again by removing a recent change that caused them to crash. This also includes improvements to how Hermes fixes itself if you encounter issues.

The `session_search` tool now uses significantly fewer instructions, making it more efficient. Important guidance that was previously in lengthy descriptions is now delivered directly in tool responses when it's most relevant.

The agent now keeps a smaller, fixed amount of recent conversation history by default, making it more efficient. You can still access the old, larger history mode if needed by explicitly opting into it.

Hermes can now automatically restart server processes that are running remotely, ensuring your remote desktop connections stay active after Hermes itself is updated. This also makes these server processes visible when you check the status of running Hermes services.

Tests for SSH ownership now reliably pass in continuous integration. This resolves an intermittent issue that caused builds to fail due to unintended side effects between different test processes.

The experimental Ox Alpha model has been removed from the lists of available models in the OpenRouter and Nous Portal interfaces. This change cleans up the user interface by removing a model that is no longer actively being previewed.

The stealth/ox-alpha model is now available again in the OpenRouter and Nous Portal catalogs. This change corrects a previous removal that was made before the model was actually no longer needed.

The Ox Alpha model has been removed from the model selection menus in OpenRouter and Nous Portal because the model is no longer available. This update ensures you only see currently active models.

Bot chats that were already open now correctly show new messages without needing to be restarted. This also ensures that switching between different bots displays fresh conversations and that any changes in your workspace are properly reflected.

Attachment removal and code copying icons are now always visible, making it easier to remove attachments and copy code on Windows. This change improves usability by ensuring these important buttons are discoverable at all times.

This update automatically fixes formatting and linting issues in the JavaScript code. This keeps the codebase clean and consistent, making it easier for everyone to work with.

You can now select the GLM-5.3-Flash model when using OpenRouter or the Nous Portal. This makes a newer, faster version of the GLM model available for your AI interactions.

This update improves how Hermes handles multiple connections and corrupted configuration files, making it more stable. It also prevents unnecessary background processes from starting, which helps with performance and reliability.

We've improved how the app handles switching between different AI models by making sure you confirm the change instead of it reverting unexpectedly. We also made bot chats load their history instantly, so you don't see an empty screen while waiting. Finally, a new "fleet rail" now shows all your connected agents in one convenient strip.

The Hermes Agent's update command now correctly identifies and preserves backends that are already in use, preventing accidental shutdowns or incorrect replacements. This ensures that remote connections remain stable and that different installations of Hermes don't interfere with each other.

The "Close All" button now correctly closes all open bot chats, and opening a direct message with a bot will properly close any lingering group chats. This makes managing your bot conversations more intuitive and prevents unexpected tabs from reappearing.

Automated tests were added to evaluate how well the agent searches through conversation history. This change ensures we can consistently measure improvements and identify regressions in this important area.

Slack threads now correctly represent conversations without repeating the original message in every reply. This makes conversations clearer and easier to follow by removing redundant text.

Messages you send in Slack will no longer appear twice in the agent. This was happening because Slack sends messages in two formats, and the agent couldn't always tell they were the same, leading to duplication.

Hermes Agent will now proactively notify the task creator when a review is requested or when a task gets stuck in triage. This ensures that important tasks don't get overlooked and are addressed more quickly.

The core code that handles interacting with AI models is now independent of specific providers like Copilot. This makes the system more flexible and easier to manage by consolidating shared logic and ensuring certain operations only run when they can actually do something useful.

Approval prompts for cron and messaging tasks can now be answered correctly. This fix ensures that questions related to these tasks are properly routed through the session owner, resolving a previous issue where they were unanswerable.

New chat sessions will now correctly connect to the gateway you've selected, instead of defaulting to the primary local connection. This fixes an issue where selecting a different gateway wasn't properly applied for new conversations.

Hermes now gracefully asks running gateways to finish their current work and exit when updating, instead of abruptly stopping them. This prevents interruptions and ensures that files are properly released, making updates smoother and more reliable, especially on Windows.

The way skills are managed has been streamlined to reduce token usage and simplify operations. This makes skill management more efficient by removing an unnecessary "edit" command and hiding internal curator-specific details.

Hermes Agent now correctly handles Slack events when running behind a corporate proxy. Previously, proxy settings were not consistently applied to incoming Slack messages, causing them to fail authorization and be rejected.

Typing in the desktop application is now smoother because the list of recent conversations won't refresh while you're actively typing. This prevents the application from slowing down during typing, making your experience more responsive.

The thinking preview now scrolls properly when it gets too long, preventing it from getting cut off. This means you can see the entire thought even if it's lengthy, without affecting the rest of the conversation display.

The visibility of certain buttons like the "X" and copy icon has been fixed to ensure they appear when you hover over them, even on devices that previously had trouble displaying them. This change makes these important controls more reliable for all users.

This update fixes an issue where certain models could not be saved as the default in settings due to confirmation requirements. It ensures a smoother saving process for these models and handles confirmation more gracefully, especially in headless environments.

This update fixes a type error in our testing setup that was causing all code checks to fail. It ensures that our tests accurately reflect the expected behavior, allowing all future code changes to pass their checks.

Removed outdated JavaScript files from the desktop application. This cleans up the project and makes it more efficient.

Formatting issues in the JavaScript code have been automatically fixed by a new workflow. This helps keep the code clean and consistent without manual intervention.

Hermes Agent on Windows now correctly identifies a successfully restarted gateway instead of reporting it as a failure. This prevents the update process from incorrectly re-stopping a gateway that was just resuming.

The code now automatically fixes common formatting and linting errors when you run the `npm run fix` command, making it easier to keep the project's code clean and consistent. This helps prevent errors and improves the overall quality of the codebase.

We updated a dependency to a newer, more secure version, fixing a potential issue that could cause infinite loops and be flagged by security scans. This update ensures that Hermes Agent uses a safer version of this component.

The setup wizard for memory providers now correctly validates and cleans up any values written to configuration files, preventing potentially harmful commands from being executed. This ensures that all settings are handled safely and consistently, just like other configuration options in Hermes.

When a code reviewer requests changes, the project's kanban board will now be notified and alert the relevant team members. This ensures everyone is immediately aware of blockers and can address them faster.

After updating Hermes, the desktop application will no longer show a blank white screen. Instead, you'll see a helpful error page with reload options if something goes wrong, and the update process itself has been fixed to prevent this issue.

The way Hermes handles situations where SSH connection files are mismatched or corrupted has been improved. This change prevents issues where a faulty file could incorrectly terminate active SSH connections.

This update prevents duplicate answers from appearing in Slack when a link unfurl happens at the same time a message is being processed. This makes conversations with the agent more reliable.

Hermes can now generate videos using FAL's new, top-ranked MiniMax H3 Max model, which produces high-quality clips faster and more affordably. This update allows you to create impressive video content with enhanced speed and quality.

Sessions in different profiles are now correctly distinguished, preventing them from appearing as a single item and ensuring clicks open the intended conversation. This fix resolves an issue where interacting with a session could incorrectly switch to a different profile or become stuck.

Windows gateway restarts are now correctly counted during the update process, preventing them from being mistakenly flagged as unaccounted for and ensuring a more accurate runtime reconciliation. This change improves the reliability of tracking service status after updates.

The way Hermes Agent structures questions has been simplified, making it more efficient and easier to use. Now, even single questions are sent as a list, which reduces the amount of data processed for each interaction.

Hermes Agent will now correctly identify when a process ID has been reused by the operating system, preventing updates from failing unnecessarily due to what appeared to be a stalled gateway. This makes the update process more reliable, especially on systems like Windows where process IDs are recycled quickly.

Automated tools now automatically fix code formatting and style issues, making development smoother and reducing manual effort. This helps ensure the code is consistent and easier for everyone to work with.

Hermes now automatically cleans up temporary files left behind by incomplete updates, preventing them from building up and corrupting your local project files. This cleanup ensures smoother background updates, especially on unstable network connections.

Updates that previously crashed and left gateways stopped will now automatically restart them upon the next update. This prevents a full fleet of gateways from going offline unexpectedly after an interrupted update.

The Hermes Agent now correctly pauses Windows services before updating them, preventing conflicts and ensuring smoother upgrades for machines running as services. This fix addresses a problem where services would restart during updates, causing instability and failed installations.