What You Will Learn

• Implement Hermes memory (memory.md and user.md) to preserve context across sessions
• Design lean memory files and a structured "second brain" for deeper knowledge
• Create, refine, and chain reusable skills; use sub-agents for parallel tasks
• Automate workflows with cron jobs and deploy on a VPS for 24/7 operation
• Manage skill library with the curator and pin essential skills to avoid bloat
• Monitor agent activity with the journey log and use approval mode for control

Study Guide

The Problem With Most AI Agents

You've probably used an AI assistant and felt that initial spark of possibility. Then reality sets in. You ask it to help with a task, it does something decent, you close the window, and the next day you're back to square one. It doesn't remember your business. It doesn't remember the way you like things done. It doesn't remember the project you were working on last week. Every session is a fresh start, and that's exhausting.

Most people interact with AI agents like they're disposable tools. You give them a task, get an output, and then start from nothing the next time. This approach fundamentally limits what these systems can do for you. You're essentially re-teaching the same lessons over and over, wasting tokens and time on repetition instead of building momentum.

The Hermes agent framework was built to solve this problem at its core. It's designed to learn and compound. Through persistent memory files and reusable skills, the agent can recall business context, personal preferences, and established workflows across sessions. This turns a generic AI assistant into a specialized teammate that improves with every single interaction. That's the difference between a tool you use and a collaborator that grows with you.

This course will walk you through the entire architecture. We'll cover the two foundational features,memory and skills,in depth. Then we'll explore the supporting infrastructure: scheduled automation through cron jobs, external knowledge bases, sub-agents for parallel work, and persistent cloud hosting. By the end, you'll know exactly how to transform a basic agent setup into a self-improving system that handles recurring work on autopilot. This isn't theory. This is practical, implementable knowledge that changes how you work with AI.

Why Memory and Skills Change Everything

Let's be honest about the current state of most AI usage. People treat these tools like advanced search engines. They type a prompt, get an answer, and move on. There's no continuity. There's no accumulation of knowledge. There's no improvement over time. The agent stays exactly as capable as it was on day one, which means you're leaving almost all of its potential on the table.

Hermes flips that dynamic completely. The core principle is simple: context plus capability equals performance. Two file types govern this dynamic.

The first is memory. Memory gives the agent context. It knows who you are, what you're working on, and how you like things done. The second is skills. Skills give the agent capability. It knows how to execute repeatable processes without being re-taught every time. When you combine these, something remarkable happens. The agent doesn't just execute tasks. It builds a growing body of knowledge and capability that makes each subsequent interaction more valuable than the last.

Now add scheduled tasks to that mix. Cron jobs let the agent run skills automatically at defined times, without you being present. That's autonomy. That's the agent working in the background while you focus on other things. Memory gives context. Skills give capability. Cron jobs give autonomy. Together, they create a compounding effect that transforms a simple chat tool into a genuine digital worker.

Core Architecture: The Two Memory Files

Let's get into the specifics of how memory works in Hermes. There are two primary files, and understanding the difference between them is critical to using the system effectively.

The first file is memory.md.

This is the agent's personal notebook. It's automatically populated from conversations and sessions. It contains concise facts, decisions, and observations relevant to ongoing projects. For example, if you're working on a client proposal, the agent might note the client's name, the key deliverables, and the deadline. If you mention that you prefer a specific format for reports, that goes into memory. The agent uses this file to maintain continuity across sessions. You can also explicitly request that facts be added to memory if you want to make sure something important is captured.

The second file is user.md.

This is a profile of you. It includes your role, your business context, your preferences, your writing style, and your working methods. If you're a marketing consultant who prefers direct, no-fluff communication, that gets noted. If you have specific things the agent should avoid doing, those go here. This file is also editable. One of the most effective ways to build it is through an automated interview process. You simply ask Hermes to interview you. The agent will ask a series of questions and then build a comprehensive initial user.md file based on your answers. It's a quick and painless way to get started.

There's an important characteristic of these files that you need to understand. They are intentionally size-limited. Why? Because they are read into every session and consume tokens. A bloated memory file makes the agent worse, not better. It's like giving someone a 200-page manual when they just need a sticky note with the key points. Hermes handles this by automatically consolidating and pruning these files when they become full. The agent forces itself to condense the information, keeping only the high-value stuff. This is a built-in quality control mechanism.

