Changelog

Fixed several issues where the code was trying to use names that weren't properly imported, which could have caused errors. This update also resolves circular import issues that were preventing certain code from being correctly understood.

The system now correctly calculates the cost of images in requests based on their actual learned cost, not just their size. This prevents a single screenshot from causing overly long processing timeouts.

The way Hermes handles longer conversations has been improved for the gpt-6 Astra model when using the ChatGPT Codex connection. This means conversations can now be much longer before they start getting shortened, making them more useful for complex tasks.

This update fixes an issue where Hermes could freeze when a plugin failed to start, preventing future plugins from running. Now, if a plugin fails to start, Hermes will correctly release its resources and allow subsequent plugins to be processed.

The Hermes desktop app can now display task details even if the connected backend is an older version that doesn't support attachments. This prevents the app from crashing and ensures you can still see important information like comments and links.

Previously, if a connection was idle, periodic checks could pile up, delaying responses to new messages. Now, these checks will proactively wake up idle connections, ensuring a more responsive experience. This also fixes a bug where idle connections might not be checked until a new message arrived.

The way you interact with the `/goal` command is now more reliable and consistent across the desktop app, command line, and messaging interfaces. This means drafting a new goal will always work as expected, and viewing your current goal won't accidentally change it.

We fixed a bug where properly formatted tool descriptions would incorrectly stop requests from reaching the main processing system. This ensures requests with valid tool schemas are handled correctly without unexpected errors.

Chat history in named profile desktop conversations will now be correctly saved even if the agent needs to rebuild. This prevents losing your conversation progress when agent settings are updated.

Linux users can now keep their custom desktop shortcuts when automatic management is turned off. This prevents Hermes from overwriting personalized launcher settings and ensures your customizations are preserved.

Hermes now correctly cleans up abandoned desktop sessions without impacting active connections. This ensures that when a desktop session unexpectedly disconnects, its resources are properly released, allowing new sessions to start without interfering with existing ones.

Hermes Agent now shows clearer notifications for subagent tasks in the command line and TUI, indicating whether tasks are grouped for review or are independent. This helps users better understand the status and outcome of agent operations.

Tests for concurrent operations have been improved to accurately reflect how the system handles temporary busy signals, ensuring it still counts metrics correctly and produces unique data even when multiple operations briefly conflict. This makes the tests more robust by allowing them to pass when expected contention occurs, without hiding actual problems.

Hermes Agent no longer shows confusing "waiting for provider" messages when it's actually receiving data. This makes the agent more reliable and easier to understand by accurately reflecting the status of data streams.

Pressing Alt + Enter on the numeric keypad now correctly inserts a new line, preventing unintended text from appearing. This makes typing and pasting more reliable in the command line interface.

The chat agents on desktop now correctly run configured shell commands when they start up. This ensures that important setup steps are performed, improving the reliability of these agents.

The `hermes auth list` command now displays unique identifiers and priorities for credentials. This helps users differentiate between multiple credentials that might have the same label, making it easier to manage them.

Silent task runs no longer accidentally overwrite important historical context. This change ensures that the system correctly remembers the state of past operations, even when some tasks are intentionally quiet.

The ability to interact with composer actions on desktop has been improved by making them easier to reach when moving your mouse between elements. This change prevents actions from disappearing too quickly, ensuring a smoother user experience.

Longer task lists now scroll correctly above the composer, ensuring you can see and interact with all your tasks. This fix improves usability by preventing the task list from being cut off.

Hermes Agent will no longer automatically save session data to JSON files after each session. You can still access your session history through SQLite or by explicitly exporting it.

Updates no longer fail unexpectedly when systemd restarts take longer than 15 seconds. This change allows Hermes Agent to correctly handle longer restart times, ensuring that updates are not prematurely marked as failed.

Replies from the assistant that were saved will now stay visible in your chat history, even after closing and reopening the app. This ensures you don't lose important final answers from the assistant.

You can now log in to MCP servers directly from your terminal without needing a web browser. This makes it easier to authorize the Hermes Agent on systems where a browser isn't available.

Hermes Agent now correctly uses context files when describing ordinary roles, meaning it will retain more relevant information. This improves the accuracy of role descriptions and prevents the loss of important details.

Hermes Agent can now correctly load older configurations for allowed items, even if they were saved in a less precise format, preventing them from being lost. This ensures that your previously set restrictions are not accidentally removed.

When you apply skills, Hermes Agent now provides clearer, named notifications about what actually happened. This helps you understand the status of applied operations more precisely.

