Nemo Mbridge Perf Activation Recompute

NVIDIAOfficialPublished by NVIDIA

Skill
Guidelines
Software development
Apache-2.0
Medium risk

From the author

Validate and use selective and full activation recompute in Megatron Bridge to reduce GPU memory usage at the cost of extra compute. Use for activation memory OOMs or regressions involving recompute_granularity, recompute_num_layers, recompute_modules, recompute_method, selective recompute, full recompute, or activation checkpointing.

— the description by NVIDIA

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides a structured approach to managing GPU memory pressure in Megatron Bridge by implementing activation recomputation (checkpointing). By trading additional compute cycles for reduced memory footprint, users can resolve out-of-memory (OOM) errors. The guide emphasizes a data-driven, iterative process of selecting specific module boundaries based on model architecture—such as standard attention, MLA, or MoE—and validating results through matched measurements of peak memory and throughput.

What it does

Provides a decision framework for choosing between selective and full-layer activation recomputation.
Lists specific module boundaries for various architectures including MLA, MoE, and dense MLP.
Defines a rigorous measurement contract to ensure performance impact is accurately tracked.
Outlines compatibility constraints with features like CUDA graphs, FP8, and expert-parallel overlap.
Offers a diagnostic table to troubleshoot common OOM scenarios and recompute failures.
Provides configuration examples for both selective module lists and full-layer uniform/block methods.

When to use it

When encountering GPU memory OOM errors during model training.
When memory usage needs to be reduced to fit larger batch sizes or longer sequences.
When investigating performance regressions related to activation memory.
When evaluating the trade-off between memory capacity and compute throughput for a specific model architecture.

Advantages

Reduces peak GPU memory allocation by discarding intermediate activations.
Allows for fine-grained control over which model components are recomputed.
Provides architecture-specific guidance to minimize the compute penalty of recomputation.
Includes a structured validation process to avoid misleading performance conclusions.

Usage examples

“How do I enable selective recomputation for a standard attention model?”: The agent will provide the configuration snippet setting recompute_granularity to selective and suggest starting with core_attn as the module boundary.
“I am getting OOMs in an MoE model; which recompute modules should I test?”: The agent will recommend testing moe_act or layernorm first, and only moving to whole-moe recompute if narrower boundaries fail to resolve the memory pressure.

Install

Download the skill as a ZIP:
https://mp-staging.autogineer.com/agent-skills/nvidia/nemo-mbridge-perf-activation-recompute/download

Unzip it into the cross-client skills folder of your project:

mkdir -p .agents/skills && unzip nemo-mbridge-perf-activation-recompute.zip -d .agents/skills

Documentation by NVIDIA

Activation Recompute

Stable docs: @docs/training/activation-recomputation.md Card: @skills/nemo-mbridge-perf-activation-recompute/card.yaml

Activation recompute (activation checkpointing) trades additional forward work during backward for lower retained-activation memory. The useful checkpoint boundary depends on the model architecture, attention backend, parallelism, and the tensor that actually drives the per-rank peak.

Quick Decision Guide

Confirm the pressure is real allocation, not allocator fragmentation. Compare max_memory_allocated() with max_memory_reserved() on every rank.
Keep an explicit no-recompute control when the workload fits. Under selective granularity, recompute_modules=[] is valid and useful for this comparison.
Select the first boundary from the architecture and observed peak:
- Standard attention: core_attn is the common first candidate. It is strongest when unfused attention materializes score/probability tensors. With Transformer Engine fused or Flash Attention, compare it against [] because those backends already rematerialize attention internals.
- Multi-Latent Attention (MLA): start with mla_up_proj when expanded Q/K/V projections dominate. Add core_attn only when the attention-core state still matters.
- Grouped MoE: start with moe_act when the expert intermediate activation dominates; add layernorm when norm outputs are material. Use whole moe recompute only after accounting for the extra expert compute and communication it replays.
- Dense FFN: mlp can save the whole dense-MLP activation region, but it usually costs more compute than a narrow output-discard boundary.
Change one label at a time. Record per-rank allocated/reserved peaks plus steady-state step time or throughput; do not infer a global module ranking from one recipe.
Use full-layer recompute only when targeted selective boundaries do not make the workload fit. Full recompute has the broadest memory effect and the largest replay cost.
Treat CUDA graphs, FP8, context-parallel communication, and overlap features as compatibility constraints, not afterthoughts.