You can also enable approval mode. This is a setting that requires the agent to ask for your consent before it updates memory or creates a skill. It's a useful safety feature, especially when you're first getting started and want to maintain full control over what gets saved. Some people prefer to let the agent run freely, but approval mode gives you visibility into what's being recorded.

Memory Files Are Sticky Notes, Not a Journal

This is the single most common mistake I see people make with memory systems. They try to store everything. Every detail, every conversation, every piece of data. The file becomes a monster, and the agent's performance degrades because it's spending tokens just reading the file every session.

Think of these files as sticky notes, not an entire journal. They're meant to hold the essential facts that need to be present in every interaction. The client's name. The project deadline. Your preferred tone. The fact that you hate bullet points in emails. That's the kind of stuff that belongs in memory files.

For larger datasets, you should maintain a structured file system or "second brain" that the agent can reference on demand. This is a crucial distinction. The memory files are for what needs to be always present. The second brain is for what can be retrieved when needed. We'll get into the second brain in detail later, but for now, understand that trying to cram everything into memory.md is a recipe for a slow, confused agent.

There's another layer to memory that people often overlook. Hermes can search your past sessions. If you ask what you worked on two weeks ago, the agent can retrieve the actual conversations. This provides a deeper layer of continuity without filling the core files. It's like having a searchable archive of everything you've ever done, accessible on demand. The memory files are the highlights, and the session history is the full record.

Building a Second Brain: Structured Knowledge Management

For business or personal knowledge that goes beyond what fits in memory files, you need a structured file system. This is what we call a second brain. It's not a separate AI feature. It's simply an external file repository that the agent can be pointed to when it needs deeper information.

Tools like Obsidian work well for this. Obsidian is a markdown-based note tool that serves as a file reader and organizer. You create folders for each domain of your work. Content ideas go in one folder. Client proposals go in another. Standard operating procedures go in a third. Research notes get their own space. The key is to store files in Markdown format because it's easy for the agent to parse and understand.

Once this structure exists, the agent can reference it on demand. You might say, "In the Instagram folder, we worked on this post," and the agent will know exactly where to look. Or you can create skills that already point to the relevant folders, so the agent automatically knows where to find what it needs. This approach scales far better than trying to stuff all knowledge into memory.md. The memory file stays lean and fast, while the full knowledge base remains available for deeper retrieval.

You can also create custom context files to provide additional context for particular sessions or roles. For example, you might have a voice.md file that describes the tone and personality you want the agent to use. Or an agents.md file that defines roles and instructions for different agent personas. Or a soul.md file that captures the overall purpose and ethos of your assistant. These custom files give you modular control over what context the agent loads in different scenarios. You're not limited to the two default memory files. You can build a whole ecosystem of context that the agent draws from as needed.

Skills: Teaching Hermes to Do Things

Memory provides context, but context alone isn't enough. You also need capability. That's where skills come in. A skill is a repeatable process encoded into a reusable format. If you perform a task regularly,creating content, pulling reports, writing proposals, cleaning up files,that process is a good candidate for a skill.

There are multiple ways to create skills. The most direct method is to complete a process in Hermes and then type /learn. The agent will analyze what you just did and save it as a reusable skill. You can also let the agent create skills autonomously based on observed patterns of use. If you keep doing the same thing over and over, the agent might proactively suggest turning it into a skill. And there are community libraries where other users share their skills. You can import these and then customize them to fit your needs.

Hermes also comes preloaded with many default skills. These are built into the system and available immediately. Between default skills, custom skills, and community imports, you'll have a robust library to work with. The key is to treat skills as living processes. They're not static. You should refine them over time based on outcomes. If a skill produces mediocre results, fix it. Add more context. Correct repeated mistakes. Update file paths. The first version of any skill is a V1. Expect to iterate.

Here's a critical caveat that most people learn the hard way: a skill is only as good as the process it encodes. If the underlying workflow is messy, the agent will repeat that mess every single time. Garbage in, garbage out. Before you teach the agent a skill, make sure the process itself is solid. Take the time to think through the steps. Document what works and what doesn't. Then teach the agent a clean, efficient process. This upfront investment pays off massively in the long run.

