--- title: "NVIDIA and Nous Research's NemoClaw Builds AI Agents That Actually Learn Over Time" subtitle: "NVIDIA's NemoClaw blueprint pairs Hermes Agent with a sandboxed runtime so enterprise AI agents learn and improve from every team interaction" url: "https://alphasignal.ai/news/nvidia-and-nous-research-s-nemoclaw-builds-ai-agents-that-actually-learn-over" author: "AlphaSignal Newsroom" author_url: "https://alphasignal.ai/editorial-team" company: "NVIDIA AI" company_url: "https://alphasignal.ai/company/nvidiaai" published: "2026-06-02T18:00:09.000Z" updated: "2026-06-16T20:30:41.072Z" type: "News" topics: - "Agents" - "Post Training" subtopics: - "Agent Frameworks" - "Rl" - "Alignment" upvotes: 541 read_time: "6 min" source_url: "https://x.com/nvidiaai/status/2061870499232190967" comments: 0 --- # NVIDIA and Nous Research's NemoClaw Builds AI Agents That Actually Learn Over Time > NVIDIA's NemoClaw blueprint pairs Hermes Agent with a sandboxed runtime so enterprise AI agents learn and improve from every team interaction Most enterprise AI deployments hit the same wall: the agent you deploy on day one is the same agent you have six months later. It doesn't learn your team's preferred report formats, your triage conventions, or the quirks of your internal tooling. Every new session starts from scratch. NVIDIA and Nous Research are taking a direct swing at that problem with the [NemoClaw blueprint for Hermes Agent](https://developer.nvidia.com/blog/deploy-self-evolving-agents-for-faster-more-secure-research-with-a-hermes-agent-and-nvidia-nemoclaw/), a fully open-source stack that lets agents accumulate reusable skills over time, all inside a policy-enforced security sandbox. ## The core idea: skills, not retraining What mainly grows is not model weights, but skills for reusing business procedures and output formats. That distinction matters enormously. This isn't a system that fine-tunes itself in production, which would be both expensive and unpredictable. Instead, good procedures taught by humans are preserved as skills, and combined with memory and session search for use in future sessions. The agent learns preferences and patterns, writing new memories and skills. The more users work with the agent, the better it gets. Concretely, when you teach Hermes a specific output format through a chat conversation, it writes a `SKILL.md` file to disk. That file has a YAML frontmatter with a name and description, plus the full format scaffolding as the body. It persists across deployments and can be read, edited, or shared by humans. ## Three layers that make it work The architecture is cleanly split into three concerns: - **Model layer:** Uses NVIDIA Nemotron and compatible open models for reasoning, summarization, and task automation. The default is `nvidia/nemotron-3-super-120b-a12b`, but Hermes Agent runs unchanged against a self-hosted NVIDIA Nemotron model on NVIDIA NIM, or vLLM when traffic must stay on-prem. - **Harness layer (Hermes Agent):** Handles team requests, coordinates planning and reasoning, and returns task-ready responses in shared workspaces. This is where skills, memory, and session search live. - **Runtime layer (OpenShell):** Controls which files and networks the agent is allowed to access. Critically, this is enforced at the network proxy level, not via prompting. The security model deserves special attention. AI agents are a powerful tool for synthesizing data to accelerate research, summarize information, and help teams make decisions faster. But combining internal data with public sources poses security challenges. OpenShell solves this with a `policy.yaml` that declares every allowed destination, port, HTTP verb, and binary. If the agent tries to reach a host not on the allowlist, the proxy returns a 403 and Hermes treats it as a tool error. The agent never even sees the Slack or Outlook tokens , authentication happens as requests exit the sandbox proxy. ## Memory is not a monolith One of the more thoughtful design decisions is how Hermes separates its different types of persistent state. There are three distinct mechanisms, each with a specific role: - **Skills:** Reusable procedures, output formats, investigation workflows. Stored as `SKILL.md` files with supporting scripts and templates. Narrow and actionable. - **Memory:** Stable knowledge injected into every session's system prompt as a frozen snapshot. Things like user preferences, environment facts, and long-lasting conventions. Broad and declarative. - **Session search:** A SQLite database with an FTS5 full-text index of past conversations. Searched on demand, with no LLM calls involved in retrieval. This division means the agent doesn't try to cram everything into a single growing context. Procedures go in skills, stable knowledge in memory, and past context gets retrieved only when needed. ## Skill governance in v0.16.0 Hermes Agent 0.16.0 was recently released. It included updates around skills covering how to fold growing skills, how much to trust growing skills, and how far to let things run autonomously. The key additions address a real operational problem: skills that accumulate without governance become noise. The new release introduces: - **Environment filters:** Skills can declare which runtime environments they're relevant to via a frontmatter `environments:` field. Skills irrelevant to the current context are hidden from the agent's skill list, but can still be force-loaded explicitly. - **A curator:** Automatically archives skills that haven't been used within a configurable inactivity period. Even built-in bundled skills can be pruned by default, with a suppression list preventing them from reappearing after a `hermes update`. - **Trust tiers for skill sources:** Skills from trusted repositories (including `NVIDIA/skills`, `openai/skills`, `anthropics/skills`, and `huggingface/skills`) get different install policies than community-sourced skills. Trusted sources allow cautionary skills; community sources block anything beyond safe. - **Injection detection:** The skill scanner checks for invisible Unicode characters , zero-width spaces, bidirectional control characters , as signs of prompt injection embedded in skill content. ## Autonomous operation: capable but conservative by default Hermes supports multi-agent delegation, where a parent agent spawns child workers to parallelize tasks. But the defaults are deliberately flat. Child agents are leaves by default and cannot spawn further workers. Going deeper requires explicit configuration, and the comment in the code is direct: deeper trees multiply API costs, so the default stays at depth 1. There's also a `goal_mode` for persistent objectives: a small judge model evaluates after each turn whether the goal has been satisfied, and if not, feeds a continuation prompt back into the session. The loop terminates when the goal is met, the turn budget is exhausted, the user pauses it, or a new message arrives. That agent runs within the policy boundaries of OpenShell. Personally, this direction is the most practical approach for growing agents in an enterprise setting. ## Getting started This post shares an open source example using Hermes Agent with NVIDIA NemoClaw for product research across Outlook, Slack, and GitHub. The full example is in the [NemoClaw Community repository](https://github.com/NVIDIA/nemoclaw-community) and can be stood up with three commands: ``` git clone https://github.com/NVIDIA/nemoclaw-community.git cd nemoclaw-community/examples/personal-community-sentiment-triage curl -LsSf https://raw.githubusercontent.com/NVIDIA/OpenShell/main/install.sh | OPENSHELL_VERSION=v0.0.38 sh ``` You'll need a `build.nvidia.com` API key, a Docker daemon, and credentials for at least one messaging integration (Slack or Outlook). Hermes Agent runs unchanged against a self-hosted NVIDIA Nemotron model on NVIDIA NIM, or vLLM when traffic must stay on-prem. Nous Research has been inducted into the Nemotron Coalition of leading AI labs working with NVIDIA to advance open frontier foundation models. In honor of this, they've partnered with Nebius to provide Nemotron 3 Ultra free on Nous Portal for two weeks. You can try the full stack via the [Hermes Agent desktop app](https://hermes-agent.nousresearch.com/docs/guides/run-nemotron-3-ultra-free) on macOS or Windows with no terminal required. ## What this unlocks While the integration points are specific to this use case (Slack, Outlook, and GitHub), the pattern of safely mixing public and private data in a self-improving agent is important for many use cases, including sales research, customer support, engineering triage, competitive analysis, and internal knowledge discovery. The deeper shift here is architectural. The field has been converging on RAG (retrieval-augmented generation) and fine-tuning as the two levers for making models more useful in specific domains. NemoClaw proposes a third path: a harness-level skill layer that accumulates organizational knowledge as human-readable, version-controllable files, governed by a runtime that enforces security boundaries in code rather than in prompts. Whether that pattern holds up at scale is the open question, but the design is grounded enough to be worth watching closely. ## Sources - [X post by @nvidiaai](https://x.com/nvidiaai/status/2061870499232190967) - [Deploy Self-Evolving Agents for Faster, More Secure Research with a Hermes Agent and NVIDIA NemoClaw | NVIDIA Technical Blog](https://developer.nvidia.com/blog/deploy-self-evolving-agents-for-faster-more-secure-research-with-a-hermes-agent-and-nvidia-nemoclaw/) - [I tried reading the self-improving of Hermes Agent from the code | DevelopersIO](https://dev.classmethod.jp/en/articles/hermes-agent-self-improving-code-reading/) - [NemoClaw for Hermes Agent Blueprint by NVIDIA | NVIDIA NIM](https://build.nvidia.com/nvidia/nemoclaw-for-hermes-agent/architecture) - [Run Nemotron 3 Ultra free in Hermes Agent | Hermes Agent Docs](https://hermes-agent.nousresearch.com/docs/guides/run-nemotron-3-ultra-free) - [How We Built Self-Evolving Hermes Agents With NVIDIA NemoClaw - YouTube](https://www.youtube.com/watch?v=NGfvTlU2T5E)