We fixed an issue where incorrectly formatted boolean settings could break tool definitions. Now, these settings are handled properly, ensuring tools are recognized correctly and preventing unexpected errors.

The bot can now correctly identify when a delivery fails because the target is busy, even if the message explaining the reason is worded differently. This makes the system more reliable in handling delivery issues.

The system will no longer show your inputs twice in the conversation history. This prevents confusion and ensures a cleaner record of your interactions.

The agent can now confirm task completion earlier, even if its tools are about to expire. This prevents tasks from failing just because the agent ran out of tool access before it could report success.

When multiple ways exist to log into Anthropic services, Hermes will now prioritize your own account credentials over shared ones. This change also ensures that if a login attempt fails, Hermes will correctly use the specific credentials that were used for that attempt to refresh your access.

Hermes Agent now correctly uses real credentials when checking its capabilities, ensuring it accurately reports what it can do. This fixes an issue where it might have incorrectly shown it couldn't perform certain tasks.

Tests that check how Hermes handles timeouts and background tasks are now more reliable. This means we can be more confident that the project's timing features are working correctly without unrelated tests failing.

Hermes Agent can now correctly process Brotli-compressed responses that arrive in multiple parts. This prevents errors and ensures data is received completely.

The documentation now clearly explains how to safely recover control of a hosted room, ensuring that the old controller is properly disabled before a new one takes over. This prevents potential data conflicts and ensures a smoother transition of room ownership.

The way Hermes organizes instructions has been improved so that general project information is always loaded before project-specific details. This ensures consistency and prevents local file changes from incorrectly influencing how the agent identifies itself.

This change prevents cron jobs that have already finished from being mistakenly re-run. This ensures that job statuses are correctly maintained even when system cleanup processes are active.

You can now manage individual credentials within a pool without affecting others. This allows for more precise control and recovery of specific accounts, making the system more robust.

Gemini's alternative names now correctly use the native request format, ensuring that thinking configurations are sent properly. This makes Gemini's features more reliable when accessed through these aliases.

Pagination in Hermes Agent now shows the correct error message when there's a problem fetching data, instead of a confusing generic error. This helps users understand and fix issues more easily.

Deferred retries for settled conversations can now publish their results without preventing new messages from being sent. This fix ensures that the conversation's history is correctly reconstructed, allowing new interactions to proceed smoothly.

Older parts of Hermes can now compress data again correctly. This fix ensures that older integrations work smoothly with the latest updates without errors.

Documentation has been updated to clarify that when a background review uses the same model as its parent, it automatically inherits the parent's reasoning effort. This correction helps users understand how reasoning is applied in these specific review scenarios.

Sessions can now reconnect more reliably after being interrupted. This change ensures that a session's connection state is properly reset, allowing it to rejoin without unnecessary delays.

ClawHub skills can now be reliably downloaded and updated even when their names are ambiguous, ensuring the correct owner is always used. This fixes an issue where the owner information could be lost, preventing proper fetching of specific skills.

Skill updates now correctly identify and skip any local installations that are broken or missing. This prevents unnecessary checks and ensures the system prioritizes valid installations.

When cron jobs fail, you'll now see more helpful local error details directly in the tool and in the `/cron list` command, without sensitive information being sent in alerts. This makes it easier to understand and fix problems with scheduled tasks.

Discovery sessions will no longer create unnecessary empty entries in the session history. This change ensures that only meaningful interactions are recorded, keeping your session history clean and organized.

The system now correctly handles ongoing conversations by allowing necessary session information and properly reports errors when messages are sent to unrecognized destinations, preventing them from being incorrectly marked as delivered locally. This ensures better reliability for chat interactions and clearer error feedback for developers.

The system now correctly restores files with unusual names, like those containing spaces or special characters, without accidentally overwriting your edits. This ensures that all your saved work is preserved when the system needs to revert to a previous state.

Desktop-only Hermes agents can now perform important background tasks automatically, even without an active internet connection. This update ensures your agent stays up-to-date and functions reliably by better tracking activity and avoiding unnecessary shutdowns.

When an agent is closed, its background processes now correctly stop without affecting other agents. This prevents orphaned processes and ensures a cleaner shutdown.

Your API keys will now correctly save and load for the specific settings profile you choose, ensuring your credentials are managed more accurately. This change makes managing your API keys more reliable by aligning them with your chosen settings.