Chaining Skills and Using Sub-Agents

Individual skills are useful, but they become significantly more powerful when you combine them. This is where the real magic happens.

Skill chaining allows you to run several skills in sequence with a single command. You can bundle multiple skills into one command, so a single word triggers a complete multi-step workflow. For example, you might have a skill for gathering data, another for analyzing it, and a third for formatting the final report. Instead of running each one separately, you chain them together. One trigger. Full workflow. Done.

Sub-agents take this a step further. For larger jobs, you can split the work across a small team of sub-agents working in parallel rather than sequentially. Instead of one agent executing phase one, then phase two, then phase three in a linear fashion, sub-agents can handle multiple phases at the same time. This dramatically reduces wait time. If you have a job with three independent parts, three sub-agents can work on them simultaneously. The total time to completion drops from the sum of all parts to the time of the slowest part. For complex workflows, this is a game-changer.

Imagine you need to create a comprehensive market analysis. One sub-agent pulls the raw data. Another sub-agent analyzes competitor positioning. A third sub-agent drafts the executive summary. They all work at the same time, and you get the finished product in a fraction of the time it would take a single agent working linearly. This parallel execution capability is what separates a basic automation from a genuinely powerful autonomous system.

The Curator and Pinning Skills

Here's something that happens to almost everyone. You start building your skill library. You see a skill online that looks useful, so you install it. Then you find another one. And another. Over time, you accumulate dozens of skills that sounded good in theory but never actually made it into your regular workflow. This bloat is a problem. It makes it harder to find the skills you actually use, and it can slow the system down.

Hermes solves this with a background maintenance system called the curator. The curator monitors which skills are being used and archives those that haven't been used in a long time. It keeps your skill library clean and functional by automatically removing the dead weight. You don't have to manually prune your library. The curator does it for you.

But what if you have a skill you only use occasionally, maybe once a quarter, and you don't want it archived? That's what pinning is for. You can "pin" important skills to prevent archiving. Simply ask Hermes to pin the skill, and the curator will leave it alone. This gives you control over what stays in the active library. Pin the skills you genuinely need. Let the curator handle the rest.

Persistent Infrastructure: Running the Agent 24/7

If you want to unlock scheduled tasks and remote access, you need to think about where your agent lives. Running Hermes on your personal laptop is fine for interactive use, but it has a fundamental limitation. Your laptop isn't always on. You close it, you travel, you go to sleep. During all those times, your agent is offline.

For truly autonomous operation, you should deploy Hermes on a virtual private server (VPS). This is a cloud-based server that runs 24/7. The advantages are significant. First, the agent remains online when your local devices are shut down. Scheduled tasks run reliably on schedule, every time. You don't have to worry about your laptop being in sleep mode when a cron job is supposed to fire. Second, you can interact with the agent via messaging interfaces like Telegram bots. You can send a message from your phone, from anywhere in the world, and the agent will respond. This remote access is incredibly powerful. You're not tied to your desk.

The desktop application is still available for local use if you prefer that route. You have flexibility in how you deploy. But if you want a truly autonomous, always-available agent, a VPS is the way to go. It's not mandatory for basic use, but it becomes a practical requirement once you start building scheduled automations and background workflows.

Automation: Cron Jobs and Scheduled Workflows

Scheduled tasks are enabled through cron jobs. These are jobs that run skills or workflows automatically at defined times. This is what turns your agent from a reactive tool into a proactive worker.

Let's walk through a concrete implementation example. Suppose you have a weekly team meeting every Monday at 10 a.m. You want the agent to automatically pull the meeting transcript, analyze the content, identify action items, and generate a summary report. You would create a cron job scheduled for Monday at 10:30 a.m. The job runs the relevant skill, which accesses the transcript folder, processes the content, and creates the summary. All without you lifting a finger.

The job can depend on multiple skills and memory context. It can reference specific folders and files stored on the host system. The intermediate results of automated workflows are stored as output files that you can review and refine later. This means the agent isn't just generating ephemeral responses. It's creating artifacts that persist and can be used.

