Hands-On With Hermes Agent's Eight Major Updates: A Complete Guide to AI Automation and Self-Evolution

AI Agents: From Conversation to Autonomous Action

The concept of the AI Agent originated in AI research years ago, but only entered practical use after the rise of large language models (LLMs). Traditional chatbots can only passively respond to single or multi-turn conversations, whereas the core distinction of an Agent lies in its "plan-execute-feedback" closed-loop capability: it can break down a complex goal into multiple subtasks, invoke external tools (such as a browser, file system, or APIs), and dynamically adjust its strategy based on execution results.

Key technologies driving this evolution include the ReAct (Reasoning + Acting) framework, Function Calling, and Tool Use capabilities. To understand the breakthrough significance of ReAct, we first need to understand its predecessor—the Chain-of-Thought (CoT) prompting technique. CoT was formally introduced by the Google Brain team in 2022 in the paper Chain-of-Thought Prompting Elicits Reasoning in Large Language Models. The core finding was that when a model is guided to output intermediate reasoning steps one by one, accuracy on complex mathematical and logical tasks improves significantly. The inspiration for CoT can be traced back to earlier "scratchpad" research—letting the model generate "draft-paper-style" intermediate steps before producing the final answer, essentially simulating how humans work through problems step by step. However, the fundamental limitation of CoT is that the reasoning chain takes place entirely within the model's "imagination space," unable to access the latest information or verify external facts. This makes it prone to "hallucination"—where the model generates content that contradicts reality with a highly confident tone—which is especially fatal in scenarios requiring real-time data or precise calculations.

ReAct was proposed by a Google research team in 2022 (in the paper ReAct: Synergizing Reasoning and Acting in Language Models). Its core idea is to interweave the language model's "reasoning" (generating a chain of thought) with its "acting" (invoking external tools), forming an iterative loop of "think → act → observe → think again." The key difference from CoT is that ReAct injects the results of external operations—such as search engine queries and calculator calls—into the reasoning chain as real "observations," thereby grounding the model's reasoning in verifiable, real-world feedback and fundamentally overcoming the information "hallucination" problem of pure reasoning mode. Notably, the ReAct framework conceptually echoes the "action-reward" loop in reinforcement learning: the returned results of external tools play the role of immediate feedback signals, guiding the model to correct its direction in the next reasoning step—except here the "correction" happens at the context level rather than the weight level. These technologies mean the model is no longer limited to generating text, but can truly interact with the external world.

AI Agents are moving from being able to "converse" into a new stage of being able to "autonomously get work done." Recently, the Hermes Agent received a version its author calls its "biggest update ever," delivering eight major feature upgrades all at once. Based on a hands-on demo by a Bilibili content creator, this article breaks down the core changes of this update and analyzes what they mean for personal automation workflows.

Mobile Access: Native iMessage Support

The most immediately noticeable change in this update is that the Hermes Agent now natively supports iMessage. Users can chat with their agent directly through the Messages app on iPhone, without needing to open a dedicated app.

According to the creator's demo, while out and about he sent the message "tell me Micron's stock price and the reasons for today's volatility," and the agent completed the query and replied directly within iMessage, with full rich-media support. More importantly, this mobile entry point connects directly to desktop Hermes—meaning a single command from your phone can open a browser on your computer, move files, or even deploy a model locally.