Megatron Core's cpu_offloading=True is an alternative when PCIe/NVLink transfer overhead is preferable to replayed compute. It cannot be combined with activation recompute and is not compatible with pipeline parallelism greater than one.

Enablement

Selective recompute

cfg.model.recompute_granularity = "selective"
cfg.model.recompute_modules = ["core_attn"]  # Common standard-attention candidate, not a universal default.

Use the decision table below to replace or extend that list for MLA, MoE, dense-MLP, or GDN workloads.

Full-layer recompute

cfg.model.recompute_granularity = "full"
cfg.model.recompute_method = "uniform"
cfg.model.recompute_num_layers = 1

uniform: checkpoint fixed groups of recompute_num_layers transformer layers.
block: checkpoint the first recompute_num_layers layers on each pipeline stage, with virtual-pipeline-aware distribution.

Selective Module Decision Table

The currently pinned Megatron Core accepts these labels. A development branch can add model-specific labels, so validate against the exact target revision rather than copying a list across branches.

Module	Checkpoint boundary	When to test it	Main cost or caveat
`core_attn`	Core attention	Standard attention, especially an unfused backend retaining attention intermediates	Replays attention. Incremental savings can be small with TE fused/Flash Attention; context parallelism can replay attention communication.
`mla_up_proj`	MLA Q/KV up-projection plus RoPE region	MLA models retaining expanded Q/K/V tensors	Replays the MLA expansion path. It is a distinct, potentially additive boundary from `core_attn`.
`layernorm`	Input and pre-MLP normalization outputs	Norm outputs contribute materially to the peak, often alongside MoE or MLA boundaries	Usually narrow, but savings depend on hidden size, sequence length, and which graph paths are active.
`moe_act`	Activation output between grouped expert FC1 and FC2	Grouped MoE expert-intermediate activations dominate	Narrow output-discard checkpoint. It does not replay dispatch, FC1, or FC2, but has FP8 delayed-scaling restrictions.
`mlp`	Whole dense MLP	Dense layers dominate after narrower boundaries are exhausted	Replays the complete dense MLP. It has no effect on layers whose MLP is MoE.
`moe`	Whole MoE forward	A broad MoE region must be discarded to make the workload fit	Replays routing, dispatch/combine communication, experts, and shared-expert work. It is incompatible with expert-parallel overlap.
`shared_experts`	Non-overlapped shared-expert MLP	Shared experts are a distinct material peak	Replays the shared-expert MLP and is invalid with shared-expert overlap. Outer `moe` already removes its original-forward saves, but nesting can still change the transient backward-replay peak.
`gdn_norm_out`	GDN gated-normalization output	GDN/hybrid models retain this output	Replays the normalization and its HP-to-CP all-to-all path.

For example, DeepSeek V4 configurations can use the model-specific mhc label only with their required Megatron Core development branch. It is not a portable label for the pinned revision and therefore is not included in the table above.

Common performance configurations consequently fall into several patterns rather than one universal list:

standard transformer recipes often use core_attn;
MLA recipes often use mla_up_proj, sometimes with mlp;
grouped-MoE recipes often use moe_act or layernorm plus moe_act;
higher-pressure MoE recipes sometimes use broader combinations such as moe plus layernorm.

These are candidate patterns, not an ordering guarantee. Peak attribution and matched measurements decide the final list.

Measurement Contract

For every candidate, capture:

