Why Hermes Agent Plus Browser Harness Is the Fastest-Growing AI Agent

Why a self-improving architecture beats a smart-but-static agent

Most AI agents are smart when they are first deployed and stay at exactly that level of smart indefinitely. They handle the tasks they were built for competently, and they do not learn from the runs they complete. Every time they encounter a new edge case, it is new information they do not carry forward. Every quirk of a website they have interacted with before is something they rediscover from scratch. The knowledge a single run produces dies at the end of that run.

Hermes Agent is built differently, and that architectural difference is the direct explanation for why it became the fastest project in GitHub history to reach 100,000 stars. The core feature is this: Hermes writes its own skills. After completing a task, it documents what it learned into a skill file. The edge cases it encountered, the URL patterns that were relative when they looked absolute, the pagination quirks, the selectors that changed partway through the page: all of it goes into a skill. The next time the agent runs a similar task, it starts with that knowledge already loaded. It does not rediscover the same traps. It runs faster, uses fewer tokens, and handles the task more cleanly because it carries the accumulated knowledge of previous runs.

That is the self-improvement loop, and it is architecturally different from what most people mean when they talk about AI improving over time, which usually refers to a model being trained on more data. Hermes improves at the skill level, not the model level. The underlying language model stays the same. The library of tasks it knows how to perform well grows continuously, and each task in that library is more refined than the first attempt at it was. The compounding is in the skills, not the model, which means the improvement is specific to your context and your tasks rather than generic across all users.

The Browser Harness: adding hands to a brain

An agent that can reason but cannot interact with the web directly is limited to what it can accomplish through APIs and structured text interfaces. Most of the work a business does online does not happen through APIs. It happens through browser sessions: logging into dashboards, pulling reports, checking competitor pages, filling forms, monitoring inventory levels, updating listings. All of that is screen work performed through the same browser interface any person uses.

The Browser Harness is a companion repository to Hermes that gives the agent the ability to see a page, click elements, type into fields, scroll, and navigate, the exact same interactions a person with a mouse and keyboard would perform. Once the Browser Harness is connected, the agent can do anything a browser-using human can do, because it is interacting with the browser the same way.

What makes the Browser Harness more interesting than similar tools is the self-healing behavior. When the default browser library cannot complete a specific step, because a selector changed, a page behaves unexpectedly, or a new interaction pattern appears that the current library does not handle, the harness writes new functions and new skills to finish the job rather than stopping and reporting an error. The team behind it was confident enough in this self-healing behavior that they offered a free Mac mini to anyone who could find a browser task the harness could not complete. That offer is a signal of how robust the loop actually is in practice.

In one demonstration, the agent was given a goal to scrape the top fifteen posts from a news aggregator site, pulling the title, score, author, comment count, and URL of each into a clean JSON file. It used an existing skill it had built from a previous run, encountered new edge cases including relative URLs and pagination behavior it had not seen before, patched the skill to handle them, and returned the complete result with the new knowledge documented for next time. In a separate test it opened a video platform channel page, pulled the twelve most recent videos, and assembled them into a four-by-three image grid. Midway through, a local browser connection failed. The agent healed it without any human input, then discovered the data it needed was already present in the page HTML rather than loaded dynamically, so it skipped the slower visual extraction and finished faster than the original approach would have taken.

The skill-writing loop that makes every repeat task cheaper

The compounding dynamic of the skill library is where the real business value accumulates over time, and it is worth explaining in some detail because the effect is not intuitive until you have watched it play out.

On the first run of a new task, the agent approaches it without prior knowledge of that specific context. It explores the environment, makes decisions about how to proceed, encounters edge cases it did not anticipate, and works through them. This first run takes longer and uses more model tokens than any subsequent run will. At the end of the run, it writes a skill file that captures everything it learned: the approach that worked, the edge cases it hit and how it resolved them, the shortcuts it discovered that the straightforward approach missed.

On the second run, the agent loads that skill and starts with all of that knowledge already in hand. It skips the exploration phase for the parts that are documented, handles the known edge cases without hesitation, and reaches the same result faster and at lower cost. The skill file refines with each run as the agent adds new edge cases it encounters and removes steps it discovers are unnecessary.

To attach rough illustrative proportions to this: a task that might take forty minutes of agent time on the first run, including all the exploration and edge-case resolution, might take around eighteen minutes after a month of skill building, and fewer than ten minutes after three months, as the skill captures the full set of quirks specific to those particular websites and tasks. The infrastructure cost stays flat throughout. The token cost per run decreases. The time to result shrinks. The skill library that accumulates across all the tasks the agent handles becomes a business asset, specific to your workflows and your environment, that no off-the-shelf tool provides because it was built through your actual runs.

Five mistakes in the setup that cost real money

The setup process is approachable, and there are five specific mistakes that cause real monetary cost when they happen early.

The first is running the agent without a spending cap on the API key. Hermes routes through OpenRouter, which means model costs accrue with every run. A misconfigured goal that sends the agent into an unexpected loop, or a task that proves significantly harder than anticipated, can consume far more tokens than planned before you notice. Setting a cap before the first real task is not optional precaution. It is the first line of defense against an unexpected bill.

The second mistake is giving the agent a vague goal for the first run of a new task. Vague goals match many possible approaches, which means the agent has to spend tokens exploring before settling on a direction. That exploration time costs more than a focused first run would, and the skill file it produces after a vague first run is less useful for subsequent runs than a skill written from a well-specified task. A specific goal with a clear output format produces a better skill file and a better first result.