Here's an operational note that will save you headaches. Always verify your cron jobs after creation. It's surprisingly common for the wrong skill to be loaded initially. You might schedule a job expecting it to run your "meeting summary" skill, but it actually loads the "content ideas" skill. The job runs, produces something, and you don't notice the error until you review the output. Always check what the agent actually created. Ask for a summary of the cron job, the scheduled trigger, and the list of skills associated with it. This verification step is essential for quality control.

Real-World Implementation: An Automated Content Workflow

Now let's put everything together in a real-world example. This is a representative scenario that demonstrates how memory, skills, and automation combine into a practical, working system.

The scenario: A professional conducts weekly mentorship calls. Each call is recorded and transcribed automatically by a tool like Granola. The goal is to turn each call into a set of published content pieces for Instagram Reels. The user records 60-second to 2-minute reels, so they don't want a word-for-word script. They want talking points they can follow naturally.

Step 1: Providing structured input.

The user initiates the workflow by speaking to their laptop using a voice dictation tool like WhisperFlow. Rather than rambling, they follow a structured prompt pattern. First, they state the objective clearly. "I want to turn this week's mentorship call into three Instagram Reel ideas." Then they fill in the necessary context. "The call was about overcoming client objections." They include do's and don'ts. "Don't use jargon. Do use a conversational tone." They provide an example if possible. "Here's a hook I liked from last week." Finally, they tell the agent what resources are available and where to find them. "The transcript is in the Mentorship Calls folder. Hook examples are in the Reels folder."

This structured approach makes it much clearer for the agent to understand the task and produce high-quality outputs. It's a habit worth developing.

Step 2: Agent execution.

The agent pulls the relevant files from the user's computer. It accesses the call transcript folder. It finds the library of hook examples. It retrieves the template for structuring Reels, which might include elements like proof, tension, and close. The agent then processes all of this information and generates multiple content ideas per call. For each idea, it creates 3-5 hook variations and a set of talking points. The output is organized into files by topic, ready for the user to review or record.

The user receives a set of ready-to-record scripts every week, automatically. They don't have to re-explain the process. They don't have to remind the agent what a good hook looks like. The agent remembers from memory files and references the same resources every time.

Step 3: Creating the skill and scheduling the job.

After the workflow runs successfully, the user asks the agent to turn the process into a reusable skill. The agent creates a skill named something like "mentorship call reels workflow." Then the user asks the agent to schedule a cron job to run automatically. The agent sets it for the day after the weekly call. If the call happens Wednesday at 9 p.m., the cron job is scheduled for Thursday at 3:30 UTC. This ensures the transcript is available and the workflow runs without any manual trigger.

Step 4: Checking the agent's work.

The agent might make mistakes. In this example, it initially loaded the wrong skills for the cron job. The user caught the error by asking for a summary of what the agent had created. This verification step is essential whenever an agent builds something autonomously. After correcting the mistake, the user can see the cron job, the scheduled trigger, and the list of skills associated with it. Everything is transparent and verifiable.

Step 5: Reviewing the journey.

Hermes keeps a timeline of everything it has done. Using the /journey command, you can review when memory files were updated, which skills were created or modified, what cron jobs are currently active, and what other changes the agent made without being explicitly asked. For example, you can ask for a summary of all updates over the last 30 days. This transparency helps you stay aware of what the agent is doing and ensures nothing happens silently.

The outcome of this entire workflow is that the user receives ready-to-record scripts every week, automatically, without re-explaining the process. This is the compounding value of an agent that remembers and grows.

Monitoring and Maintaining the Agent

Even autonomous agents require periodic oversight. You can't just set it and forget it. The system includes a journey log that records all changes made by the agent, including memory updates, skill creations, and scheduled tasks. This is your window into what the agent is doing.

Here are some recommended practices for keeping your agent aligned with your goals.

First, ask for a periodic summary of all agent-initiated changes. You might ask for a 30-day summary of what the agent has updated, created, or modified. This gives you a clear picture of the agent's behavior without having to dig through logs manually.

Second, review the memory files and skills for accuracy and usefulness. Are the facts still correct? Are the skills producing good results? If something is outdated or wrong, fix it. The agent can't know everything has changed unless you tell it.

Third, correct the agent when it makes mistakes. This feeds into the learning loop. When you tell the agent it did something wrong and explain the correct approach, that information gets incorporated into future behavior. The agent improves because you're actively teaching it.

