NeMo Relay Context Isolation
Keeps NeMo Relay scope stacks independent across concurrent requests and async workflows while preserving ancestry propagation.
The skill explicitly requires an independent scope stack per request and explains propagation risks across async, thread, goroutine, and worker boundaries. It requests no credentials or external operations, and no malicious behavior is visible. Points are deducted because it does not specify sensitive input/output redaction, user confirmation, rollback, dependency security, or failure isolation, and the supplied repository-level license metadata is NOASSERTION and not fully reconciled with the stated license.
The Python, Rust, Go, and Node.js guidance is internally consistent and identifies event mixing, middleware leakage, and missing active scopes as failure symptoms. Points are deducted for the absence of version constraints, runnable examples, edge-case handling, exception behavior, and diagnosable failure messages; the static-review ceiling also limits the score.
The description and trigger conditions are clear, covering concurrent requests, async tasks, threads, workers, goroutines, and multi-agent systems, with language-specific APIs. Points are deducted because non-fit scenarios, input/output boundaries, API compatibility, and Chinese-language guidance are not specified. The core guidance does not depend on an overseas service, so no additional mainland-China reachability deduction is warranted.
SKILL.md is concise and organized around core rules, language defaults, common failures, and related skills, and states Apache-2.0; the skill card adds owner, version, geography, and risk information. Points are deducted for missing recommended Instructions and Examples sections, incomplete installation/dependency notes, no FAQ or changelog, and no clear maintenance responsibility or update path. The benchmark also reports schema and author-format findings.
The content directly addresses concurrent NeMo Relay scope isolation and names the key APIs and failure modes for several languages, so it can cover the core advisory task. Points are deducted because it lacks complete examples, validation steps, and directly reusable implementations; users must still adapt the advice to their Relay version and runtime. The supplied benchmark report cannot exceed the static-review ceiling.
The fixed revision, SKILL.md, evaluation tasks, benchmark metrics, and Tier 1 findings provide some auditability, while evals.json states expected behaviors. Points are deducted because there is no skill-specific committed test suite, CI coverage, or independently reproducible execution evidence; the benchmark results cannot be independently verified from this static review.
- Do not share one mutable scope stack across unrelated concurrent work; this can mix event ancestry and leak scope-local middleware.
- Before crossing async-task, goroutine, thread, or worker boundaries, verify the propagation semantics and API for the deployed NeMo Relay version; the skill provides no runnable example or validation procedure.
- Scope inputs and outputs may contain business data, so establish redaction and data-minimization rules before recording payloads.
What does this skill do, and when should you use it?
This skill guides applications that run concurrent requests, worker threads, async tasks, goroutines, or multiple agents in one process. It treats scope-stack ownership as part of the request boundary so unrelated work does not share mutable state. The guidance covers nested scopes, event parentage, scope-local middleware, and stack-management approaches for Python, Rust, Go, and Node.js. It fits NeMo Relay integrations that need request-level telemetry and behavior isolation.
Guides agents to create an independent scope stack for each request, agent, or workflow; explains root and child scope structure and standard types including Agent, Function, Tool, Llm, Retriever, Embedder, Reranker, Guardrail, Evaluator, Custom, and Unknown; describes context propagation; identifies the relevant stack-management helpers for Python, Rust, Go, and Node.js; and helps diagnose incorrect event ancestry, leaking scope-local middleware, and lost context across asynchronous execution boundaries.
- A developer handles multiple concurrent requests in one process and must prevent events from appearing under one root UUID.
- A team uses async tasks, worker pools, or threads and needs each unit of work to inherit the correct scope ancestry.
- An engineer builds a multi-agent application and needs each agent run to have its own scope stack and local middleware.
- A maintainer of a Python, Rust, Go, or Node.js NeMo Relay integration needs to choose task-local or explicit context propagation.
- An engineer investigates scope loss after crossing thread, goroutine, async-task, or JavaScript worker boundaries.
What are this skill's strengths and limitations?
- Targets a clearly defined problem: scope isolation across concurrent requests and workflows.
- Provides language-specific direction for Python, Rust, Go, and Node.js.
- Enumerates common failure modes for event ancestry and middleware leakage.
- Uses no Claude Code- or Codex-specific extensions, supporting portable Agent Skills clients.
- Provides instructional SKILL.md content only, with no scripts, complete code, or test suite.
- Does not specify version requirements, installation dependencies, or full initialization configuration.
- Focuses on NeMo Relay scope propagation rather than broader observability deployment or business logic.
How do you install this skill?
Install the specific skill with the skills CLI command supported by the repository README:
npx skills add nvidia/skills --skill nemo-relay-instrument-context-isolation --yes
The CLI prompts for the skill and installation destination. The source does not specify a fixed local directory or additional dependencies.
How do you use this skill?
After installation, ask an agent to handle a context-isolation task, for example: “Design independent ScopeStack ownership for this NeMo Relay Go service using goroutines, and preserve request ancestry propagation.” The application must still use the runtime helpers listed in SKILL.md for its language; the source does not provide a complete project configuration or runnable example.