Highlights of Hermes Agent Panoramic Guide
David的AI全景图 · 2026-04-13 · 30 min
Show full episode description
背景：Hermes Agent 把 Harness Engineering 从“高手手工调教”做成了“开箱即用且会自我进化”的产品化系统。 金句： 限制 AI Agent 表现的瓶颈，往往不是模型本身，而是模型运行的环境配置。 Harness Engineering 的本质，是用一套持续生长的约束系统，让 AI 在可控边界内越来越可靠。 Hermes 最重要的创新，不是又多了几个工具，而是它开始学会“自己给自己造缰绳”。 三层记忆回答的是三个不同问题：刚刚发生了什么、你是谁、这件事该怎么做。 自主 Agent 的真正挑战从来不是让它跑得更快，而是让它在没人盯着的时候，依然朝着正确方向前进。 来源链接： GitHub - NousResearch/hermes-agent: The agent that grows with you
✨ Episode Outline — click any point to jump to it in the episode
Problem solved
Hermes Agent automates Harness Engineering's reins so individuals can run self-improving AI agents.
Benefits
- Five harness components built-in and automated out of the box
- Three-layer memory with on-demand SQLite FTS5 retrieval
- Self-improving learning loop refines skills from feedback
- 24/7 autonomous background execution via Telegram or Discord
- Cross-platform Agent Skills interoperable with Cloud Code and OpenClaw
Use cases
- GitHub gained more than 27,000 stars in just two months
- Lanchen tuned GBT 5.2 KODX config, score 52.8% to 66.5%, rank top 30 to top 5
- Run 24/7 personal agent on a $5/month VPS like Hetzner CX22 (~$4/month)
- ClawHub offers more than 44,000 community-contributed Skills
- Local 8B or 70B Ollama models on a VPS for zero API cost
KPIs / results
- 27,000+ GitHub stars in two months
- GBT 5.2 KODX: 52.8% to 66.5%, top 30 to top 5
- 40+ built-in tools, MCP connects 6,000+ apps
- Memory usage under 500MB without local LLM
🌐 This transcript was automatically translated to English from the original.
What we are going to discuss today is a very special open source project, Hermes Agent. This is not another AI Agent tool on the market, but an important conceptual innovation. In February 2026, News Research released this project. In just two months, GitHub received more than 27,000 stars. This growth rate is quite amazing. More importantly, it represents the first productization attempt of this Harness Engineering methodology. It is indeed worthy of attention. We know that after the lobster craze caused by OpenClaw, many people may be interested in the new project. Agent tools are tired, but Hermes is taking a completely different path. Its core innovation is to build-in the reins system that originally required manual configuration and maintenance, and realize automated operation. The reins mentioned here refer to the core concept of Harness Engineering. Through carefully designed constraints and rules, AI can work better in a controlled environment. Let me first explain the background of Harness Engineering. In early 2026, an important discovery occurred in the field of AI programming. The bottleneck limiting AI performance is not the model itself. It is the environment configuration in which the model runs. The Lanchen team used a very convincing experiment. They used the same model GBT 5.2 KODX. Just adjusting the surrounding configuration parameters improved the score from 52.8% to 66.5%, and the ranking jumped from the top 30 to the top 5. The most critical revelation of this experiment is that the model code has not changed a single line. What has changed is its working environment. Mitchell Hashimoto, the creator of Terraform, named this method Harness Engineering. Its practice is simple but very effective. Every time the AI makes a mistake, a rule is added to the configuration file to ensure that it does not make the same mistake again. This configuration file will continue to grow and gradually evolve into detailed project specifications. Harness Engineering can be decomposed into five core components: system prompts, toolset, memory system, feedback loop and workflow orchestration. These five components work together to form a complete constraint system. The breakthrough of Miss Agent is that it builds and automates all five components. Traditional Harness Engineering requires developers Manually write configuration files, manually set hook functions, manually build memory systems, and manually design workflows. This requires users to have considerable engineering experience. Hermes provides a complete solution out of the box. The pre-configured prompt word system corresponds to the system prompt word components. More than 40 built-in tools plus MCP integration correspond to tool set components. The three-layer memory architecture corresponds to the memory system components. The learning loop mechanism corresponds to the feedback loop component. Self-agent pseudo-party response workflow orchestration component. This comparison clearly demonstrates the value proposition of Hermes. It is not intended to replace Cloud Code or Open Claw is about solving problems at different levels. Cloud Code focuses on interactive coding. You need to sit in front of the terminal to collaborate with it. It is like your team programming partner. Open Claw adopts the concept of configuration and behavior. It defines the personality and capabilities of the Agent by writing Seal MD files. It has a mature community ecosystem. There are more than 44,000 community-contributed Skills on Claw Hub. Hermes is positioned as autonomous background execution and self-improvement. It can run online 24 hours a day and respond at any time through Telegram or Discord. You don’t need to stay by your side all the time. What’s particularly worth mentioning is that these three tools all use Agent Skills. There are single standards, which means that Skills can be interoperated across platforms. Skills you write for Cloud Code can be used directly in Hermes, and the reverse is also true. They are not competitive, but more like different roles in the same ecosystem that work together to form a complete AI Agent tool chain. The adoption of this open standard is a very positive signal for the entire open source AI community. Let’s take a look at the core architecture of Hermes. The entire system can be connected in series with a process line. The learning cycle is the heart, responsible for continuous self-improvement. The three-layer memory is the brain, which stores different types of information. The Skill system is the skill library, which records the execution methods of various tasks. More than 40 built-in tools are hands and feet, providing actual execution capabilities. The multi-platform gateway is the entrance, supporting more than 12 intervention methods. These five modules perform their own duties and work closely together to form a complete autonomous learning system. The learning cycle is the core innovation mechanism of Hermes. After each task is completed, It will automatically review and analyze what information is worth remembering, which experiences can be refined into Skills, and whether the existing Skills need to be optimized. This process is completely automated and does not require manual triggering by the user. The three-layer memory structure has a clear division of labor. The drawing memory is responsible for recording what just happened. The persistent memory is responsible for recording who you are. What are your preferences? The Skill memory is responsible for recording how to do things. All data is stored using Skill Lite plus FTS5 full-text index. It supports precise on-demand retrieval rather than full loading. The design of the Skill system is also unique. Each Skill is a Markdown file in the Skill directory. It has three sources: Bundle Skills that come with the warehouse, installed from the Community Hub, and created by Agents themselves. The most critical feature is that Skills are not static. It will improve itself based on feedback during use. More than 40 built-in tools cover five major categories. Execution tools can run code and manipulate files. Information tools provide search and web crawling capabilities. Media tools process pictures and videos. Memory tools manage storage systems. Truncation tools can delegate tasks to sub-agents. Integrated through MCP, it can also connect to more than 6,000 external applications. From the perspective of deployment costs, Harmis is very user-friendly. The software itself is completely free. It adopts the MIT opening agreement. You only need to pay the LLMAPI calling fee. The most economical deployment solution is to use a VPS server that costs $5 per month, such as Hazner CX22, which costs about $4 per month. Digital Ocean and Vilter also have similar price options. Run the pre-layout 22.04 system. If you do not run a large language model locally, the memory usage is less than 500MB. Use an economical API such as Cloud Type or Deepthick with OpenRouter. The overall cost is very low. If you pursue lower costs, you can also adopt a Serverless solution and use Daytona or Model as the backend. The environment sleeps when idle and wakes up automatically when a message is received. The cost between paintings is almost zero. If you pay special attention to privacy protection, you can run Allama on a VPS. The open source model with 8 billion or 70 billion parameters can be run locally. The API cost is completely zero, but a larger server configuration is required. It is recommended to have at least 16 bytes of memory. No matter which plan you choose, a 5 US dollar VPS plus Telegram Bot can build a 24/7 online personal AI Agent. This price/performance ratio is far better than the subscription-based commercial solution. News Research of the development of Hermes It is not a large technology company, but an open source AI research laboratory. The core figure Technium leads the model fine-tuning and data set planning. The team size has always been small. In the early days, it relied on Redmond AI to provide computing power support. However, the Hermes model family they developed has ranged from 8 billion parameters to the fourth-generation 14.07 billion and 405 billion parameter versions. It has reached cutting-edge evaluation only through post-training. There is no need for pre-training from scratch or a huge computing power budget. This concept has been completely continued in the design of Hermes Agent. Using open source tools and any LLM API interface, individual developers can also deploy AI Agents that are comparable to commercial solutions. Their core principles are very clear. User control is given priority. The model must be controllable. Users can adjust their behavior as needed and are not restricted by corporate content policies. They clearly state that they will not do content censorship. The model remains neutral while not compromising on creativity, mathematical ability, coding ability and reasoning performance. These principles determine the design orientation of Hermes Agent. It does not make decisions for the user, but sets the rules for the user. The agent learns the rules and then gradually optimizes the execution. The control is always in the hands of the user, and the complexity of execution is borne by the system. Now let us delve into the learning cycle mechanism of Hermes. This is the core innovation of the entire system. The Agent can create its own reins. This concept sounds very abstract, but it can be well understood through a real scenario. Suppose you ask Hermes to help you write a Python script for the first time. It will generate a usable code, but the style may not be in line with your habits. Variable naming and error handling methods may not be what you like. This is normal because it does not understand you yet. But by the tenth time, the situation is completely different. It already knows that you prefer to use HTTPX instead of Request. It knows that you are used to writing error logs to files instead of printing to the terminal. It knows that your project structure is usually divided into SRC directories by modules. It also knows that you hate transition functions. The key is that no one taught him these preferences. These are all learned by himself. The learning cycle consists of five links. Each link is not complicated when viewed individually, but in series, it forms a flywheel effect of continuous improvement. The first link is planning memory. After each round of dialogue, Hermes will actively decide which information is worth remembering. This is active decision-making rather than passive storage. The traditional conversation memory method is very crude. It is to stuff the entire chat history into the context until it can no longer fit. Hermes's approach is more like a human writing a diary. At the end of each conversation, he will review it, what new discoveries were made during this conversation, what preferences the user expressed, and then write the content worth remembering into the Sequel Lite database and establish an FTS45 full-text index. The system also has a periodic reminder mechanism that regularly allows the Agent to review recent interaction records. The second step is to create skills independently. When Hermes completes a relatively complex task, he will ask himself whether this solution will be used in the future. If the answer is yes, he will refine the solution into a Skill file and store it in the Skills directory. This Skill is a Markdown format file that contains task descriptions, execution steps and precautions. For example, you ask Hermes to help you clean the CSV file and import it into the database. After completion, it may create a skill called CSV2-Database Skill to record the common steps of data cleaning. Your preferred database connection method. Fields you usually need. Validation rules. You'll talk about it next time. You need to import the CSV file. It does not start from scratch, but loads the verified Skill and executes it the way you did before. The third link is Skill self-improvement. This is the most critical differentiating feature. Skill creation is not the end point. During each use, if you give feedback, Hermes will use this feedback to modify the Skill itself. For example, if you say this An import script should first check whether the table exists. Hermes will not just add a check this time. It will go back and modify the Skill file and write this rule. The next time you use this Skill, the check step will be included by default. This process is very similar to continuous improvement in software development. Every time a problem occurs, not only patches will be applied after repairs, but also documents and specifications will be updated to prevent similar problems from happening again. The fourth link is FTS5 cross-painting recall. The key to remembering so much content is to be able to find it out at the right time. Hermes uses Skill Lite FTS5 extension does full-text indexing. Before each new conversation starts, search historical memory based on the current topic. Retrieve relevant content on demand. Load into context. This design of on-demand retrieval is much more important than imagined. Most AI tools either don’t remember what was said last time or stuff all the history into it, which slows things down. Hermes’ approach is that if you ask database-related questions, it will flip through database-related memories. If you ask previous questions, it will flip through previous paragraphs of memory. This is a well-organized note-taking system with a directory and index. What is needed? What to look for? Moreover, FTS5 is purely local memory data. It does not need to be uploaded to any server. It is in the local Skill Lite file. Once signed, it can be directly copied and the data is inserted. The fifth link is coaxing user modeling. This is an optional external integration. What he does is deeper than remembering what you said. It is inferring the characteristics of you. After each conversation, Hongcho will analyze the communication content and deduce your preferences, habits and goals. Hongcho's derivation is not just about recording what you said, but from behavioral patterns. Summarize deeper characteristics. For example, you have never explicitly said that you like a concise coding style, but Hongcho infers this conclusion by analyzing your pattern of multiple code modifications. The concise route will be adopted by default the next time you generate code. This dialectical user modeling covers multiple identity dimensions and can capture the inconsistencies between your words and deeds. Your verbal preferences and the preferences shown by actual behaviors may be different. Dialectical modeling pays attention to both at the same time. This entire mechanism actually automates Metro Hashimoto's philosophy. Metro has a habit of using Cloud Code. Every time the Agent makes a mistake, add a rule to the configuration file. After a few weeks, the configuration file becomes a very detailed project specification. Hermes does essentially the same thing, but automates the process. You don't need to write rule files manually. Now let's look at the specific implementation of the three-layer memory system. Why is memory the most difficult problem? Many people think that the memory of AI is just to save chat records, but in reality it is far from that simple. An active user chats with the AI for thousands of words every day, tens of thousands of words a month, all of them are crammed into the context window, or they cannot be loaded. Either because there is too much information, it makes the model sluggish, and most of the chat records are nonsense and repetition. The truly valuable information may only account for 10%. A good memory system is not to store more, but to find it accurately. The first layer is drawing memory. Answers. What happened. The content of each round of conversation, tool calls and return results are all written to the SQ Lite database. At the same time, FTS5 full-text search index is established. This is episodic memory, similar to the hippocampus in the human brain. The key design decision is to retrieve on-demand rather than full load when a new conversation starts. Hermes will not stuff all the conversation history in the past, but use FTS5 to search for relevant historical fragments based on the current topic and only add the required parts. The advantage of this solution is that it is fast because FTS5 index query is very efficient and low-cost. Only the necessary fragments are loaded, which greatly reduces the token consumption and is completely localized. FTS5 is a full-text search extension of SQL Lite. No additional database is required. All data exists in local SQL Lite files. There is no network dependency. No privacy concerns. Conversation memory will not leave your machine. The second layer is persistent memory. Answer Who are you? What this layer stores is not the content of the conversation, but the persistent state extracted from the conversation, such as coding preferences, project structure habits, commonly used tool chains, and working time patterns. This information is maintained across drawings and will not be lost just because a new conversation is opened. The portability of persistent memory is an underestimated feature. The memory of many AI tools is locked in the cloud. If you change tools, you have to start from scratch. Hammis's memory is your own file. You can move it how you want. You can back up the Data directory to the right disk and continue using it on another computer. When deploying with Docker, mount the Data directory to the host to maintain the state. You can even use disk synchronization between multiple devices. The third layer is Skill memory. How to do things. The first two layers remember what happened. What kind of person you are. The third layer remembers the methodology and operational violations. Each Skill is a Markdown file in the Skills directory. It is readable and editable. These three layers correspond to the three types of memory in cognitive science. Painting memory corresponds to episodic memory. Persistent memory corresponds to residual memory. Skill memory corresponds to procedural memory. The process of riding a bicycle in Anthropology is the collaboration of these three layers of memory. You remember the last time you fell. You know the principle of lowering the center of gravity. The body will automatically maintain balance. The process of Hermes processing tasks is similar. It remembers how you changed the code last time. It knows what your preferences are. It has a set of verified execution plans at hand. In addition to the three layers of local memory, the Honcho user modeling system is an optional plug-in. It was developed by Plastic Labs. What Honcho does is deeper than remembering what you said. It is inferring the characteristics of you as a person. Suppose you continue for three weeks. Let Hermes help you write Python scripts every day. In the process, Honcho may infer your technical level, work rhythm, and communication style. Goal direction and emotional pattern can even capture conflicting preferences. For example, you verbally say you want to write complete comments but never read the comments when actually reviewing the code. These inferences will be injected into the prompt words of subsequent conversations. As an invisible context, you cannot see this information, but you will feel that Honcho understands you better. Compared with Codecode's automatic memory system, the design philosophies of the two are different. Codecode's configuration file is a mode where humans write AI execution. The advantage is that humans have full control, but the disadvantage is that it requires continuous investment and maintenance. Hermes is a mode reviewed by AI self-writers. The advantage is that the threshold is low and the degree of automation is high. The disadvantage is that automatically generated content may not always be accurate. Which one is better depends on the usage scenario. If you are a moderate user and have spent several weeks carefully polishing the configuration file, the hand-programmed reins may be more accurate than the automatically generated one. But if you don’t want to spend time, maintain and configure the fully automatic solution of Hermes. It is really a lot of trouble. The memory system is not omnipotent. You need to clarify what should be remembered and what should not be remembered. What should be remembered includes user preferences and habits, project context, and verified solutions. Recurring patterns should not be remembered, including details of one-time tasks, out-of-date information, wrong inferences, sensitive information such as passwords and keys. Another problem is memory contamination. If Hermes remembers wrong information in early conversations, this error may continue to affect subsequent behavior, so it is necessary to review the memory regularly. Look at the Skills directory to see which Skills have deleted inappropriate ones. Check the persistent memory to correct wrong inferences. It is like organizing a notebook. If you look through it occasionally, you will find a lot of content that needs to be updated. Next, let’s look at the self-evolution ability of the Skill system in Hermes. Each Skill is an independent Markdown file that is stored in the Skill directory. It records how the Agent does something. Procedural memory. For example, if you teach a mental system to make a weekly report, you have to take it step by step for the first time. The second time, he may ask a few questions, and he can solve it by himself. The Skill is the state after the third time. The Agent solidifies the method into a reusable document. Skills come from three sources: the Bundle Skills that come with the warehouse, community contributions installed from the Skill Hub, and those created independently by the Agent. These three sources are not parallel. Bundle Skills is the starting point. Skill Hub is an accelerator. Agent is created independently. It is the real killer key of Hermes. Hermes' Skill adopts the AgentSkills.io standard. Currently, it is supported by more than 30 tools, including Cloud Code Cursor Copilot Gemini CLI. You think that Skills written by Cloud Code can be used directly in Hermes, and vice versa. This is different from the logic of the App Store. The App Store is a set of ecological developers for each platform and needs to adapt to multiple terminals. AgentSkills.io is more like a USB interface. A Skill can run anywhere if it is bad. For those who are already using Cloud Code, the accumulated Skill assets will not be locked in a certain tool. Switch to Hermes or use two tools at the same time. Skills can be seamlessly migrated. The biggest difference is the Skill self-improvement mechanism. Traditional Skills require manual maintenance. If a certain step is found to be ineffective during actual use, you have to manually change it. Hermes Skills are alive and run in a learning cycle. Automatically optimize based on actual feedback. The specific mechanism is as follows: First execute the Skilligent and follow the recorded steps. Complete the task and then collect feedback. The user's reaction is recorded in the drawing memory. Then the Skilligent is updated. The feedback is analyzed. Automatically modify the relevant steps in the file. Finally, use the new version the next time it is executed. The improved Skill will automatically take effect in subsequent tasks. The effect depends on the ability of the large meta-model and the quality of feedback. But the direction is right. Let the Agent learn from experience instead of waiting for others to maintain it. The key difference with OpenCoreSkill is that OpenCore's CoreHub has more than 44,000 community Skills, far more than Hermes. The advantage of Hermes lies in its adaptability. The same skilled Python developers and Rus developers who write code will evolve into two completely different versions after three weeks of use. It is not a universal template, but tailor-made. Now let’s look at the integration of the tool system and MCP. No matter how smart the Agent is, it can’t do practical things without tools. Hermes has more than 40 built-in tools, from running code to sending messages, covering all MCP, and then extending its reach to more than 6,000 external applications. Tools are divided into five categories by function. The execution category includes code execution and terminal operations. The Information class includes web search and content crawling. The Media class handles images and videos. The Memory class manages storage and retrieval. The Coordination class is responsible for delegating from the Agent. Several of these tools deserve special mention. Session Search is a relatively unique capability. It uses FTS5 full-text index to search historical conversations and cooperates with large language model summarization to allow the Agent to quickly recall the solution discussed last week. Most agents do not have this ability. Every conversation starts from scratch. Now we need to discuss the research limitations of Hermes Agents. Although this framework demonstrates impressive self-improvement capabilities, any technical solutions All have their boundaries. First, there is the problem of hollowing out of Skill's self-improvement. From a technical perspective, Hermes's constraint mechanism exists. Skill files are in readable Markdown format. The memory data is based on the local Skillite tool. With permissions, there are kill box restrictions. You can see what the Agent has changed, you can roll back, you can delete. But technical control does not mean actual control. The real problem lies on the human side. It is not the attraction of Hermes. It is that you don’t have to worry about him. But if you have to check the words and rush the results every day, what is the difference between that and manual maintenance of the skill? This contradiction is fundamental. The value of conscious Agent is that you don’t have to watch, but security requires you to watch. This touches on a deeper issue, which is where is the ceiling of self-improvement. Hermes' self-improvement cycle relies on a key assumption. It can judge whether its own improvement is good or bad. If you are present to give feedback, the cycle is effective. This is supervised improvement. But if you are not present, the agent can only use its own evaluation criteria. He feels that the reply is faster and more accurate, but fast and accurate are not equal to correct. Some errors require domain knowledge to find. The agent does not know itself. It does not know what Michu Hashimoto can write the reins for the terminal emulator because he understands every technical detail. The self-improvement agent does not have this kind of domain knowledge. He can optimize execution efficiency but cannot judge whether the direction is correct. Self-improvement allows the Agent to run faster and faster in the known direction, but the direction itself still has to be determined by people. Another problem that is easily overlooked is the memory pollution and forgetting mechanism. People will forget. This is not a defect but a feature. Outdated experiences are forgotten so as not to interfere with current judgments. But the Agent's memory only increases. The pattern learned three months ago may be outdated. If Hermes remembers wrong information in early conversations, this error may continue to affect subsequent behavior. There is currently no automatic forgetting mechanism, and users are required to regularly review the Skills directory and persistent memory. Delete inappropriate content. This is back to the paradox. Autonomous systems that require manual intervention. From the perspective of application scenarios, Hames is most suitable for long-term projects and background tasks, continuous content creation, code warehouse monitoring, and regular investigation of these scenarios. It can give full play to its advantages of memory accumulation and autonomous operation. However, in scenarios where interaction and timely feedback are required, the experience of Cloud Code may be better. In enterprise environments that require strict compliance and predictable behavior, OpenCloud's Sool single transparent configuration method may be more suitable. This leads to an important extended discussion. These three tools are not competitive, but complementary. They represent the three interaction modes of AI agents. Cloud Code is an interactive coding tool. The core value is to implement collaboration. OpenCloud is a configuration and behavior framework. The core value is predictability and auditability. Hermes is an autonomous backend engine. The core value is autonomy and self-improvement. The real value is not to choose which one, but to understand how to use it in combination. For example, use Hermes to handle things that do not require presence. As a night shift team, use Cloud Code to handle work that requires presence. As a day team, the emergence of Agent Skills' own standards is of great significance from a cross-domain perspective. More than 30 tools currently support this standard, which means that the Skill you write for Cloud Code can be used by Hermes. The opposite is also true. Skill is no longer bound to a specific tool and has become a portable unit of ability. This means that no matter which horse you choose, the saddle is universal. The time you invest in Skill will not be wasted by changing tools. The accumulated Skill library is your own asset, not an accessory of a certain platform. If OpenCrow's more than 44,000 community skills can pass this standard, they will be called by Hermes. The boundaries of capabilities will expand instantly. This ecological interoperability may have a longer-term impact than any single tool itself. It is redefining the ownership and portability of AI capabilities. From the future research direction, there are several issues worthy of continued attention. The first is the evolution of the audit mechanism. NOS Research has chosen the route of giving priority to open source and user control. The MIT license gives the right to audit, but there is no guarantee that users will exercise this right. It is necessary to explore more lightweight audit tools so that non-technical users can understand the self-improvement trajectory of the agent. The second is the quality of feedback signals and the self-improvement effect. Highly dependent on the accuracy and timeliness of feedback. How to ensure the quality of feedback while reducing manual intervention. This is a core contradiction that needs to be solved. The third is the intelligence of memory management. The current memory system is only increasing. In the future, it may be necessary to introduce automatic forgetting, memory prioritization, outdated information identification and other mechanisms. Finally, a simple summary. The core innovation of Hermes Agent is to productize the Harness Engineering methodology and realize a design where the reins are shipped from the factory and the reins will grow on their own through a five-link learning cycle. The self-improvement Skill mechanism of the three-layer memory system shows the possibility of the evolution of AI Agents from tools to partners, but it also exposes the fundamental challenges of autonomous systems. How to find a balance between autonomy and controllability. For developers and enthusiasts who want to build long-term companion AI assistants, Hermes provides a low-cost, highly customizable, data localization solution. With a five-dollar monthly VPS and an open source framework, you can have a 24-hour online personal Agent that will understand you better the more you use it. But users need to understand. This is not an out-of-the-box solution, but a symbiotic system that requires regular review and adjustment. Thank you for listening to this podcast. We have an in-depth discussion of Hermes Agent, an open source framework that implements the concept of Harness Engineering. From learning loops to memory systems, from Skill self-evolution to multi-Agent orchestration, we also honestly discuss the boundaries and limitations of self-improving Agents. The field of AI Agents is evolving rapidly. The interoperability and collaboration between tools may be more meaningful than the power of a single tool. If you are interested in this topic, you can Pay attention to the development of agentskills.io standards. Pay attention to open source and closed source solutions. Different explorations in nullability. I hope this content can help you better understand the opportunities and challenges of self-improving agents. Find your own AI collaboration method in practice. See you in the next issue. Goodbye