Fourth, update cron job configurations when workflows change. If your meeting time changes, the cron job needs to change too. If you stop doing a particular task, cancel the associated cron job. Keep your automation aligned with your actual work patterns.

Approval Mode and Control

When you're first starting, or if you're working in a sensitive environment, you might want to enable approval mode. This setting requires the agent to ask for your consent before it updates memory or creates a skill. It's a way to maintain control over what gets saved and learned.

Some users find approval mode too restrictive. They prefer the agent to operate autonomously and make its own decisions about what to remember and what to learn. That's a valid approach. But if you're the type of person who likes to know exactly what's happening in your systems, approval mode is a valuable safety feature. It gives you visibility into every change the agent wants to make, and it puts the final decision in your hands.

You can always start with approval mode enabled and then loosen the restrictions as you build trust in the agent's judgment. It's a flexible system that adapts to your comfort level.

Key Insights and Takeaways

Let's distill everything we've covered into the core principles that will guide your implementation.

Memory and skills are the foundation of an effective agent. Memory provides context. Skills provide capability. Neither alone is sufficient. You need both working together to create a genuinely useful system.

More memory is not always better. Bloated memory files degrade performance. The agent must consolidate to retain only what matters. Keep your memory files lean and focused. Resist the urge to store everything.

Skills are iterative. The first version of a skill will not be perfect. Expect to refine it based on real-world results. Treat every skill as a work in progress. The more you use it and refine it, the better it gets.

Automation creates compounding value. Cron jobs turn valuable skills into background productivity. They execute without user involvement, freeing you to focus on higher-value work. This is where the long-term payoff lives.

Sub-agents enable parallel execution. Complex workflows can be split into smaller tasks running simultaneously. This reduces total time and makes large jobs tractable.

Curated skill libraries stay functional. Avoid hoarding unused skills. Let the curator archive them, or pin the ones you genuinely need. A clean library is a functional library.

A VPS expands availability. For unattended automation, a 24/7 server is a practical requirement. If you want scheduled tasks to run reliably, you need the agent to be online when those tasks are supposed to fire.

Oversight is essential. Even self-improving agents need periodic review and correction to stay aligned with goals. Use the journey log. Ask for summaries. Verify the agent's work. This is not optional. It's how you maintain quality.

Action Items for Implementation

If you're ready to implement this system, here's a clear path forward. Follow these steps in order, and you'll be up and running in no time.

First, deploy Hermes on a persistent server if you need 24/7 availability and scheduled tasks. A VPS is the recommended choice. This is your foundation.

Second, initialize your memory files. Let the agent interview you, or manually populate user.md and memory.md with essential facts and preferences. This is the starting point for all future interactions.

Third, set up a second brain. Create a folder structure on your computer or server for all documents, templates, and reference materials. Organize it in a way that makes sense to you. The agent will reference this structure constantly.

Fourth, build one high-value skill first. Identify the repetitive process that consumes the most time and encode it as a skill. Iterate on it over several sessions until it produces consistently good results. Don't try to automate everything at once. Start with one thing and do it well.

Fifth, enable approval mode initially so you maintain control over what the agent writes to memory or learns as a skill. This gives you visibility and control while you're still building trust in the system.

Sixth, create a cron job for the skill once it is reliable. Choose an appropriate schedule and verify that the correct supporting skills are loaded. Check the agent's work after the first run.

Seventh, review the agent's journey log monthly. Ask for a summary of memory updates, skill creations, and background tasks. Prune or correct as needed. This keeps the system aligned with your goals.

Eighth, pin essential skills to prevent the curator from archiving them. Identify the skills you genuinely need and protect them.

Ninth, keep memory lean. Resist the urge to store everything in memory files. Use external folders for deep knowledge. The memory files are for what needs to be always present.

Tenth, scale gradually. Once one automation is stable, identify the next highest-ROI process to automate. Build momentum one workflow at a time.

The Strategic Challenge

Here's the honest truth about implementing this system. The challenges are not technical. The technical side is straightforward. The real challenges are strategic. You have to decide which processes to automate. You have to maintain the quality of the underlying workflows. You have to review the agent's evolving behavior and course-correct when needed.