exact Bridge and Megatron Core revisions;
model, sequence length, micro/global batch sizes, precision, attention backend, and parallelism;
the exact recompute_granularity, module list, method, and layer count;
per-rank max_memory_allocated() and max_memory_reserved();
steady-state step time or throughput after warmup;
a short convergence or numerical-sanity check appropriate to the task.

Use a matched no-recompute control and change one recompute choice at a time. Peak memory from different jobs, backends, or parallel layouts is not a module-ranking benchmark.

Do not call a candidate successful merely because it advances farther than the control. Run through optimizer-state initialization and multiple steady-state steps: selective recompute can move the memory wall from forward into gradient synchronization or the optimizer without making the workload viable.

Matched H100 Evidence: Moonlight 16B

A 2026-08-12 short-run study used the exact Bridge revision 600d069b824dd5ce50367a311a5a3244478faf22 and Megatron Core revision 24bad8e677d22625d86ef2a54c9506b6e4992c93. The Moonlight 16B BF16 pretraining recipe ran on 8 H100 80GB GPUs with sequence length 4096, MBS=1, GBS=4, TP=2, PP=1, CP=1, EP=8, mock data, and 20 steps. This model mixes one dense layer with 26 MLA+MoE layers. Each row changed only recompute_modules; all 20 losses were finite with zero skipped or NaN iterations.

Peak allocated memory is the maximum post-optimizer value reported after iteration 2. Time and throughput are means over iterations 11--20.

Selective modules	Peak allocated (GB)	Step time (ms)	TFLOP/s/GPU	Allocated vs `[]`	Time vs `[]`
`[]`	36.618	457.18	77.50	control	control
`core_attn`	36.614	474.80	74.44	-0.01%	+3.85%
`mla_up_proj`	35.902	480.89	73.72	-1.96%	+5.19%
`mla_up_proj`, `mlp`	35.917	496.73	71.50	-1.91%	+8.65%
`moe_act`	35.941	466.26	75.50	-1.85%	+1.99%
`layernorm`, `moe_act`	35.949	506.53	70.27	-1.83%	+10.79%

For this exact workload, moe_act is the best first boundary: it recovered nearly as much allocated memory as mla_up_proj for less replay cost. mla_up_proj is the next candidate if its roughly 39 MB additional reduction matters. Adding mlp to mla_up_proj or layernorm to moe_act did not improve the observed peak and made steps slower. Explicit core_attn added cost without material memory benefit under fused attention.

Maximum reserved memory stayed near 40 GB and did not fall monotonically. That is allocator caching, not contrary evidence: boundary selection in this study is based on allocated memory and successful end-to-end steps.

Matched H100 Evidence: Nemotron 3 Nano

The same 2026-08-12 study used the native 16-H100 BF16 performance recipe for the 52-layer hybrid Mamba/fused-attention MoE model. The matched short-run configuration used sequence length 8192, MBS=1, GBS=16, TP=1, PP=1, CP=1, EP=8, DP=16, expert-DP=2, HybridEP, grouped GEMM, TE CUDA graphs for attention and Mamba, mock data, and 12 steps. Each row changed only recompute_modules.

Selective modules	Outcome	Rank-0 measured peak	Failure or steady-state evidence
`[]`	OOM after iteration 1	66.297 GB after iteration 1	Iteration-2 MoE router allocation failed; hot ranks had about 72.9 GiB allocated.
`core_attn`	OOM in iteration 1	not comparable	Grouped-expert linear allocation failed; explicit attention recompute did not make the fused-attention workload fit.
`moe_act`	OOM after iteration 1	62.103 GB after iteration 1	4.194 GB (6.33%) below the control at the matched checkpoint, but the iteration-2 output projection still needed 2 GiB.
`layernorm`, `moe_act`	OOM in iteration 1	not comparable	Output projection still needed 2 GiB; CUDA-graph private pools were material.
`moe`	completed 12 steps	64.653 GB after iteration 2	657.42 ms and 277.72 TFLOP/s/GPU over iterations 7--12.
`moe`, `layernorm`	completed 12 steps	63.639 GB after iteration 2	677.62 ms and 270.62 TFLOP/s/GPU over iterations 7--12.