Cron incident and notepad data can now be imported correctly after an upgrade, even if the old version of the system is still temporarily loaded. This prevents data import errors and ensures your incident and notepad information is always accessible.

Hermes Agent now correctly sends attachments to Discord channels and threads, and it accurately reports when attachments fail to send instead of pretending they were delivered. This ensures your files and media reach their intended destinations on Discord.

The desktop read-aloud feature now keeps your chosen speech settings on your computer, rather than accidentally changing them for other users of the service. This ensures your personal preferences are respected without affecting shared configurations.

We fixed an issue where private information could be accidentally shared with certain servers when resuming requests. This update ensures that your internal details remain protected and are not leaked during these resumed operations.

This update ensures that if cloud services fail due to billing issues, the agent can still use local backups to function. This is important because it prevents the agent from completely stopping if there are temporary problems with its cloud connection.

Planned restarts of the gateway service will no longer trigger unnecessary failure alerts, ensuring the system correctly distinguishes between planned maintenance and actual errors. This change makes the agent's behavior more robust and less prone to false alarms during scheduled updates.

File synchronization now prevents accidental overwrites of your local work. Previously, if you made changes while files were being uploaded, those changes could be lost. This update ensures your most recent local saves are kept safe during the upload process.

The Hermes Agent now clearly shows which board you're starting with when using the Kanban feature. This helps you immediately see if you've accidentally subscribed to the wrong board.

Completed terminal output from background processes can now be found again even if the original program that launched them stopped. This makes it easier to review the results of tasks that have already finished.

Hermes Agent can now automatically retry sending messages that were temporarily blocked due to high traffic, without needing to be restarted. This ensures messages are eventually delivered even after a platform-imposed delay.

Session search has been significantly sped up by processing results in batches rather than individually. This change reduces the number of database lookups, making searches much faster and more efficient.

Previously, the agent would incorrectly report success even when it couldn't handle video input. Now, it correctly rejects unsupported video, preventing confusion and ensuring accurate results.

Approval buttons for secondary profiles now work even when the system temporarily loses track of your session. This ensures that you can correctly approve or reject requests from these profiles without errors.

Worktree lanes that you hide in the sidebar will now stay hidden without deleting the actual worktree. This fixes a bug where previously hidden worktrees would reappear unexpectedly.

Completed background tasks now show a single notification, even when there are many. This makes progress clearer for users without losing track of individual tasks.

Text written using a shorthand alias now correctly saves to both the agent's local files and any mirrored external storage. This ensures that your written content is always reliably saved and available, even when using shortcuts.

The Hermes Agent now provides clearer error messages when it encounters issues launching services, explaining restrictions without incorrectly assuming how a service is set up. This helps users understand why certain services might not start properly.

When recovering from data corruption, Hermes Agent now correctly tells you where to find your actual backup files. This ensures you can restore your data more reliably, especially if you've customized where your homes or profiles are stored.

Custom routes that you name now work more consistently with how the agent reasons about requests. This ensures that when you specify a custom route, the agent applies the same level of analysis as it does for general requests, leading to more predictable behavior.

Files downloaded from remote sessions now correctly use the original session's location, preventing downloads from the wrong place. This ensures that when you access remote files, you get the exact files you expect from their source.

When a project fails to load, you'll now see a clear "Could not load sessions" message with a Retry option instead of an empty screen. This makes it easier to understand and recover from loading errors.

Fallback requests now correctly use credentials, preventing authentication errors and ensuring more reliable operations. This fix ensures that custom provider fallbacks maintain their authenticated status even after client updates.

Fallback notices now accurately show when you can retry an action after an error, rather than promising recovery that might not happen. This prevents confusing messages and ensures the system correctly handles repeated attempts to avoid overwhelming services.

Kanban tasks now correctly wait for all required checks to pass on the latest code before being marked as complete. This ensures that the agent only considers tasks finished when the underlying code is fully validated.

Hermes now allows you to disable automatic update checks while still being able to manually check for updates. This change provides more control over when Hermes checks for new versions.

The color of session titles in the classic command-line interface now correctly matches your chosen theme. This ensures a more consistent and visually appealing experience when using Hermes.

When you run `sudo` using its full file path or by prefixing it with `env`, the Hermes Agent will now correctly ask for your password. This ensures you can securely authenticate even when using less common ways to start `sudo`.

Reports generated for scheduled tasks and delegations now correctly display their detailed results, making them easier to read. This ensures that important information from these reports isn't lost or obscured after the system processes them.

Scheduled tasks that have already finished will no longer accidentally run again after restoring a saved state. This prevents duplicate work and ensures the system behaves predictably.