This is not a set-it-and-forget-it system. It's a partnership. You teach the agent, you correct it, you refine its processes, and in return, it takes over the repetitive work that consumes your time. The more you invest in this foundation, the more you get back.

Think about what you could do with an extra few hours every week. Think about what it would mean to never have to re-explain your process to an AI tool. Think about having a system that gets better every single week, that builds on previous work, that understands your business and your preferences deeply. That's what this architecture delivers.

The difference between a disposable AI tool and a compounding intelligence is not the underlying model. It's the system around it. Memory. Skills. Automation. These are the elements that turn a generic assistant into a specialized digital worker. And they're all within your reach.

Conclusion

The true power of an AI agent lies not in its initial out-of-the-box performance but in its ability to compound knowledge and capability over time. Most people use AI agents as disposable tools because they don't know any other way. They give a task, get an answer, and start from scratch next time. This approach leaves almost all of the agent's potential unrealized.

The Hermes agent's memory and skill architecture provides a practical, accessible framework for building a self-improving system. Persistent memory files give the agent context. Reusable skills give it capability. Cron jobs give it autonomy. Sub-agents give it scale. A second brain gives it depth. Together, these features transform a generic AI tool into a specialized, autonomous worker that improves with every interaction.

You now have the complete picture. You understand the two core memory files and how to keep them effective. You understand how to build and refine skills. You understand how to chain skills and use sub-agents for parallel work. You understand the curator and the importance of pinning. You understand cron jobs and scheduled workflows. You understand the value of a VPS for 24/7 availability. And you understand the importance of monitoring and maintaining the system through the journey log.

What remains is implementation. Start with one process. Build one skill. Schedule one automation. Review the results. Refine. Iterate. Scale. The path is clear. The tools are available. The only question is whether you'll take the first step.

Those who invest in this foundation will find themselves working alongside an agent that grows smarter, faster, and more useful with every engagement. That's the genuine leap from disposable AI to compounding intelligence. It's not about having the most powerful model. It's about building a system that gets more powerful every single day.

Frequently Asked Questions

What is the core difference between Hermes and a standard AI chatbot?

Most AI tools are what you'd call stateless. You open a chat window, give it a task, and when you close the window, everything vanishes. The next time you open it, you're back to a blank slate, re-explaining your business, your preferences, and your context. Hermes breaks this cycle with a persistent memory system and a skill architecture. It's designed to remember who you are, how you work, and what you've done before. More importantly, it can learn repeatable processes, so you don't have to re-teach it the same workflow twice.

The result is a compounding effect. The more you use Hermes, the more valuable it becomes. It transitions from being a temporary tool to a long-term collaborator that knows your business and can execute complex tasks autonomously. That's the fundamental shift from using a disposable utility to building a compounding asset.

What are the primary files that power Hermes' memory system?

Hermes relies on two core markdown files for its built-in memory. The first is memory.md, which acts as the agent's personal notebook. It's automatically populated with operational details, facts about your environment, file structures, and key learnings from your sessions. The second is user.md, which is your identity profile. It contains your role, business context, communication style, and things to avoid. This file ensures the agent knows exactly who it's working for and how you like things done.

Both files are loaded at the start of every session, so they consume tokens. They have a character limit for this reason. You should treat them as high-value sticky notes, not a comprehensive journal. Periodically reviewing and cleaning these files keeps the agent focused and efficient.

Why is it counterproductive to have bloated memory files?

There's a common misconception that stuffing more information into the memory files will make the agent smarter. In reality, it degrades performance. These files have a character limit because they are injected into every single session, consuming valuable tokens. If they're bloated with redundant or outdated information, the agent has to process all that noise to find the signal.

Hermes handles this intelligently. When the files reach their limit, it doesn't just pile on more data. Instead, it consolidates, distilling the information to what truly matters and discarding the rest. The goal is to keep vital, frequently-referenced context accessible while letting less important details be pulled from the deeper session history when needed. Think of it as keeping your most important tools on your desk, not your entire storage unit.

Can users manually edit or add to the memory files?

Yes, absolutely. While Hermes automatically updates these files based on your interactions, you have full control. You can explicitly ask the agent to remember specific facts or preferences. For example, you might say, "Remember that I prefer data-heavy reports with charts," and it will incorporate that into the appropriate file.