The third mistake is treating the first run as the finished product. The first run is a draft. The skill file it produces is the real asset. Read the skill file after the first run, check what edge cases the agent documented, and run the task again on a slightly harder version of the same job before scheduling it to run automatically overnight. The skill is production-ready when it handles the harder version cleanly, not when the first run happens to work.

The fourth mistake is not reviewing the skill file before the second run. The skill file tells you what the agent understood about your task and context. Reading it takes ten minutes and shows you whether the agent's interpretation matches your actual intention. Edge cases the agent documented but handled incorrectly become visible before they compound into a week of subtly wrong results. This review step is the quality gate between a first run and a production schedule.

The fifth mistake is removing the spending cap after the initial runs. Once the agent is running tasks reliably, there is a temptation to remove the cap to avoid any possibility of a task stopping partway through. Keep a cap in place, sized at a comfortable multiple of the typical run cost. The risk of an unexpected loop or a task that expands in scope does not disappear with familiarity. A cap sized at three times the typical run cost rarely interferes with normal operation and always provides a backstop against the unexpected.

Putting it on a server so it works while you sleep

The single most impactful decision in deploying Hermes is removing it from a laptop and putting it on a server. A laptop closes. It sleeps. It travels with you and sometimes operates on a slow or restricted connection. An agent running on a laptop is available when the laptop is on and connected, which is not the same as continuously available.

A small virtual private server changes the economics entirely. A modest server capable of running several agents simultaneously costs roughly five to ten dollars a month. That server runs continuously around the clock, is reachable from any network, and does not close, sleep, or travel. Tasks scheduled to run at three in the morning because that is when the data updates you need run at three in the morning without anyone pressing a button or remembering to leave a computer on.

The architecture that works well for multiple task types is one agent instance per major category. One instance handles daily inventory checks. Another handles competitor monitoring. A third handles content research. Each has its own skill library tuned to the specific websites and data sources for its domain, so the edge cases it has learned are precisely relevant to the tasks it runs. You interact with each through a standard interface, review the skill files when you want to understand what the agent has learned, and update the goals when the underlying tasks evolve.

Security on the server is worth taking seriously from the beginning rather than adding after the fact. Run the agent processes as a non-root account with minimal filesystem permissions. Store the API key as an environment variable, never hard-coded in a configuration file. Keep the spending cap active at the API level so it applies regardless of how the agent is invoked. Rotate the key on a regular schedule and whenever a configuration changes significantly.

An online store that automated its morning grind in one week

The use case I find most instructive for a business without a technical team is an online store that was doing its morning reporting entirely by hand every day.

The morning routine looked like this: log into the store admin, check yesterday's orders for anything requiring manual attention, log into each supplier's page to check current stock levels on fast-moving items, compare those stock levels to what the store had listed as available, update any listings where actual stock was running low, pull revenue and order numbers into a shared spreadsheet for the team, and flag any pricing differences with the main competitor. Start to finish, this consumed an hour and a half of staff time every morning before any other work began.

The Hermes setup for this took one week of initial runs and refinement. The first day was the inventory check. The agent was given the store admin URL, the supplier URLs, and a specific goal describing the comparison logic and the output format. The first run took around forty minutes as the agent navigated the store admin, learned the supplier site structures, encountered pagination quirks and relative URL patterns it had not seen before, and documented all of it in a skill file. The second run used that skill and took twenty-two minutes. By the end of the first week the task was running in under ten minutes per morning.

The competitor monitoring was the second task, set up midweek. The agent was given three competitor product page URLs and a clear definition of what to log: price, availability status, and any promotional callout visible on the page. The first run took thirty minutes and hit two edge cases where competitor pages used lazy-loaded pricing that appeared only after the viewport scrolled to the element. The agent documented both edge cases in the skill and handled them automatically on subsequent runs.

By the end of the first week both tasks were scheduled to run automatically every morning at five, before anyone arrived. The staff member who had been doing the morning routine walked in each day to a shared document already populated with the inventory comparison and the competitor price check, with a flagged list of any discrepancies needing human attention. The hour and a half became fifteen minutes of reviewing what the agent had found and making decisions about the flagged items.

The compounding skill library as a business asset

The argument I want to close with is about time horizon rather than individual task value. Most of the conversation around AI agents focuses on what a single task costs and how fast a single run finishes. Those are the right questions for evaluating a first use case. They are not the right questions for evaluating what a self-improving agent deployment is worth over one year.

Over one year, a Hermes deployment running tasks daily builds a skill library that reflects the specific contours of your business. The edge cases it has learned are the edge cases of your supplier sites, your store admin, your competitor pages, and your content sources. No other business has the same skill library because no other business has exactly the same combination of tasks, platforms, and operational patterns. The library is, in a real sense, a proprietary operational asset. It was built through your actual runs, on your actual environment, and it gets more valuable with each run because each run either refines an existing skill or adds a new one.

That library is also cumulative in a way that transfers across related tasks. If the agent has already learned how to navigate your store admin for inventory checks, it applies portions of that knowledge when you add a new task about checking order statuses. The learning carries over across tasks that share context, which means each new capability you add costs less to establish than the previous one did. The skill library gains momentum.

At the start of the process the agent is a capable tool with a small library. At the end of a year of continuous operation it is a well-trained operational system that knows your specific business environment in a way that no generalist tool does. The infrastructure cost throughout is a small fixed monthly amount. The skill library grows without additional investment. The value it produces grows with the library.

That compounding is the reason to start with a well-defined first task today rather than waiting for the tooling to mature further. The skill library only builds through actual runs on actual tasks. The head start is the time in operation, and time in operation is something that cannot be purchased retroactively.