Both successful rows had finite losses and zero skipped or NaN iterations. For this exact capacity-limited recipe, whole-moe recompute is the smallest tested passing boundary. Adding layernorm recovered another 1.014 GB (1.57%) of rank-0 peak at 3.07% higher step time, so the recipe's broader combination is justified when that headroom is required. Narrow moe_act produced real activation relief but did not make the whole training step viable.

An exploratory native 8-H100 layout failed during FP32 optimizer-state initialization even at sequence length 4096. That is optimizer capacity, not a selective-boundary throughput baseline; no timing comparison from those runs is used here.

Cross-model conclusion

These measurements do not define one ranking. Moonlight fit with an empty control and favored narrow moe_act; Nemotron required broad whole-moe recompute; historical dense Llama evidence found whole-mlp replay costly and lacked an empty control. The correct first candidate is therefore the narrowest boundary implicated by the architecture and peak, followed by broader replay only when the narrow choice does not pass the complete step.

Compatibility and Validation

Configuration semantics

recompute_granularity="selective" uses recompute_modules; an empty list is accepted as an explicit control.
recompute_granularity="full" uses recompute_method and recompute_num_layers; selective labels do not apply.
Full granularity supersedes selective module choices rather than composing with them.
Unknown labels fail Megatron Core validation. Labels may differ on development branches, so use the exact revision's TransformerConfig validator as the source of truth.

Attention backend and context parallelism

TE fused and Flash Attention already use internal rematerialization. Explicit core_attn may still change retained inputs/outputs, but it must earn its place in a matched [] comparison.
Under context parallelism, an attention checkpoint can replay communication as well as compute. Include CP size and topology in the measurement record.

MoE restrictions

Whole-moe recompute is incompatible with expert-parallel overlap because backward replay would repeat the overlapped routing/communication region.
shared_experts recompute is incompatible with shared-expert overlap.
moe_act applies to grouped-GEMM experts and is the narrower choice when only the expert activation needs to be discarded.
mlp targets dense MLPs and is a no-op on MoE layers; mixed dense/MoE models can still benefit on their dense layers.

FP8 restrictions

moe_act and layernorm recompute are not supported with FP8 delayed scaling and require a compatible Transformer Engine version.
Absorbed MLA paths have additional FP8/FP4 restrictions. Validate the exact model/provider path before selecting mla_up_proj.

CUDA graphs

Selective recompute is valid only when a checkpointed module lies wholly inside or wholly outside the selected graph scope. A checkpoint boundary that straddles a graph boundary is invalid.
Capture/warmup can bypass checkpoint wrappers, so verify the final graph scope and replay path rather than assuming eager behavior carries over.
Full recompute with CUDA graphs requires cuda_graph_impl="full_iteration" in the pinned Megatron Core. Otherwise disable CUDA graphs; scoped/local graph capture is not a substitute for full-iteration capture here.

Historical Measurement: Context, Not a Module Ranking

Historical H100 measurements from Bridge PR #3107 used Llama 3 70B SFT on 32 H100 80GB GPUs with FP8 current scaling, sequence length 4096, micro-batch size 1, global batch size 32, TP=4, PP=4, VPP=5, and DP=2:

Configuration	TFLOP/s/GPU	Peak memory
`core_attn` baseline in that run	~704	58.8 GB (OOM on rank 0)
`mlp`	593.6	55.6 GB
`mlp` + `core_attn`	586.8	55.6 GB
`core_attn` + `layernorm`	~702	59.6 GB (OOM on rank 0)
Golden throughput recorded in the PR context	709.93	Not a paired memory measurement

Limitations of this evidence:

it did not include a matched no-recompute row;
the golden row was not a paired module-only comparison;
the measurements cover one dense Llama workload, not MLA or MoE;
the table supports the local memory/throughput tradeoff only and must not be used to rank all recompute labels.