You can also manually view and edit the files directly. This is useful for cleaning up outdated information or restructuring how data is organized. If you want even tighter control, you can enable approval mode. In this mode, Hermes asks for your permission before it makes any updates to its memory files or creates new skills. This provides a safety layer if you're concerned about the agent making autonomous changes you don't want.

How does Hermes recall past conversations and sessions?

Beyond the always-loaded memory files, Hermes can search through your entire session history. If you ask, "What were the key decisions from our last meeting?" or "What did we work on last week?", the agent will retrieve the actual past conversations to find the details. This creates a two-tier memory architecture.

The first tier is the memory files, which keep critical context close and inject it into every session for efficiency. The second tier is the full session history, which serves as a deeper archive that Hermes can query on demand. This separation ensures everyday interactions remain fast and efficient, while nothing is truly lost. It's the difference between having your notes on your desk versus having them in a filing cabinet you can access when needed.

What is a "second brain" and how does it relate to Hermes?

A second brain is an organized collection of files and notes on your computer or server, structured into folders and categories. It serves as a knowledge repository that your AI agent can reference on demand. Tools like Obsidian are popular for this because they provide a visual interface for browsing markdown notes, project briefs, and documentation.

The concept matters because Hermes' built-in memory is not designed to store your entire business knowledge. For larger knowledge bases, you maintain a structured file system, and Hermes taps into it when needed. For instance, you might say, "In the client proposals folder, pull the template we used for Acme Corp," and the agent will navigate to that file, extract the information, and use it in your current task. This external layer provides depth without bloating the character-limited memory files.

What exactly is a "skill" in Hermes?

A skill is a repeatable process that Hermes can execute on command. It encapsulates the steps, prompts, references, and outputs of any workflow you perform regularly. This could be anything from creating a weekly report, drafting a proposal, analyzing data, or generating content. Once a skill is created, you can invoke it with a simple command, typically by typing /skillname or asking Hermes to run it.

The power here is that you don't have to re-teach the process every time. The agent executes the entire workflow, referencing the files, documents, and instructions embedded in the skill definition. This is what transforms Hermes from a tool that follows instructions into a system that has learned your standard operating procedures. It saves significant time and ensures consistency across tasks.

How do users create skills in Hermes?

There are three primary ways to build skills. The first is using the /learn command. After you work through a process manually within Hermes,providing instructions, completing a task, refining outputs,you can type /learn to turn that exact workflow into a reusable skill. The second is through automatic skill creation. Hermes may proactively create skills based on observed patterns in how you use it. If it notices you frequently perform a similar multi-step task, it can generate a skill without you asking.

The third is importing existing skills. You can install ready-made community skills shared by other users, or import skills you created on another Hermes instance, like moving from your local device to a VPS. Additionally, Hermes comes preloaded with a library of default skills that you can modify and customize to fit your needs. This gives you a solid starting point right out of the box.

What is the Curator and what role does it play in skill management?

The Curator is an automatic maintenance system that quietly archives skills you have stopped using. It's easy to accumulate dozens or even hundreds of skills you never actually deploy. The Curator works in the background to keep your skill library clean and lean by identifying skills that haven't been used for an extended period and archiving them.

The key feature here is the ability to pin any skill you want to preserve indefinitely. Simply tell Hermes, "Pin this skill so the Curator doesn't archive it," and it will be permanently protected from automatic removal, even if you only use it once every few months. This ensures you don't lose valuable workflows while still keeping your active library uncluttered.

What are context files and how do they enhance the agent?

Beyond the standard memory.md and user.md, Hermes supports additional markdown files that provide specialized context in specific scenarios. Examples include voice.md to define the tone Hermes should adopt for different types of output, agents.md for configuration of sub-agents and multi-agent workflows, and soul.md to define the core personality and philosophical orientation of the agent.

These custom context files give you modular control over what information Hermes loads. You can tell the agent to include these supplementary files as part of its working context for complex projects or niche business domains. This flexibility allows you to inject scenario-specific context without cluttering the core memory files that are used for every interaction.

Can Hermes integrate with external knowledge management systems?