Slash command descriptions are now fully visible in a helpful tooltip when you hover over them. This makes it easier to understand what each command does without it being cut off.

This update fixes how Markdown is displayed and copied on desktop, ensuring that extra spaces and line breaks in code and text are preserved, making content look and behave as intended. This makes the experience more reliable for users.

Changes ensure that when you edit tools or if a rebuild fails, the session and its database remain correctly linked. This prevents data loss and ensures your work is not lost due to unexpected errors.

The Hermes Agent now properly cleans up temporary browser files it creates during desktop updates. This prevents unnecessary clutter on your computer after an update is complete.

This update prevents a small window where a newly created scheduled task could accidentally run before it was properly paused. Now, new tasks can be created directly in a paused state, ensuring they are safe from the start.

Model search now better highlights relevant parts of model names, even when using separators like spaces or dots, making it easier to find the models you're looking for without altering how other search features work. This improves consistency and accuracy when searching for models across different parts of the application.

The Kanban system now correctly remembers completed tasks even after re-evaluation, and new tasks will inherit important information from their parent tasks. This ensures that task progress and relationships are preserved more reliably.

Skills sign-in on desktop now uses your computer's local connection for authentication, making it more secure. It also correctly cleans up the sign-in process when you switch or close the skills window.

The Hermes Agent now correctly remembers to restart gateway services that were pending updates, even if no gateway was running at the moment the restart was scheduled. This prevents unexpected disruptions and ensures updates are applied reliably after maintenance.

Hermes Agent will now correctly clear warnings about outstanding update receipts when all required gateway processes are running and up-to-date. This prevents confusion by ensuring warnings are only shown when a real problem exists.

This update ensures that structured reasoning information is correctly processed, preventing crashes and ensuring it appears as expected for chat users. This makes the chat experience more reliable and prevents data loss or corruption.

Startup checks for updates now avoid asking for SSH passwords by default when connecting to internal Git repositories. This improves the speed and reliability of update checks by preventing interactive prompts.

When updates are run in the background, you can now see their progress, helping to ensure they are working correctly. This also means that stalled updates will be more reliably canceled.

Previously, when Hermes Agent needed to redirect a conversation, it lost important information about where the conversation originally came from. This update ensures that all that context is preserved, making the Agent smarter and more reliable in handling complex conversations. This helps maintain a user's privacy by correctly redacting sensitive information while still passing along necessary details for accurate responses.

The "Reconnect gateway" option is now always visible, making it easier to fix connection issues without restarting other parts of the application. This change ensures that only the affected connection is reset, preventing disruptions to other ongoing chats.

Hermes Agent now provides clearer error messages when it can't find essential directories on your system, helping you fix storage issues faster without creating new problems. It also correctly preserves file permissions for important folders, ensuring everything runs smoothly.

Changes ensure that when Hermes starts new processes, they correctly respect the original worker's task assignments. This prevents unintended changes to tasks and keeps operations secure by limiting what new processes can modify.

The system can now correctly recall the specific question being answered, rather than using information from a previous, unrelated question. This improves the accuracy of responses by ensuring the agent is always referencing the most relevant context.

The way the code execution helper instructions are written has been corrected to use the right imports. This fixes an error that prevented these instructions from working correctly, making them more reliable.

The way context usage is displayed has been improved to clearly show whether the information is an estimate or actual provider usage. This helps users understand the accuracy of the displayed token counts.

Tests for the quickstart feature now correctly run the full installation process on Linux machines with GPUs, ensuring the system's acceleration features are properly evaluated. This change fixes a bug where the test would fail due to an incorrect configuration, making our automated checks more reliable.

Core review checks for Kanban boards now run even if an optional component is not installed. This ensures these essential checks are more reliable and don't break when certain features are disabled.

Saved profile credentials will now correctly show as enabled when they are properly configured. This change ensures the messaging status accurately reflects your chosen profile's settings.

Hermes now uses the default settings from its providers instead of separate user-defined limits for output size. This change ensures that Hermes respects the maximum output capabilities of the underlying language models, preventing potential errors or unexpected behavior.

Conversations in the gateway will now remember their history even if you step away or it's a new day, making your interactions smoother. This change prevents your conversation from being reset unless you explicitly ask it to start a new one.

When Hermes Agent forcefully terminates a process, it now correctly stops any child processes that were created by the main process during the termination sequence. This prevents orphaned child processes from continuing to run unexpectedly after their parent has been stopped.

