Nous Research Raises $90M to Bring Open-Source Hermes Agent to Enterprises

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 agent from individual developers to enterprise customers. The core proposition: enterprises can choose their own models, control deployment environments, and retain the knowledge and capabilities agents accumulate during work. This addresses a growing pain point: as AI assistants connect to databases, code repositories, and business systems, organizations invest heavily in tool development, workflow configuration, permission management, and long-term business experience. If these capabilities are locked into a single platform, migrating to a new model or vendor could cost far more than simply switching an API endpoint.

01 Why Hermes Moves from Personal Assistant to Enterprise

Founded in 2023, Nous Research initially focused on open models, post-training, and tool-use research, releasing work such as YaRN for long-context extension. In 2025 they built an internal Agent Stack, and in February 2026 released the Hermes Agent under the MIT license. Hermes attracted developers by providing 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 individuals, flexibility is the main benefit. For enterprises, that flexibility translates directly into architectural control and long-term maintenance costs. The article illustrates with a scenario: a dev team builds a code-review agent integrated with internal Git repos, test environments, and defect-tracking systems. Six months later they want to swap the underlying model. If tools, state, and execution logic are deeply bound to the original model platform, migration may require rewriting the entire workflow; if components are independently retainable, the team mainly re-adapts the model interface and re-validates task outcomes. Hermes' design favors the latter, decoupling the execution system so the model becomes a configurable component while tools and runtime environments can be adjusted separately.

Nous Research explicitly states that enterprises should be able to own and improve their own AI systems. Hermes for Businesses will center on model choice, organizational knowledge accumulation, and secure, private scaling. The company also argues enterprises can pick more cost-effective models per task, reducing spend — though the article notes actual savings depend on task success rates, invocation pricing, tool compatibility, and ongoing ops work. The clearer foundation is that the more engineering effort a company pours into agents, the more it needs assurance those assets remain usable long-term. Hermes aims to let developers keep their running systems without rebuilding every time the model changes.

02 Decoupling Model and Execution System for Flexible Agent Adjustment

According to official developer docs, Hermes comprises multiple interaction entry points, a shared AI Agent core , a model service integration layer, a tool system, and session storage. CLI, messaging gateways, and APIs all invoke the same agent execution logic, while models, tools, and state management are handled by separate components.

A hypothetical task execution flow demonstrates the collaboration: a developer asks Hermes via Slack to inspect a code repository. The Messaging Gateway receives the message, verifies authorization, and locates the session; the AI Agent reads context, constructs a prompt, and sends it to the configured model. The model decides whether to call code, file, or terminal tools; the Tool System executes the operations and returns results to the model. Upon completion, the session is saved and the result is returned via Slack.

Provider Resolution handles model integration, determining provider, API schema, authentication, and endpoint from configuration. Tools are managed through an independent registration mechanism covering terminal, filesystem, browser, and external MCP services. Models can be swapped while the tool system persists; new tools can be added without modifying the underlying model.

This architecture expands model choice. For example, an internal data-analysis agent already wired to database queries, Python execution, and report-generation tools can be tested against different models, selecting based on task complexity, latency, token cost, and tool-call success rates — without locking the entire pipeline to a single vendor. However, the article cautions that swappable interfaces do not guarantee identical task performance; multi-step workflows are sensitive to how models understand tool parameters, recover from failures, and handle context. Enterprises must still re-evaluate to confirm a swap is worthwhile.

Hermes also makes the execution environment a configurable backend, officially supporting local, Docker, SSH, Daytona, and Modal . This lets developers run tasks on the host, in isolated containers, or in remote environments — critical for enterprises where agents may need to access internal data systems or execute untrusted code, and where different workloads demand different network, compute, data-access, and isolation profiles. Yet self-hosting does not automatically keep data inside the enterprise: if Hermes calls external model APIs, task context may leave the organization. The actual data boundary depends 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 does not eliminate migration costs but can shrink the scope of changes required for each technical adjustment.

03 Memory and Skills: Turning Business Experience into Maintainable Assets

If models and tools define what an agent can do, Memory and Skills determine whether it can reuse previously accumulated work experience. Enterprises hold vast tacit knowledge — which table stores a metric, pre-deployment checks, commit conventions, verification steps — scattered across employee experience, docs, scripts, and historical tasks. As agents take on long-running work, persisting and reusing that experience becomes a practical engineering challenge.

Hermes addresses this through persistent memory, historical session retrieval, and Skills . Persistent memory lives 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 is stored in SQLite with FTS5 full-text search , allowing the agent to query past discussions and executions via session_search. Frequently used information comes from persistent memory; detailed traces are retrieved on demand.

Skills capture concrete work methods. The skill_manage tool lets agents create, modify, and delete reusable skills. When an agent completes a complex task, discovers an operational sequence, or corrects a method based on user feedback, it can write the workflow into a skill file for future invocations.

