Hermes Agent's $90M Funding: Can Open-Source AI Agents Win Enterprise Adoption?

Funding and Market Context

On October 8, 2026, The Wall Street Journal reported that Nous Research closed a $90 million Series B round, bringing total funding to $158 million at a $1.5 billion valuation. Investors include Robot Ventures, NVIDIA, Microsoft's M12, and Samsung. The company claims Hermes has been downloaded approximately 22.7 million times since February 2026 and cloned over 24 million times, with internal estimates suggesting Hermes accounts for roughly 2.5% of global token usage — figures that lack independent verification but indicate significant open-source traction.

CEO Dillon Rolnick announced Hermes for Businesses , repositioning the MIT-licensed agent from individual developers to enterprise customers. The core pitch: enterprises should be able to choose their own models, control deployment environments, and retain the knowledge and capabilities their agents accumulate over time.

Why Hermes Moves from Personal Assistant to Enterprise

Nous Research was founded in 2023, initially focusing on open-model post-training and tool-use research (e.g., YaRN for long-context). In 2025 they built an internal Agent Stack, releasing Hermes Agent under MIT license in February 2026. Hermes attracted developers by offering a self-hosted, modifiable agent system accessible via terminal, Telegram, Discord, Slack, and other entry points, with support for file, browser, and code-execution tools, flexible model provider selection, and deployment on local or remote servers.

For individual users, flexibility is the main benefit. For enterprises, that flexibility translates directly into architectural control and long-term maintenance cost reduction. The article illustrates with a scenario: a dev team builds a code-review agent integrated with internal Git repos, test environments, and bug trackers. Six months later they want to swap the underlying model. If tools, state, and execution logic are tightly bound to the original model platform, migration could require rebuilding the entire workflow. Hermes' design favors the alternative: decoupling the execution system so the model becomes a configurable component, while tools and runtime remain portable.

Nous Research explicitly states that enterprises should own and improve their own AI systems . Hermes for Businesses will center on model choice, organizational knowledge accumulation, and secure, private scaling. The company argues enterprises can pick more cost-effective models per task, lowering spend — though the article cautions that actual savings depend on task success rates, invocation pricing, tool compatibility, and ongoing ops work.

Decoupling Model and Execution System for Flexible Agent Adjustment

According to official developer docs, Hermes comprises distinct interaction entry points (CLI, messaging gateway, API), a shared AI Agent core , a model service integration layer ( Provider Resolution ), a tool system, and session storage. All entry points invoke the same execution logic; model, tools, and state are managed by separate components.

A hypothetical task walk-through shows the flow: a developer asks Hermes via Slack to audit a code repository. The Messaging Gateway authenticates the user and retrieves the session; the AI Agent core reads context, builds a prompt, and sends it to the configured model via Provider Resolution (which handles provider selection, API schema, auth, and endpoint). The model decides whether to call code, file, or terminal tools; the Tool System executes those operations and returns results. On completion, the session is saved and the result is sent back via Slack.

Provider Resolution enables model swapping without touching tooling. Tools are registered independently — terminal, filesystem, browser, external MCP services — so new tools can be added without modifying the model. This gives enterprises wider model choice: e.g., a data-analysis agent with database query, Python execution, and report-generation tools can be tested against multiple models, selecting based on complexity, latency, token cost, and tool-call success rate, without locking the entire pipeline to one vendor.

However, the article notes that interface replaceability does not guarantee identical task performance. Multi-step workflows are sensitive to how models understand tool parameters, recover from failures, and manage context. Enterprises must still re-evaluate before committing to a swap.

Hermes also makes the execution backend configurable: local, Docker, SSH, Daytona, Modal are supported. This matters for enterprise workloads that must connect to internal data systems or run untrusted code, allowing teams to match deployment topology (host machine, isolated container, remote environment) to each task's network, compute, data-access, and isolation requirements.

A critical caveat: self-hosting Hermes does not automatically keep data inside the enterprise. If Hermes calls external model APIs, task context may leave the organization. Actual data boundaries depend on model deployment location, tool connections, credential handling, and log configuration.

From an engineering perspective, Hermes reduces coupling between agent components. Enterprises can adjust models or execution environments while preserving tools and workflows. This doesn't eliminate migration costs but can shrink the scope of changes required for each technical adjustment.

Memory and Skills: Turning Business Experience into Maintainable Assets

Beyond model and tool flexibility, Memory and Skills determine whether an agent can reuse accumulated work experience. Enterprises hold vast tacit knowledge — which table stores a metric, pre-deployment checks, commit conventions, verification steps — scattered across people, docs, scripts, and history. As agents take on long-running work, persisting and reusing that experience becomes an engineering challenge.

Hermes addresses this through three mechanisms:

Persistent memory stored in MEMORY.md (project environment, conventions, experience; default 2,200 chars) and USER.md (user preferences; default 1,375 chars). These files are read at session start and injected into the prompt.

Full session history kept in SQLite with FTS5 full-text search . Agents can invoke session_search to retrieve past discussions and execution traces on demand. Frequently used info lives in persistent memory; detailed lookups pull from history.

Skills capture concrete work methods. The skill_manage tool lets agents create, modify, and delete reusable skill files. When an agent completes a complex task, discovers a procedure, or incorporates user feedback, it can write the workflow into a skill for future invocations.