Yes. While Hermes has its own built-in memory, it can also connect to and reference external file systems and knowledge bases. Obsidian is a popular tool for this purpose, providing a visual interface for browsing markdown files stored in a structured folder hierarchy. This makes it easy to organize and locate knowledge assets.

The practical workflow involves maintaining a structured folder system on your machine or server. For example, you might have separate folders for content briefs, client proposals, market research, and template libraries. Hermes can access these files, pull relevant information, and use them as references within skills and automations. This external knowledge layer complements the built-in memory by providing depth without bloating the character-limited memory files.

What are cron jobs and how do they enable autonomous operation?

Cron jobs are scheduled tasks that Hermes executes automatically at predetermined times. Named after the Unix cron utility, these scheduled automations allow the agent to run workflows in the background without any manual initiation. This is what gives Hermes its autonomy.

For example, you might schedule a cron job to run every Thursday morning that pulls a recent meeting transcript, identifies key content ideas, generates hooks and scripts, and saves the outputs to a specific folder,all without you touching anything. Cron jobs require the agent to be running continuously, which is why deploying Hermes on a VPS is recommended for 24/7 availability. When scheduled tasks fire, they can reference your existing skills and memory files to complete complex, multi-step processes autonomously.

What are sub-agents and how do they improve efficiency?

Sub-agents are specialized Hermes instances that the main agent can spin up to work on portions of a task in parallel. Instead of processing a large job sequentially,phase one, then phase two, then phase three,the main agent can delegate each phase to a separate sub-agent that works concurrently. This parallel processing dramatically reduces the wall-clock time required for complex projects.

All sub-agents report back to the main agent when completed, and the main agent compiles their outputs into a cohesive final result. Sub-agents are particularly valuable for content pipelines, research tasks, and data processing workflows where multiple independent workstreams can run simultaneously. Instead of waiting for one step to finish before starting the next, you can have multiple steps happening at once.

What is approval mode and when should it be used?

Approval mode is a setting that requires Hermes to ask for your explicit permission before it makes changes to its memory files, creates new skills, or performs other autonomous modifications to its configuration. It's a control mechanism for users who want to review every change before it's committed.

Without approval mode, Hermes will autonomously update memory and create skills based on your usage patterns. This is generally helpful but can occasionally produce unexpected results. For users who want tight control over how the agent evolves, approval mode provides a safety layer. The trade-off is convenience; you have to actively monitor and approve changes, which means you may miss out on the agent's proactive improvements if you're not regularly checking in.

What is /journey and how does it help with oversight?

/journey is a command that produces a comprehensive timeline of everything the agent has done, including skills it has created, updates to memory files, cron jobs set up, and other autonomous actions that may have occurred without your awareness. This is particularly valuable for users who run Hermes autonomously.

By typing /journey, you get a detailed audit trail showing when memory files were last modified and what points were added, which skills were created or updated, what cron jobs are currently active, and any other configuration changes. This transparency ensures you can spot errors, catch unexpected behavior, and course-correct before issues compound. It's your window into the agent's autonomous activity.

Why is it beneficial to deploy Hermes on a VPS rather than only on a local machine?

Local deployment limits Hermes to running only when your computer is powered on and the application is open. This severely constrains the agent's ability to execute scheduled tasks, respond to messages, or run background workflows while you sleep, travel, or close your laptop. A VPS keeps Hermes running 24/7.

This enables scheduled automations that fire at specific times regardless of whether you're around, always-on availability for integrations like Telegram bots, and background processing of business tasks. While a VPS is not strictly required,Hermes works fine on a desktop,it's the recommended approach for anyone who wants full autonomy and reliability. It's worth noting that using a VPS is entirely optional; it's one deployment option among several, not a mandatory requirement.

What are memory providers and how do they extend Hermes' capabilities?

Memory providers are external services that offer more robust, scalable memory systems than the built-in memory files. Hermes supports integration with specialized memory platforms like Honcho, which provides an API-driven persistent memory layer. These are appropriate when your usage demands more sophisticated memory management.

This could include storing large volumes of structured knowledge, supporting multi-user contexts, or needing advanced retrieval capabilities that go beyond the character-limited markdown files. By connecting a memory provider, you effectively offload the memory burden to a purpose-built system that can grow with your requirements. It's a way to scale your agent's memory beyond what a simple file system can handle.