Code Anchors

Selective-label validation and cross-feature checks: 3rdparty/Megatron-LM/megatron/core/transformer/transformer_config.py
Checkpoint implementations: 3rdparty/Megatron-LM/megatron/core/tensor_parallel/random.py
Standard-attention checkpoint boundary: 3rdparty/Megatron-LM/megatron/core/transformer/attention.py
MLA up-projection boundary: 3rdparty/Megatron-LM/megatron/core/transformer/multi_latent_attention.py
Layernorm, dense-MLP, and outer-MoE placement: 3rdparty/Megatron-LM/megatron/core/transformer/transformer_layer.py
Grouped expert activation boundary: 3rdparty/Megatron-LM/megatron/core/transformer/moe/experts.py
Shared-expert and whole-MoE paths: 3rdparty/Megatron-LM/megatron/core/transformer/moe/moe_layer.py
GDN normalization boundary: 3rdparty/Megatron-LM/megatron/core/ssm/gated_delta_net/gdn.py

Failure Diagnosis

Symptom	Likely cause	Next action
`core_attn` gives little or no peak reduction	Fused/Flash attention already rematerializes the expensive internals, or the peak is elsewhere	Compare with `[]`, attribute the peak, then test the architecture-specific boundary such as `mla_up_proj` or `moe_act`.
MLA still OOMs after `core_attn`	Expanded Q/K/V projection tensors, not attention-core tensors, dominate	Test `mla_up_proj`; add `core_attn` only if matched evidence supports it.
MoE peak remains high	Expert intermediate or norm outputs dominate	Test `moe_act`, then `layernorm`; reserve whole `moe` for broader pressure.
Expert-overlap validation fails	Whole-`moe` or `shared_experts` recompute conflicts with overlap	Keep overlap and use a compatible inner boundary, or disable overlap and remeasure the entire configuration.
A selected label has no measurable effect	That module is absent or inactive on the measured layers, or graph capture bypassed the wrapper	Inspect the provider/layer mix and final graph scope; for example, `mlp` is ineffective on pure-MoE layers.
Full recompute plus CUDA graphs asserts	Graph implementation is not full-iteration	Set `cuda_graph_impl="full_iteration"` or disable CUDA graphs.
Reserved memory is high but allocated memory is stable	Allocator fragmentation or caching	Try `PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True` before adding recompute.
OOM moves to a different rank after enabling recompute	Pipeline/virtual-pipeline layer distribution changed the bottleneck	Compare per-rank peaks and tune full block/uniform placement or selective boundaries for the actual hot stage.
A candidate gets farther but still OOMs	Recompute moved the peak into gradient synchronization or optimizer-state initialization	Record the changed failure stage as diagnostic evidence, but require optimizer initialization and multiple steady steps before calling it a pass.

Known Limitations

A module list is not portable across model families, attention backends, parallel layouts, or Megatron Core revisions.
Memory savings are nonlinear when boundaries overlap or nest; additive arithmetic is unreliable.
Full recompute changes RNG execution paths; dropout workloads need a numerical/convergence check.
Activation recompute does not address parameter, optimizer-state, or allocator-fragmentation pressure.
The correct result is the smallest measured replay cost that satisfies the per-rank memory target, not the longest module list.

Files

ATTRIBUTION.mdAdded by AutoGineer875 B
BENCHMARK.md4.8 KiB
LICENSELicence file added by AutoGineer11.2 KiB
SKILL.md18.5 KiB
card.yaml16.5 KiB
evals/evals.json5.3 KiB
skill-card.md4.2 KiB
skill.oms.sig4.7 KiB