A hypothetical example: a Data Agent develops an analysis flow for a key business metric — query prescribed tables, run validation SQL, check business constraints, emit a standardized report. That method becomes a Skill; project context goes into Memory. The article emphasizes this is a scenario, not a published customer case, illustrating the division: Memory stores facts and context; Skills store executable methods.

File-based knowledge and processes are easier to inspect, version, and integrate into existing engineering practices than ephemeral conversation context. But the article warns that Hermes' "continuous learning" relies on external memory and skill updates — not automatic model-weight training — and more experience does not guarantee higher correctness.

Quality control for experience updates is crucial. If an agent saves a fluke success as a general rule, or memory retains stale info, downstream tasks may repeat errors. Hermes provides a write-approval mechanism : enabling skills.write_approval puts skill changes in a pending state for human diff review before application; memory.write_approval does the same for persistent memory. This moves experience accumulation from pure automation into a human-in-the-loop workflow, letting organizations vet critical steps before they become reusable.

This governance layer may be a differentiator: enterprise-generated knowledge, procedures, and tool configs can be maintained by the organization rather than depending on a model vendor's memory features. Still, file persistence alone doesn't equal reliable knowledge — versioning, collaboration, permission inheritance, and rule updates need additional design. Hermes provides foundations, not a full enterprise knowledge-governance system.

Enterprise Integration Demands Engineering-Grade Permission Management

Once agents connect to internal systems, permission management dictates what work they can safely perform. Hermes uses MCP (Model Context Protocol) to attach external tool services — databases, filesystems, GitHub, internal APIs — and controls which tools are exposed to the model.

Example: an order system offers query, modify, and delete endpoints. An analytics agent should only get the query tool; a fulfillment agent needing state changes must combine business-system permissions with approval workflows for write operations. Hermes' tool configuration can narrow the agent's callable operation set . Official security docs also list message-platform user allowlists, DM pairing, high-risk command approval, file-write restrictions, container isolation, and MCP subprocess environment-variable filtering.

These protections have boundaries. File-tool path restrictions (e.g., blocking write_file and patch on sensitive paths) only constrain those specific tools; if the agent also has host-terminal access, it can still reach files via shell. Thus file-tool limits cannot replace OS-level permissions and environment isolation. Likewise, showing the model fewer tools doesn't guarantee safety if the exposed tools themselves carry excessive business privileges.

This is the core permission challenge for enterprise agents: they need enough capability to be useful, but must not gain unnecessary system access from a single misjudgment. For state-changing tasks, tool permissions, human approval, runtime isolation, and execution audit trails must align with actual risk. Hermes' advantage is that its runtime and code are inspectable and modifiable, letting enterprises tailor execution policies to their environment. Open source alone doesn't create a complete security posture — identity management, privilege separation, auditing, and disaster recovery still require concrete implementation and validation.

Hermes Sells a Continuously Controllable Agent System

Combining architecture, Memory, Skills, and permission controls, Nous Research's enterprise strategy is clear: enterprises choose the base model, arrange task runtimes, connect existing business tools, and keep agent-accumulated knowledge and methods in systems they maintain. When model capabilities, pricing, or business needs shift, teams can swap individual components without rebuilding entire workflows each time. This is the core enterprise value proposition.

Unlike buying a generic Q&A assistant, enterprises must continuously operate an agent environment wired to their own systems. Models will keep evolving, but internal tools, permission rules, task flows, and validated operational experience need long-term viability.

This logic explains why Nous Research launched Hermes for Businesses after the open-source version gained traction: open source attracts developers to build apps and workflows; the commercial product can monetize deployment, security, org management, and ongoing services. However, the article stresses that publicly disclosed enterprise product details remain limited, so potential commercial capabilities should not be treated as already delivered.

From a buyer's perspective, Hermes fits organizations that already have extensive internal APIs, data systems, and complex workflows, want model flexibility, and possess the capacity to self-host and maintain the stack. If a company only needs a general-purpose information assistant and prefers quick, low-maintenance adoption, managed platforms are more direct.

Greater control brings greater responsibility: enterprises must handle deployment, monitoring, incident response, security auditing, version upgrades, and skill management themselves. Model inference costs may drop, but total engineering costs may not fall proportionally.

Currently, Nous Research has not published detailed, independently verifiable enterprise production cases proving Hermes' superiority in task success rate, long-term stability, or total cost of ownership. Official download, clone, and token-usage metrics cannot substitute for those production indicators.

For enterprises evaluating Hermes, the most valuable validation is to pick a real internal workflow and, under identical permissions and task conditions, compare Hermes against existing solutions on completion rate, failure recovery, model-switching cost, and maintenance overhead. Only then can they judge whether retaining control of the agent system yields benefits that outweigh the added engineering burden.

The $90M round gives Nous Research resources to scale and clarifies the path from developer tool to enterprise market. The proposed value is straightforward: let enterprises continuously own their agent runtime, preserving models, tools, and work experience through technological change. Whether that autonomy creates a large enough commercial market will depend not on download counts, but on how many enterprises trust it with real business long-term, and whether those deployments prove reliable, controllable, and economical.

References: The Wall Street Journal, "Nous Research Scores $90 Million to Bring Open-Source AI Assistant to Enterprises", October 2026. Nous Research / Dillon Rolnick, "A Note on Our Fundraise", October 2026. TechCrunch / Marina Temkin, "Nous Research confirms it hit $1.5B valuation, launches AI agents for business users", October 7, 2026. Nous Research, Hermes Agent — Official GitHub Repository.