All articles
    nvidia
    nemo
    nemo-agent-toolkit
    agent-frameworks
    context-runtime
    closure-resolution
    mission-runtime
    governance
    reference-implementation
    benchmarks

    NeMo Owns the Agent Loop. ReDevOps Owns the Mission.

    August 31, 2026redevops.io
    NeMo Owns the Agent Loop. ReDevOps Owns the Mission.

    We expected the first problem to be dependency incompatibility. A modern agent toolkit and a separate runtime, both pinning pydantic, numpy, and a web stack, usually do not want to share a process. Instead, the Mission SDK, Closure Resolution, and a real nvidia-nat 1.8.0 agent coexist in one Python environment. Installing the NeMo Agent Toolkit only nudged pandas down a minor version and left torch, numpy, and pydantic untouched. So the integration runs entirely in-process with a genuine NeMo agent: a real nvidia-nat Function, built with WorkflowBuilder and invoked with ainvoke, sitting inside a real ReDevOps Mission. No mock. No sidecar approximation.

    That single fact set the tone for everything else. This is a reference implementation of a specific division of labour, measured honestly.

    What NeMo owns, what ReDevOps adds

    The NeMo Agent Toolkit owns the agent loop, tools, model access, native optimization, evaluation, and telemetry. It is good at those, and we do not re-implement any of them. ReDevOps adds the layer around the agent that has to stay stable when the agent, model, retriever, or application changes:

    NVIDIA NeMo Agent Toolkit          →   ReDevOps Runtime
      agent loop · tools · models            Mission · Context / Closure
      evaluator · telemetry                  Authority · Replay · Verification · Governance
    

    The NeMo agent's own retrieval can even be registered as a Context-Runtime representation the optimizer is allowed to choose, so the framework's strengths are treated as capabilities.

    Three experiments, three different kinds of result

    We ran the top-priority workload from the plan: SciFact + GDPR Closure Resolution, plus a governed action. The point of using three is that they fail differently, and an honest integration should show that.

    Scientific evidence (SciFact). A NeMo agent verifies scientific claims (Supported, Refuted, or NotEnoughInfo) given retrieved evidence. Same model, same token budget, two context sources: naive semantic retrieval versus ReDevOps Closure Resolution. Verification accuracy moves 0.800 → 0.867, evidence recall 0.841 → 0.877, and using the two context views as a cheap ensemble gives selective autonomy of 0.857 at 93% coverage. A real gain, and a modest one, because SciFact is already content-saturated: the evidence is usually textually similar to the claim, so good semantic retrieval already finds most of it.

    Regulatory structure (GDPR). The same closure mechanism, on a structural domain. Editing a GDPR article means considering every article it cross-references, and cross-referenced articles are not textually similar, so content retrieval alone is weak. Content-only closure recall is 0.412; composed closure (content + the cross-reference graph) is 0.913. Here the graph is decisive, and the gain is large.

    That contrast is the honest headline. On a content-saturated task, closure adds a little. On a structural task, it adds a lot. We report both, each result kept separate from one dramatic average.

    Governed action. The third experiment is not about accuracy at all. A NeMo agent proposes a consequential action; the action only runs through a ReDevOps Mission. Without the required grant, the action never executes (zero unauthorized). With the grant but no approval, the Mission parks at a human gate and the side effect stays at zero. Approved once, it fires exactly once. Replay the sealed run and the side effect fires zero additional times, because replay reconstructs from the event ledger and does not re-execute. A stateless re-run would double-charge on every crash; the governed one does not.

    This is the result that matters most for production. The framework decides what to propose. The Runtime decides whether it may run, once, and only with authority, and can prove it afterwards.

    Conformance

    Every comparison is classified into one of five buckets (PARITY, FRAMEWORK_NATIVE_ADVANTAGE, REDEVOPS_DELTA, EXPECTED_IMPLEMENTATION_DIFFERENCE, BUG), so the exercise reads as conformance. Across the NVIDIA suite the findings come out as incremental runtime value with no unexplained divergence, and the one non-delta is exactly what it should be: telemetry differs in shape (NeMo's spans nest under the Mission causal node) but the semantics are preserved. That is an EXPECTED_IMPLEMENTATION_DIFFERENCE.

    The template

    Because the substance lives in a small, provider-neutral core (a result-classification enum, a Workflow Adapter Contract, and a reproducibility bundle) the NVIDIA integration is the template the rest of the program follows. PydanticAI, LlamaIndex, CrewAI, and the hyperscaler managed stacks each become a new adapter against the same contract, with their own flagship workload, on the same architecture. A small provider-neutral Mission is reserved for semantic-portability conformance only, never to rank frameworks against one another.

    The reference implementation, the exact results, the environment, and the reproduce commands are public. The claim we are willing to stand behind is narrow and true: a real NeMo agent, governed by rAIls, keeps everything NeMo is good at and adds closure-aware context and governed Mission semantics around it, measured, classified, and reproducible.

    Want ReDevOps in your Google Top Stories & AI results?Follow ReDevOps on Google