Article summary — original
NVIDIA NemoClaw Architecture for Building Memory-Driven Enterprise Agents
NVIDIA outlined a system design using NVIDIA NemoClaw and NVIDIA OpenShell to create a memory-driven Chief of Staff agent that leverages persistent context, separates knowledge from execution, and maintains strict runtime governance.
The system separates raw evidence, structured knowledge stored in a Markdown 'self model', and agent judgments tracked in a SQLite ledger.
An intent gate prioritizes tasks based on stated user goals rather than incoming urgency, while an append-only audit trail records user corrections to update readable preference policies.
Benchmark evaluations using NVIDIA Nemotron 3 Ultra showed the self model increased overall accuracy to 90.9% from an 82.8% agentic RAG baseline, including a 40 percentage point boost in tracking changing facts.
Runtime security is enforced via NVIDIA OpenShell sandboxing, which isolates credentials and enforces file, process, and network boundaries independently of agent context.
Structuring Memory and Separating Knowledge from Action
Enterprise agents require continuous context rather than fleeting conversation history. NemoClaw achieves this through a human-readable 'self model' composed of structured Markdown pages that catalog people, projects, priorities, and recurring patterns without overwriting source evidence. A separate SQLite ledger logs obligations, rankings, corrections, and audit events. This three-layer design—evidence, knowledge, and governed execution—ensures context guides recommendations without directly granting authorization to execute actions like sending messages.
Intent-Based Prioritization and User Correction Loops
Incoming communications frequently present artificial urgency that diverges from user priorities. NemoClaw employs an intent gate to rank tasks according to explicitly stated user goals, placing quiet high-priority tasks above ostensibly urgent requests like expense attestations. When an agent errs, users can re-tier or dismiss obligations; each intervention enters an append-only audit trail. Repeated adjustments update a transparent, user-editable preference policy rather than embedding hidden biases into model weights.
Agent Memory Benchmark Performance
Across a 186-question benchmark evaluating NVIDIA Nemotron 3 Ultra, the self model outpaced an agentic multi-round retrieval baseline by raising overall accuracy from 82.8% to 90.9%. It achieved notable improvements in hard questions (87.1% versus 67.7%), point-in-time reasoning (66.7% versus 33.3%), entity disambiguation (86.7% versus 66.7%), and tracking facts that changed over time (100.0% versus 60.0%). Minor regressions occurred in single-hop lookups (83.3% versus 86.7%) and faithful corpus answering (92.3% versus 100.0%).
Runtime Boundaries and Implementation Scope
Because agent memory constitutes unverified input rather than trusted policy, execution safety relies on NVIDIA OpenShell. OpenShell confines the agent within an isolated sandbox and regulates file, process, and network permissions, keeping Model Context Protocol and inference credentials outside the runtime. An open-source Hermes profile recipe is available in the NVIDIA/nemoclaw-community repository with synthetic data and offline walkthroughs to test ranking and memory logic before integrating live enterprise connectors.
Saved original article
Enterprise work spans messages, decisions, projects, and obligations that change over time. An
AI agent
that starts without this context must reconstruct it before contributing.
To provide agents with this necessary context, our team used
NVIDIA NemoClaw
to build a
memory-driven Chief of Staff
. It maintains a human-readable knowledge layer called the
self model
: an agent memory of relevant people, projects, priorities, and working patterns. Scheduled jobs periodically review new activity, track obligations, and incorporate user decisions over time. Our experience shows that useful agent memory requires structure, selective retrieval, and governance—not just storage.
This post demonstrates how a memory-driven agent built with NVIDIA NemoClaw can improve productivity in real-world enterprise workflows. It also shares five design lessons you can apply to your own agents:
Maintain context across daily work to improve task quality
Separate evidence, knowledge, and actions to help agents make better judgments
Design memory-driven agents can prioritize user intent over short-term urgency
Allow users to correct agent decisions to build trust
Enforce the boundary of security and authorization with
NVIDIA OpenShell
Maintain context across daily work
Conversation history provides short-term continuity, but it mixes current priorities with past decisions and temporary requests. Retrieval can find relevant source material, but the agent must still connect information across time.
Consider a project status question. The answer might depend on an earlier decision, a correction in a later message, an unresolved obligation, and the knowledge that two different names refer to the same project.
To solve these problems, you can use the self model that maintains these relationships in structured Markdown pages. It organizes information about people, projects, priorities, goals, concepts, and recurring work patterns. Its schema defines indexing, cross-references, provenance, and growth limits.
The self model stores a derived interpretation rather than replacing source evidence. Keeping the two separate helps you, the developer, determine whether an incorrect answer came from the evidence, memory maintenance, retrieval, or the model’s final decision.
Separate evidence, knowledge, and action
You could use the three layers of tuning capabilities from the memory-driven Chief of Staff:
Evidence → Knowledge → Governed execution
Evidence supports updates to the self model. For each task, the agent retrieves a bounded set of relevant context. The agent then uses that context within the NVIDIA NemoClaw example. The architecture is shown in Figure 1.
Figure 1. NVIDIA NemoClaw uses persistent context for governed agent actions
The example stores two kinds of information:
Knowledge
: People, projects, priorities, and working patterns
Judgment
: Whether an item needs attention, where it ranks, and whether the user ignored it
A Markdown agent memory stores knowledge. A SQLite ledger stores obligations, rankings, corrections, and audit events. This design preserves the agent’s judgments without writing them into source messages as read flags, labels, or folders.
A memory page might say that a collaborator prefers Slack. The agent can use that context to recommend Slack, but sending a message still depends on credentials, tool permissions, runtime policy, and user approval.
Context can inform an action, but it cannot authorize one.
Prioritize user intent over short-term urgency
Incoming requests often describe themselves as urgent, but urgency does not necessarily reflect the user’s priorities. An intent gate therefore reserves the highest tier for obligations connected to the user’s stated priorities.
In the public recipe provided, an urgent expense-policy attestation remains visible but ranks below a quieter request tied to a stated priority. Your NVIDIA NemoClaw could interpret that relationship, while deterministic code enforces tier size, overflow behavior, and ranking order.
Allow users to correct the agent
Persistent memory can preserve an incorrect judgment as easily as a correct one. Using the recipe, you could move an obligation to another tier or ignore it, and later agent runs preserve that decision. Each change is recorded once in an append-only audit trail.
Repeated correction patterns can update a small, readable preference policy. Users can inspect, edit, or delete that policy instead of leaving the preference hidden in model state.
The feedback loop remains visible:
Agent judgment → User correction → Audit event → Preference update
Add memory to improve agent task performance
Adding the memory-driven Chief of Staff to NemoClaw produced measurable improvements across several agent tasks, as shown in Table 1. The
Agent Memory Benchmark
and evaluation examples are included in the example repo. The example repo compares an agentic
retrieval-augmented generation (RAG)
baseline that performs multi-round retrieval with the self model.
Metrics
Question counts
Agentic RAG baseline
Self model
Difference
Overall accuracy
186
82.8%
90.9%
+8.1 pp
Hard questions
31
67.7%
87.1%
+19.4 pp
Tracking facts that changed over time
5
60.0%
100.0%
+40.0 pp
Point-in-time reasoning
6
33.3%
66.7%
+33.3 pp
Entity disambiguation
15
66.7%
86.7%
+20.0 pp
Multisource synthesis
73
87.7%
94.5%
+6.8 pp
Answered faithfully based on Corpus
13
100.0%
92.3%
-7.7 pp
Single-hop lookup
30
86.7%
83.3%
-3.3 pp
Citation coverage
186
92.5%
97.8%
+5.4 pp
Table 1. Evaluation metrics for the agentic RAG baseline and the self model in the example repo. Both configurations use NVIDIA Nemotron 3 Ultra
Enforce the boundary at runtime
This separation is enforced with NVIDIA NemoClaw and the NVIDIA OpenShell secure runtime for autonomous agents. NemoClaw integrates the example with NVIDIA OpenShell and manages its lifecycle, while NVIDIA OpenShell runs the agent in a sandbox and provides governance and policy enforcement for file system, process, and network access. For managed inference and MCP connections, credentials remain outside the sandbox.
This is important because memory and retrieved content are inputs to the model, not trusted security policy. If the agent misinterprets that context—or follows malicious instructions—it still operates within operator-defined runtime boundaries. They limit the agent’s access and the potential impact of a failure.
Get started building agent memory
To adapt the memory design featured in this post for your own NemoClaw example, review the open source
Memory-Driven Chief of Staff recipe
and its
design proposal
in the NVIDIA/nemoclaw-community GitHub repo.
The recipe packages the example as a deployable Hermes profile for NemoClaw:
A structured memory schema
A durable obligation ledger
Bounded ranking logic
User correction and audit paths
Scheduled memory maintenance
Synthetic messages and memory pages
An offline walkthrough
A suite of unit tests
The sample people, organizations, projects, and messages are invented. Recorded model decisions stand in for inference in the offline walkthrough. The code then applies the ranking, correction, persistence, and validation behavior.
The current recipe focuses on the memory foundation. It does not send messages or modify source systems. This scope allows you to examine the design without connecting a workplace account. Live connectors require separate handling for credentials, privacy, retention, and deletion.
Learn more about
NVIDIA NemoClaw
and
NVIDIA OpenShell
.