Nous Research's $90M Bet: Open-Source Hermes Agent Targets Enterprise AI Control

Funding and Market Entry

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 , aiming to move 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.

Why Move from Personal Assistant to Enterprise?

Nous Research, founded in 2023, initially focused on open models, post-training, and tool-use research (e.g., YaRN for long context). In February 2026 they released the Hermes Agent under the MIT license. For individual users, Hermes offered flexibility: tasks via terminal, Telegram, Discord, Slack; tool calls for files, browser, code execution; model provider choice; and local or remote deployment.

For enterprises, that flexibility translates into architectural and maintenance concerns. The article illustrates: 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 may require rewriting the entire workflow ; if components are independent, the team mainly re-adapts the model interface and re-validates task outcomes. Hermes's design favors the latter, making the model a configurable component while tools and runtime remain separate.

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

Decoupling Model and Execution System

According to official developer docs, Hermes comprises:

Multiple interaction entry points (CLI, messaging gateway, API)

A shared AI Agent core

Model service integration layer ( Provider Resolution )

Tool system with independent registration

Session storage

All entry points invoke the same agent execution logic. Provider Resolution determines model provider, API schema, auth, and endpoint. Tools (terminal, filesystem, browser, external MCP services) are managed via independent registration. Models can be swapped without touching the tool system; new tools can be added without modifying the model.

Hypothetical execution flow (constructed from the architecture): A developer asks Hermes via Slack to check a code repo. The Messaging Gateway receives the message, verifies authorization, and locates the session. The AI Agent reads context, builds 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. On completion, the session is saved and the result is sent back via Slack.

This separation gives enterprises wider model choice. Example: an internal data-analysis agent already wired to database query, Python execution, and report-generation tools. The team can test different models against task complexity, latency, token cost, and tool-call success rate, selecting the best fit without locking the entire pipeline to one vendor . However, the article cautions that model swap does not guarantee identical performance — multi-step tool parameter understanding, failure recovery, and context handling vary — so re-evaluation is still required .

Execution environments are also configurable backends: local, Docker, SSH, Daytona, Modal . This matters for enterprise workloads that must connect to internal data systems or run untrusted code, allowing teams to match deployment to network, compute, data-access, and isolation requirements. Yet data boundaries are not automatic: if Hermes calls external model APIs, task context may leave the organization. Actual data boundaries depend on model deployment location, tool connections, credentials, and log configuration .

Engineering-wise, Hermes lowers coupling between agent components . Enterprises can adjust models or execution environments while preserving tools and workflows. This doesn't eliminate migration cost but can shrink the scope of each technical change.

Memory and Skills: Turning Business Experience into Maintainable Assets

Beyond model and tools, Memory and Skills determine whether an agent can reuse accumulated work experience. Enterprises hold vast tacit knowledge — which table for a metric, pre-deployment checks, commit conventions, verification steps — scattered across people, docs, scripts, and history.

Hermes handles this via:

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

Full session history in SQLite with FTS5 full-text search . Agents can invoke session_search to retrieve past discussions and executions on demand. Frequent info comes from persistent memory; detailed traces come from history.

Skills — reusable work methods managed via skill_manage. When an agent completes a complex task, discovers a procedure, or incorporates user feedback, it can write the flow into a Skill file for future invocation.

Illustrative scenario (not a published customer case): A Data Agent establishes an analysis flow for a key metric — query prescribed tables, run validation SQL, check business constraints, emit a fixed-format report. The method becomes a Skill; project context goes into Memory. This shows the division: Memory stores facts and context; Skills store executable methods .

File-based knowledge and processes are easier to inspect, modify, and fold into existing engineering practices than ephemeral context. But Hermes's "continuous learning" relies on external memory and Skill updates — not automatic model-weight training — and more experience does not guarantee higher correctness.

Quality control is critical: if an agent saves a fluke success as a general rule, or memory retains stale info, errors propagate. Hermes provides write-approval gates : enabling skills.write_approval puts Skill changes into a pending state for human diff review before application; memory.write_approval does the same for persistent memory. This moves experience accumulation into a human-in-the-loop workflow, letting organizations vet critical steps before they become reusable.

The article notes this could be a differentiated piece of Hermes's enterprise value: organization-maintained knowledge, steps, and tool configs rather than reliance on a model vendor's memory features. Still, file persistence alone doesn't equal reliable knowledge governance — versioning, collaboration, permission inheritance, and rule updates need further design.

Permissions Must Enter Engineering Management

Once agents touch internal systems, permission management dictates what work they can safely do. Hermes connects external tool services via MCP (Model Context Protocol) — databases, filesystems, GitHub, internal APIs — and configures which tools are exposed to the model.

Example: an order system offers query, modify, and delete interfaces. An analysis-only agent gets only the query tool; modifying order state requires combining business-system permissions and approval flows to gate write operations. Hermes's tool configuration narrows the agent's callable operation set . Official security docs also provide: messaging-platform user allowlists, DM 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 explicitly state these limits only constrain those file tools. If the agent also has 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 doesn't guarantee safety if the exposed tools themselves hold excessive business permissions.

Enterprise agent adoption thus requires balancing task capability with operational risk. For state-changing tasks, tool permissions, human approval, runtime isolation, and execution logs must match actual risk. Hermes's advantage: the runtime and code are inspectable and modifiable, so enterprises can set execution policies per their environment. But open source alone doesn't auto-create a full security posture — identity management, privilege separation, auditing, and disaster recovery still need concrete implementation and validation.

Enterprise Value Proposition and Selection Criteria

Synthesizing architecture, Memory/Skills, and permissions, Nous Research's commercialization path is clear: enterprises choose the base model, arrange task runtime, plug in existing business tools, and keep agent-accumulated knowledge and methods in systems they maintain . When model capabilities, pricing, or business needs shift, teams adjust components without rebuilding entire workflows each time .

Compared to buying a generic Q&A assistant, enterprises must continuously operate an agent environment connected to their own systems. Models upgrade, 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 open-source traction: open source attracts developers building apps and workflows; the enterprise product can monetize deployment, security, org management, and ongoing services. However, 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 specific conditions:

If an organization only needs a general info assistant, wants quick start, and won't maintain agent infrastructure long-term → managed products are more direct (platform handles deployment, updates, ops).

If the org has many internal APIs, data systems, complex workflows, wants model flexibility, and has independent deployment/maintenance capacity → open agent runtimes like Hermes warrant evaluation .

More control means more responsibility: enterprises must handle deployment, monitoring, incident response, security auditing, version upgrades, and Skill management. Model call costs may drop, but overall engineering costs may not fall proportionally .

Currently, Nous Research has not published detailed, independently verifiable enterprise production cases proving Hermes's general 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 considering Hermes, the highest-value validation is: pick one real internal workflow , run it under identical permissions and task conditions, and compare against existing solutions on completion rate, failure recovery, model-switch cost, and maintenance overhead. Only then can they judge whether retaining control of the agent system yields benefits that outweigh the added engineering work.

The $90M funding gives Nous Research resources to scale and clarifies Hermes's trajectory from developer tool to enterprise market. Its proposed enterprise value is straightforward: organizations continuously own their agent runtime, preserving models, tools, and work experience through technical change . Whether that autonomy creates a large enough commercial market depends less on download counts and more 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.