A hypothetical scenario: a Data Agent establishes an analysis flow for a key business metric — query prescribed tables, run validation SQL, check business constraints, generate a fixed-format report. This repeatable method becomes a Skill, while project environment details go into Memory. The article emphasizes this is illustrative, not a published customer case, but shows the division: Memory stores facts and context; Skills store executable methods .

File-based knowledge and processes are easier to inspect, modify, and integrate into existing engineering practices than ephemeral context. However, the article stresses that Hermes' "continuous learning" relies on external memory and skill updates — not automatic model-weight training — and more experience does not guarantee higher correctness. Enterprises must guard against quality degradation: if an agent saves a fluke success as a general rule, or memory retains stale information, downstream tasks may repeat errors. Hermes provides a write-approval mechanism : enabling skills.write_approval puts skill changes into a pending state for human diff review before application; memory.write_approval offers similar control for persistent memory. This moves experience accumulation from pure auto-save into a human-in-the-loop workflow, letting organizations vet critical steps before they become reusable.

This could be a differentiated piece of Hermes' enterprise value: organizational knowledge, steps, and tool configs can be continuously maintained by the organization rather than depending entirely on a model vendor's memory features. Still, file persistence alone does not equal reliable knowledge; versioning, multi-user collaboration, permission inheritance, and rule updates require additional design. Hermes provides foundations but not a full enterprise knowledge-governance system.

04 Enterprise Integration Demands Engineering-Grade Permission Management

Once agents connect to internal systems, permission management directly dictates what work they can safely perform. Hermes uses MCP (Model Context Protocol) to link external tool services — databases, filesystems, GitHub, internal APIs — and configures which tools are exposed to the model. This lets developers hand existing system capabilities to agents, but also means models can directly affect business data.

Example: an order system offers query, modify, and delete interfaces. An analysis-only agent should receive only the query tool; modifying order state requires combining business-system permissions and approval workflows to gate write operations. Hermes' tool configuration can narrow the agent's callable operation set . Official security docs also provide messaging-platform user allowlists, direct-message pairing, high-risk command approval, file-write restrictions, container isolation, and MCP subprocess environment-variable filtering.

These protections have boundaries. Hermes can restrict write_file and patch tools from sensitive paths, but the docs note these limits only constrain the corresponding file tools. If the agent also holds host terminal access, it can still reach files via shell. File-tool restrictions cannot replace OS-level permissions and environment isolation. Likewise, showing the model fewer tools does not 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 complete tasks, yet must not gain unnecessary system access from a single misjudgment. For state-changing tasks, tool permissions, human approval, runtime isolation, and execution logs must align with actual risk. Hermes' advantage is that its runtime and code are inspectable and modifiable, letting enterprises set execution policies per their environment. Open source alone does not auto-create a complete security posture; identity management, privilege separation, auditing, and disaster recovery still need concrete implementation and validation. A production-ready agent must balance task completion with operational risk; Hermes supplies configurable pieces, but the reliability and governance required for enterprise deployment remain to be proven.

05 Hermes Sells a Continuously Controllable Agent System

Viewing architecture, Memory, Skills, and tool permissions together clarifies Nous Research's commercialization path. Enterprises can select the base model, arrange task runtime environments, integrate existing business tools, and store agent-accumulated knowledge and methods in systems they maintain. When model capabilities, service pricing, or business needs shift, teams can swap individual components without rebuilding entire workflows each time . This is the core enterprise value Hermes targets.

Unlike buying a generic Q&A assistant, enterprises must continuously operate an agent workspace connected to their own systems. Models will keep upgrading, but internal tools, permission rules, task flows, and validated operational experience need long-term usability. This logic explains why Nous Research launched Hermes for Businesses after the open-source version gained traction: the open edition attracts developers to build apps and workflows; the enterprise product can then monetize around deployment, security, org management, and ongoing services — though the article notes official enterprise-product details remain limited and potential commercial capabilities should not be treated as already delivered.

From a buyer's perspective, Hermes fits specific conditions. If a company only needs a general information assistant, wants quick deployment, and has no appetite for maintaining agent infrastructure, a managed service is more direct. If the organization already has many internal APIs, data systems, and complex workflows, wants model flexibility, and possesses independent deployment and ops capability, an open Agent Runtime like Hermes warrants evaluation. Greater control brings greater responsibility: the enterprise must handle deployment, monitoring, incident response, security auditing, version upgrades, and skill management. Model inference costs may drop, but overall engineering costs may not fall in step .

Currently, Nous Research has not published detailed, independently verifiable enterprise production cases proving Hermes' superiority in task success rates, long-term stability, or total cost of ownership. Published download, clone, and token-usage metrics cannot substitute for those production indicators . The most valuable validation for prospective adopters 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 the benefits of retaining agent-system control outweigh the added engineering burden.

The $90 million round gives Nous Research resources to scale and sharpens Hermes' trajectory from developer tool to enterprise market. Its enterprise value is straightforward: let organizations 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.