The project's code formatting has been automatically improved to ensure consistency. This makes the code cleaner and easier for everyone to read and maintain.

The agent will now wait 60 seconds of silence before showing a notice about provider activity, up from 30 seconds. This change makes the notices less sensitive and prevents them from appearing too early during normal operation.

Automated code formatting and linting fixes have been applied to the JavaScript code. This ensures our code is consistently styled and easier to maintain.

Tests for the update feature have been improved to run in isolation, preventing them from affecting your actual runtime environment. This change makes testing more reliable and prevents unintended consequences.

Hidden chat drafts will now correctly update without interfering with your cursor's position in the visible chat. This means your typing will stay exactly where you expect it to be.

This update prevents an app from reopening and interfering with a new build being released on Windows. It ensures that the promotion process correctly stops the old app before installing the new one, preventing errors and ensuring a smoother update.

The desktop sidebar now correctly highlights the active session you are viewing, rather than getting stuck on an old selection. This makes it easier to navigate and keep track of what you are working on.

Hermes now remembers where you were reading in a conversation even after you switch between different conversations or restart the app. This means you won't lose your place as easily.

Windows updates now correctly identify and reject incomplete builds before marking them as successful. This prevents users from installing broken software by ensuring essential components are present.

The sign-in process for desktop providers now correctly remembers which account profile you've chosen. This means your settings, like saved credentials and model selections, will stay with the profile you intended, preventing confusion.

Tests for the desktop interface now start faster by preparing their initial components before the main testing time begins. This ensures tests accurately measure functionality rather than setup time.

The system now sends one status update per delegated task call by default, preventing tasks from being mistakenly interrupted while waiting. This makes agent delegation more reliable and efficient by ensuring all results are processed correctly.

This update automatically fixes code formatting issues to keep the project tidy. It improves code quality and makes it easier for developers to contribute by ensuring a consistent style.

Subagents can now transfer running background tasks to their parent agent for better management. If a subagent terminates unexpectedly, any leftover processes it was managing are now clearly reported to the parent instead of being silently discarded.

GPT-6 Astra is now available, but only for users whose accounts have specifically enabled it. This change also allows for a larger context window when using the model.

The task panel in the desktop app now correctly displays your to-do items, and progress from sub-agents will be visible even when certain tool details are hidden. This fixes issues where to-dos were not appearing and sub-agent updates were being accidentally hidden.

Hermes Agent will now be more flexible when dealing with potentially large text inputs. It previously would try to compress text too aggressively, even if it wasn't strictly necessary, which could cause errors. This change ensures it only compresses when truly needed, preventing unnecessary failures and improving reliability.

Explicit deny rules now correctly block commands that attempt to bypass them by using certain shell features or prefixes. This prevents potentially unsafe actions from executing when they have been explicitly forbidden.

This update prevents duplicate messages from being sent after an error occurs during message processing. Previously, the system could mistakenly re-send messages it had already accepted, causing confusion.

Cron jobs and Kanban tasks can now run correctly when the Hermes Agent is started as a system service. This fix ensures that necessary environment variables are passed, allowing these scheduled tasks to execute properly.

When a specific task is set to use a particular provider or model, it will now strictly use that setting and not fall back to the general system settings if it fails mid-run. This change ensures more predictable behavior and clearer error reporting for complex task setups.

Windows users can now run terminal commands reliably in the Hermes Agent TUI. This fix prevents a crash that occurred when the agent first tried to interact with Git Bash on Windows.

Approval buttons in private QQ chats now work correctly by fixing how the agent identifies these chats. This change ensures that when you approve something in a private chat, the action is properly recognized and doesn't time out.

The Hermes Agent now correctly detects when the backend is ready, even if the readiness message is mixed with other log output. This prevents the agent from crashing unnecessarily when the backend starts up properly.

Hermes Agent will now correctly identify standalone hosts, preventing issues where it mistakenly thought it was running inside a container. This fix resolves problems like missing browser tools and hidden update controls by ensuring the agent's environment is accurately detected.

The system now correctly uses the specified context length for your custom AI models, rather than a default value. This ensures that the AI can process longer inputs as intended, improving its ability to handle complex tasks.

Tests for tools can now correctly find real code dependencies. This means we can run more comprehensive tests and ensure that searches work as expected, even with real dependencies present.

Conversations now automatically resume after brief interruptions like heartbeats or when tasks are completed. This prevents lost progress and ensures ongoing dialogues are not prematurely ended.