LICENSE

Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.


                                 Apache License
                           Version 2.0, January 2004
                        http://www.apache.org/licenses/

   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

   1. Definitions.

      "License" shall mean the terms and conditions for use, reproduction,
      and distribution as defined by Sections 1 through 9 of this document.

      "Licensor" shall mean the copyright owner or entity authorized by
      the copyright owner that is granting the License.

      "Legal Entity" shall mean the union of the acting entity and all
      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
      "control" means (i) the power, direct or indirect, to cause the
      direction or management of such entity, whether by contract or
      otherwise, or (ii) ownership of fifty percent (50%) or more of the
      outstanding shares, or (iii) beneficial ownership of such entity.

      "You" (or "Your") shall mean an individual or Legal Entity
      exercising permissions granted by this License.

      "Source" form shall mean the preferred form for making modifications,
      including but not limited to software source code, documentation
      source, and configuration files.

      "Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,
      and conversions to other media types.

      "Work" shall mean the work of authorship, whether in Source or
      Object form, made available under the License, as indicated by a
      copyright notice that is included in or attached to the work
      (an example is provided in the Appendix below).

      "Derivative Works" shall mean any work, whether in Source or Object
      form, that is based on (or derived from) the Work and for which the
      editorial revisions, annotations, elaborations, or other modifications
      represent, as a whole, an original work of authorship. For the purposes
      of this License, Derivative Works shall not include works that remain
      separable from, or merely link (or bind by name) to the interfaces of,
      the Work and Derivative Works thereof.

      "Contribution" shall mean any work of authorship, including
      the original version of the Work and any modifications or additions
      to that Work or Derivative Works thereof, that is intentionally
      submitted to Licensor for inclusion in the Work by the copyright owner
      or by an individual or Legal Entity authorized to submit on behalf of
      the copyright owner. For the purposes of this definition, "submitted"
      means any form of electronic, verbal, or written communication sent
      to the Licensor or its representatives, including but not limited to
      communication on electronic mailing lists, source code control systems,
      and issue tracking systems that are managed by, or on behalf of, the
      Licensor for the purpose of discussing and improving the Work, but
      excluding communication that is conspicuously marked or otherwise
      designated in writing by the copyright owner as "Not a Contribution."

      "Contributor" shall mean Licensor and any individual or Legal Entity
      on behalf of whom a Contribution has been received by Licensor and
      subsequently incorporated within the Work.

   2. Grant of Copyright License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      copyright license to reproduce, prepare Derivative Works of,
      publicly display, publicly perform, sublicense, and distribute the
      Work and such Derivative Works in Source or Object form.

   3. Grant of Patent License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      (except as stated in this section) patent license to make, have made,
      use, offer to sell, sell, import, and otherwise transfer the Work,
      where such license applies only to those patent claims licensable
      by such Contributor that are necessarily infringed by their
      Contribution(s) alone or by combination of their Contribution(s)
      with the Work to which such Contribution(s) was submitted. If You
      institute patent litigation against any entity (including a
      cross-claim or counterclaim in a lawsuit) alleging that the Work
      or a Contribution incorporated within the Work constitutes direct
      or contributory patent infringement, then any patent licenses
      granted to You under this License for that Work shall terminate
      as of the date such litigation is filed.

   4. Redistribution. You may reproduce and distribute copies of the
      Work or Derivative Works thereof in any medium, with or without
      modifications, and in Source or Object form, provided that You
      meet the following conditions:

      (a) You must give any other recipients of the Work or
          Derivative Works a copy of this License; and

      (b) You must cause any modified files to carry prominent notices
          stating that You changed the files; and

      (c) You must retain, in the Source form of any Derivative Works
          that You distribute, all copyright, patent, trademark, and
          attribution notices from the Source form of the Work,
          excluding those notices that do not pertain to any part of
          the Derivative Works; and

      (d) If the Work includes a "NOTICE" text file as part of its
          distribution, then any Derivative Works that You distribute must
          include a readable copy of the attribution notices contained
          within such NOTICE file, excluding those notices that do not
          pertain to any part of the Derivative Works, in at least one
          of the following places: within a NOTICE text file distributed
          as part of the Derivative Works; within the Source form or
          documentation, if provided along with the Derivative Works; or,
          within a display generated by the Derivative Works, if and
          wherever such third-party notices normally appear. The contents
          of the NOTICE file are for informational purposes only and
          do not modify the License. You may add Your own attribution
          notices within Derivative Works that You distribute, alongside
          or as an addendum to the NOTICE text from the Work, provided
          that such additional attribution notices cannot be construed
          as modifying the License.

      You may add Your own copyright statement to Your modifications and
      may provide additional or different license terms and conditions
      for use, reproduction, or distribution of Your modifications, or
      for any such Derivative Works as a whole, provided Your use,
      reproduction, and distribution of the Work otherwise complies with
      the conditions stated in this License.

   5. Submission of Contributions. Unless You explicitly state otherwise,
      any Contribution intentionally submitted for inclusion in the Work
      by You to the Licensor shall be under the terms and conditions of
      this License, without any additional terms or conditions.
      Notwithstanding the above, nothing herein shall supersede or modify
      the terms of any separate license agreement you may have executed
      with Licensor regarding such Contributions.

   6. Trademarks. This License does not grant permission to use the trade
      names, trademarks, service marks, or product names of the Licensor,
      except as required for reasonable and customary use in describing the
      origin of the Work and reproducing the content of the NOTICE file.

   7. Disclaimer of Warranty. Unless required by applicable law or
      agreed to in writing, Licensor provides the Work (and each
      Contributor provides its Contributions) on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
      implied, including, without limitation, any warranties or conditions
      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
      PARTICULAR PURPOSE. You are solely responsible for determining the
      appropriateness of using or redistributing the Work and assume any
      risks associated with Your exercise of permissions under this License.

   8. Limitation of Liability. In no event and under no legal theory,
      whether in tort (including negligence), contract, or otherwise,
      unless required by applicable law (such as deliberate and grossly
      negligent acts) or agreed to in writing, shall any Contributor be
      liable to You for damages, including any direct, indirect, special,
      incidental, or consequential damages of any character arising as a
      result of this License or out of the use or inability to use the
      Work (including but not limited to damages for loss of goodwill,
      work stoppage, computer failure or malfunction, or any and all
      other commercial damages or losses), even if such Contributor
      has been advised of the possibility of such damages.

   9. Accepting Warranty or Additional Liability. While redistributing
      the Work or Derivative Works thereof, You may choose to offer,
      and charge a fee for, acceptance of support, warranty, indemnity,
      or other liability obligations and/or rights consistent with this
      License. However, in accepting such obligations, You may act only
      on Your own behalf and on Your sole responsibility, not on behalf
      of any other Contributor, and only if You agree to indemnify,
      defend, and hold each Contributor harmless for any liability
      incurred by, or claims asserted against, such Contributor by reason
      of your accepting any such warranty or additional liability.

   END OF TERMS AND CONDITIONS

   APPENDIX: How to apply the Apache License to your work.

      To apply the Apache License to your work, attach the following
      boilerplate notice, with the fields enclosed by brackets "[]"
      replaced with your own identifying information. (Don't include
      the brackets!)  The text should be enclosed in the appropriate
      comment syntax for the file format. We also recommend that a
      file or class name and description of purpose be included on the
      same "printed page" as the copyright notice for easier
      identification within third-party archives.

   Copyright [yyyy] [name of copyright owner]

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs Python

Security

What our scanner noticed· Medium risk

Large base64-encoded blobs

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Published by

NVIDIA

Publisher

NVIDIA (Official)

Source

NVIDIA/skills · skills/nemo-mbridge-perf-activation-recompute · commit fce3cca

Licence

Apache License 2.0 (redistribution allowed)

LICENSE (added by AutoGineer from LICENSE-APACHE)
ATTRIBUTION.md (written by AutoGineer)

Synced

2026-11-08

AutoGineer is not affiliated with or endorsed by NVIDIA.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download nemo-mbridge-perf-activation-recompute.zip