On the technical side, all of this runs through a free service called Photon. Understanding the architecture here first requires understanding iMessage's own security design: iMessage is built on Apple's APNS (Apple Push Notification Service)—the push infrastructure Apple launched in 2009, which covers billions of devices worldwide. APNS uses a persistent, long-lived TCP channel, allowing servers to proactively push messages to devices without requiring frequent polling. This design dramatically reduces power consumption on mobile devices and has become an architectural model for modern mobile push. On top of this, iMessage layers a complete end-to-end encryption (E2EE) system: the sender's device first obtains the recipient's public key certificate from Apple's Identity Service (IDS) server, negotiates a session key using the Elliptic Curve Diffie-Hellman (ECDH) protocol, then encrypts the message body in AES-128-CTR mode, while the message signature uses the ECDSA algorithm to prevent tampering. The entire encryption process is completed locally on the device; Apple's servers are only responsible for storing and forwarding ciphertext, and in theory Apple itself cannot read the content. ECDH is widely adopted for mobile communication encryption because, compared to traditional RSA, it can achieve equivalent security with much shorter key lengths (256 bits provides the same security strength as RSA's 3072 bits), significantly reducing the computational overhead on mobile devices.

However, precisely because of the closed nature of this encryption architecture, third-party services wanting to access the iMessage ecosystem typically rely on a "virtual number" approach: registering a real phone number capable of sending and receiving SMS, then bridging via an SMS gateway to custom backend logic. Photon plays exactly this middle-layer role, handling number allocation and bidirectional message routing. It's especially important to note that this bridging approach means messages must pass through a third-party server in plaintext before reaching Apple's ecosystem, breaking the native iMessage security chain. The essence of this security risk is a "shift of the trust boundary"—users originally only needed to trust Apple, but now must also trust Photon's data-handling policies and server security. Users should carefully weigh this when transmitting sensitive content such as account passwords or financial information. The advantage of this design is a zero app-installation barrier, but the privacy boundary is a cost users must be clearly aware of.

The author also offers practical usage recommendations: use iMessage to fire off quick commands while out on the go, use the desktop app when sitting at your computer, and use Telegram (thanks to its topic-grouping support) for complex, in-depth tasks involving multiple threads.

Background Agents and the Sub-Agent Tree: Goodbye to Long-Task Blocking

The second update solves a major pain point in using AI Agents: long-task blocking.

Previously in Hermes, background agents had to be manually toggled on. A background agent refers to having the main agent create "sub-agents" that execute tasks in the background, so they don't occupy the main conversation channel. Previously, assigning a long task often meant waiting hours before being able to continue interacting.

Now, background agents trigger automatically—as long as the prompt is sufficiently complex, the system will spawn sub-agents on its own. The author demonstrated a task of "writing a complex research report on several AI companies already invested in," upon which the system launched 5 sub-agents running in parallel across 28 tool calls.

Sub-agent architecture is essentially the practical application of a Multi-Agent System (MAS) within a personal tool. MAS is a core research area of distributed artificial intelligence, with theoretical roots tracing back to the pioneering work of Victor Lesser and others on the Blackboard System in the 1980s—the blackboard system used a shared "blackboard" data structure as the communication medium among multiple expert modules, with each module asynchronously reading and writing intermediate results on the blackboard. This idea directly influenced later MAS coordination theory. MAS has long focused on three core problems: Coordination, Communication, and Negotiation. In modern LLM Agent implementations, this theory maps to the "Orchestrator-Worker" pattern: the main agent is responsible for task decomposition, prioritization, and result aggregation, while worker agents focus on executing atomic subtasks. The engineering challenges of parallel execution are mainly twofold: first, context isolation—each sub-agent needs an independent token budget to prevent information interference; second, tool contention—when multiple sub-agents access the same resource (such as the file system) simultaneously, lock mechanisms or queue management are needed to prevent data races—which is essentially the same class of concurrency-control challenge as the classic "Readers-Writers Problem" in operating systems. This aligns with OpenAI's Swarm framework, Anthropic's Claude multi-agent approach, and Microsoft's AutoGen philosophy; the difference is that Hermes packages it into a consumer-grade product and provides a visual "sub-agent tree" so that ordinary users can also monitor execution status.

Accompanying this feature is a brand-new sub-agent tree visualization interface. Users can drill in to see in real time what each sub-agent is doing and which commands it has invoked. Even better, while sub-agents are working, users can continue chatting with the main agent—for example, adding on the fly "also add Nvidia to the research list," and the system will spawn another sub-agent to handle it. This "chat-while-working" parallel experience is a key step toward making Agents practically usable.

MCP Ecosystem Expansion: From Unreal Engine to Desktop Experience Upgrades

The third update is quite imaginative: MCP support for Unreal Engine 5.8.

To understand the significance of this update, we first need to understand the technical specification and strategic value of MCP (Model Context Protocol). MCP was open-sourced by Anthropic in November 2024, with the design goal of solving the "M×N problem" of AI tool integration: previously, connecting each AI model to each external tool required custom integration code, so M models and N tools required M×N adapters—extremely costly to develop and severely fragmenting the ecosystem. This predicament closely resembles the Web Service integration space of the early 2000s—when the SOAP protocol attempted to solve heterogeneous system interoperability through complex WSDL description files, but its extreme complexity ultimately gave rise to the lighter-weight REST specification that replaced it. In a sense, MCP is playing the historical role of "REST-ifying" the AI tool integration space.

At the technical level, MCP is built on the JSON-RPC 2.0 specification—a lightweight remote procedure call protocol widely used in developer tool ecosystems such as the Language Server Protocol (LSP). The design philosophy of JSON-RPC 2.0 is "minimalism": it defines only three message types—Request, Response, and Notification—and binds to no transport layer protocol, allowing it to run over HTTP as well as communicate via Unix Socket or stdio pipes. MCP defines three core primitives: Resources (structured data such as file contents or database records), Tools (executable actions such as sending emails or querying APIs), and Prompts (reusable prompt templates). An MCP Server declares its own capabilities through a standardized schema, and all compatible AI clients (such as Hermes) act as MCP Clients, discovering and invoking these capabilities according to the protocol, with the entire interaction remaining agnostic to the underlying transport layer (stdio, HTTP/SSE, etc.). This plays a standardization role similar to the REST API specification in the Web domain or the USB protocol in the hardware domain—Anthropic chose to fully open the specification in exchange for broad adoption by the developer community, a strategy strikingly similar to Google's opening of the Android ecosystem back in the day. As of 2025, hundreds of mainstream services such as GitHub, Slack, Figma, and Stripe have released official MCP Servers, and MCP is becoming the de facto industry standard for AI tool integration.

Unreal Engine, one of the most popular game engines, opening up to AI via MCP for the first time means users can directly use the Hermes Agent to build complex 3D games—creating levels, placing assets, and adjusting lighting through natural language commands, everything from FPS to third-person shooters. Unreal Engine itself has a mature Blueprint visual scripting system and Python automation APIs, and the MCP integration effectively layers a natural-language interface on top of these existing interfaces, transforming engine operations that once required professional developers into conversational commands usable by ordinary people. Compared to making browser mini-games with 3JS in the past, integrating Unreal enables more professional, Steam-publishable works, and the entire process "doesn't cost a penny." This also demonstrates how the MCP protocol is expanding the capability boundaries of AI Agents from pure software operations into the domain of professional creative tools.

The fourth update covers several experience optimizations for the desktop application:

• Multi-window support: Right-click any chat to open it in a standalone window, achieving for the first time the ability to run multiple Hermes agents side by side simultaneously;
• Model selector: A quick switching entry has been added at the bottom, eliminating the need to type slash commands or dig through config files, and it also allows selecting the thinking level;
• Built-in terminal: Open a terminal directly within Hermes to run commands, without switching to an external terminal app.

Profiles, Skill Hub, and Self-Evolution

The fifth and sixth updates center around the Dashboard. Entering Hermes Dashboard in the terminal opens a web-based management interface.

The highlight here is the brand-new Profile builder. Profiles are used to quickly launch multiple agents with different roles—the author himself configured a default Hermes, a GPT-MES for programming, a Librarian for managing memory, and several other profiles. In the past, setting up a profile required manually editing config files; now it can be done easily through a guided flow. Architecturally, profiles are similar to user account switching in an operating system or the "profile" feature in browsers—each profile has its own system prompt, tool permission set, and isolated memory space, enabling the same underlying model to exhibit vastly different behavioral characteristics and depths of expertise.

The sixth is the Skill Hub. An agent's "Skill" in the Hermes system is stored as a Markdown file, essentially a collection of structured prompt templates and tool-invocation instructions, similar to plugins or scripts in traditional software. The Skill Hub's community-sharing model borrows the ecosystem logic of the VS Code plugin marketplace or the npm package manager, allowing users to publish and reuse others' automation capabilities. It's worth noting that using plain-text Markdown as the skill carrier is a deliberate design choice: compared to compiled binary plugins, the Markdown format allows ordinary users to read, review, and even manually modify skill content without any programming knowledge, which to some extent lowers the security risk of malicious code injection—but it also means the existence of a Prompt Injection attack surface, where a malicious skill file could deceive the agent into performing unintended actions through carefully crafted instructions. Users can not only view installed skills but also browse hundreds or thousands of community skills and check details for security review. The author shared a practice worth emulating: rather than downloading a skill directly, obtain the skill's MD file and let the agent "create a safe, customized version itself," specifically tailored to your own use case.

The seventh best embodies the Agent's evolutionary capability: smarter memory and self-editing of skills. Hermes now more frequently and autonomously creates, finds, and updates skills, forming a continuous self-improvement loop.

The technical core of this "self-evolution" mechanism lies in in-context optimization, and its capability-accumulation pattern bears a deep analogy to "procedural memory" in cognitive science. Traditional machine learning achieves learning by updating model weights through gradient descent, which is costly and requires large amounts of data. In-context optimization, by contrast, doesn't touch the underlying weights but writes "experience" as structured text into prompt templates, tool-invocation instructions, or memory files, injecting them into the model as context on the next call to alter its behavioral output. From an information-theory perspective, in-context optimization essentially leverages an LLM's powerful "In-Context Learning (ICL)" ability—large models have already learned during pre-training how to generalize patterns from a few examples, and persistently stored skill files provide exactly such "few-shot examples" to the model at the start of each session, guiding it to reproduce past successful behavioral strategies. This is highly similar to how procedural memory in cognitive psychology (the skill knowledge of "how to ride a bicycle") operates—experience is gradually internalized through repeated practice into automatically retrievable capability patterns. By storing skills as persistent Markdown files, Hermes allows optimization results to be retained across sessions, forming a long-term capability accumulation akin to "procedural memory"—when an agent uses a skill and encounters errors or poor results, it writes the failure case into memory and proactively revises the skill file in subsequent conversations. This approach iterates extremely quickly (taking effect within a single conversation), at near-zero cost, at the price of depending on the reliability of the external storage system and continuous consumption of the context window length.

The author cites the Unreal Engine MCP skill as an example—it was somewhat clumsy at first, but after a few conversations the agent continuously patched and optimized its own skill, ultimately becoming quite proficient with the tool. This self-evolution mechanism means users only need to issue more commands and assign more tasks, and the system will automatically hone its capabilities through use.

Telegram Rich-Text Formatting

The eighth update corresponds to full integration with the Telegram platform. The agent can now output rich formatting such as tables, lists, and bold text in Telegram. In the author's demo, the agent generated a complete stock table containing fields such as descriptions, stock prices, and market caps, with clean, clear layout and smoother text scrolling. The underlying technology of this improvement relies on Telegram's Bot API and its own two rich-text rendering specifications, MarkdownV2 and HTML—Telegram's rich-text support is a relatively open system among instant messaging apps, allowing developers to precisely control message layout styling through the official Bot API. This is also an important reason why it is more suitable than iMessage or WhatsApp as an Agent output carrier. This improvement means data returned by the Agent no longer comes as hard-to-read plain text, significantly boosting usability.

Conclusion: AI Agents Move Toward "Parallelizable and Self-Evolving"

Looking at these eight updates as a whole, several main threads of current AI Agent product evolution become clear: multiple access points (iMessage/Telegram/desktop) lower the barrier to use, background and sub-agent parallelism breaks through long-task blocking, MCP ecosystem expansion lets Agents reach professional tools, and the Skill Hub + self-evolution builds a continuously strengthening capability loop.

From a more macro perspective, these evolutionary directions reflect a technical consensus across the entire AI Agent industry: ReAct-style reasoning-action loops are becoming standard, the MCP protocol is unifying the fragmented ecosystem of tool integration, and in-context optimization provides a low-cost path to continuous evolution without retraining. Notably, these three technical routes differ significantly in maturity: the ReAct framework has ample academic validation, the MCP protocol is in the early standardization stage of rapid expansion, and the long-term reliability of in-context optimization—especially the context-pollution problem caused by skill-file bloat in complex tasks—still awaits validation through engineering practice. The value of Hermes lies in packaging these enterprise-grade concepts into a consumer product that ordinary users can pick up, though users still need to exercise sufficient independent judgment regarding privacy boundaries (such as iMessage's third-party relay) and skill security review.

It should be noted that this article is based on a single creator's hands-on demo, which carries a certain promotional flavor (such as the repeated community recommendations). Readers should still validate feature performance against their own scenarios in actual use, and above all, be sure to conduct security checks when installing third-party skills. For users interested in personal AI automation workflows, this update offers plenty of new paradigms worth trying.

Key Takeaways

Key Takeaways

Key Takeaways