[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill-nvidia-doca-spcx-cc":3,"mdc-zhypio-key":31,"related-repo-nvidia-doca-spcx-cc":1599,"related-org-nvidia-doca-spcx-cc":1703},{"slug":4,"name":4,"fn":5,"description":6,"org":7,"tags":11,"stars":20,"repoUrl":21,"updatedAt":22,"license":23,"forks":24,"topics":25,"repo":26,"sourceUrl":29,"mdContent":30},"doca-spcx-cc","manage Programmable Congestion Control algorithms","Use this skill when the user is invoking `doca_spcx_cc` (the host-side CLI under \u002Fopt\u002Fmellanox\u002Fdoca\u002Ftools\u002F) to load, parameterize, start, observe, or stop a Programmable Congestion Control (SPCX) algorithm on a BlueField with a DPA processor against a live RDMA \u002F RoCE fabric, or picking SPCX vs the established `doca-pcc` surface. Trigger even when the user does not say \"DOCA SPCX\" or \"doca_spcx_cc\" — typical implicit phrasings include \"I want to write a custom RTT-based CC algorithm for my RoCE fabric\", \"my SPCX session loaded but throughput \u002F latency didn't change\", \"doca_pcc status shows Active but factory CC seems to still be in charge\", \"DOCA_PCC_PS_ERROR on start\", \"is the programmable-CC surface available on my install\", or \"DPA-side algorithm image won't load\". Refuse and route elsewhere for DPA-side algorithm authoring detail, factory PCC firmware configuration, read-only PCC counter inspection, raw DPA cycle profiling, RDMA library programming, or general DOCA install — those belong to other skills.\n",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},"nvidia","NVIDIA","https:\u002F\u002Fpexgzepcugksgbtrxkhf.supabase.co\u002Fstorage\u002Fv1\u002Fobject\u002Fpublic\u002Forg-logos\u002Fnvidia.png",[12,16,17],{"name":13,"slug":14,"type":15},"Performance","performance","tag",{"name":9,"slug":8,"type":15},{"name":18,"slug":19,"type":15},"Engineering","engineering",2473,"https:\u002F\u002Fgithub.com\u002FNVIDIA\u002Fskills","2026-07-20T06:24:21.788525","Apache-2.0",281,[],{"repoUrl":21,"stars":20,"forks":24,"topics":27,"description":28},[],"AI agent skills published by NVIDIA","https:\u002F\u002Fgithub.com\u002FNVIDIA\u002Fskills\u002Ftree\u002FHEAD\u002Fskills\u002Fdoca-spcx-cc","---\nlicense: Apache-2.0\nname: doca-spcx-cc\ndescription: >\n  Use this skill when the user is invoking `doca_spcx_cc` (the\n  host-side CLI under \u002Fopt\u002Fmellanox\u002Fdoca\u002Ftools\u002F) to load,\n  parameterize, start, observe, or stop a Programmable Congestion\n  Control (SPCX) algorithm on a BlueField with a DPA processor\n  against a live RDMA \u002F RoCE fabric, or picking SPCX vs the\n  established `doca-pcc` surface. Trigger even when the user does\n  not say \"DOCA SPCX\" or \"doca_spcx_cc\" —\n  typical implicit phrasings include \"I want to write a custom\n  RTT-based CC algorithm for my RoCE fabric\", \"my SPCX session\n  loaded but throughput \u002F latency didn't change\", \"doca_pcc status\n  shows Active but factory CC seems to still be in charge\",\n  \"DOCA_PCC_PS_ERROR on start\", \"is the programmable-CC surface\n  available on my install\", or \"DPA-side algorithm image won't\n  load\". Refuse and route elsewhere for DPA-side algorithm\n  authoring detail, factory PCC firmware configuration, read-only\n  PCC counter inspection, raw DPA cycle profiling, RDMA library\n  programming, or general DOCA install — those belong to other\n  skills.\nmetadata:\n  kind: tool\ncompatibility: >\n  Requires DOCA SDK installed at \u002Fopt\u002Fmellanox\u002Fdoca on Linux\n  (Ubuntu 22.04\u002F24.04 or RHEL\u002FSLES) with the SPCX optional\n  component, a BlueField exposing its DPA processor with the\n  firmware custom-PCC slot enabled, the DPACC compiler installed\n  and version-matched, and a non-prod RDMA \u002F RoCE fabric with\n  controllable contention reachable for evaluation. Probes via\n  `pkg-config doca-pcc` and `doca_spcx_cc --help`.\n---\n\n# DOCA SPCX Congestion-Control Tool\n\n**Where to start:** This is a tool skill for invoking\n`doca_spcx_cc` — the documented host-side CLI that exercises\nan SPCX-class Programmable Congestion Control algorithm on a\nlive RDMA \u002F RoCE fabric driven by a BlueField with a DPA\nprocessor. Open [`TASKS.md`](TASKS.md) and start at\n[`## configure`](TASKS.md#configure) for the\nSPCX-vs-PCC-vs-factory-firmware decision tree (load-bearing\ngate before any code), the role decision (RP \u002F NP), the\nDPA-side algorithm authoring vs consumption split, and the\nlive-link \u002F contention precondition. Open\n[`CAPABILITIES.md`](CAPABILITIES.md) when the question is\n*what does SPCX let me express that `doca-pcc` does not*,\n*what is the SPCX-vs-PCC tradeoff*, *what runtime metrics\ndoes the tool surface*, or *what is the safety posture for\nloading a custom CC algorithm on a production fabric*. If\nDOCA is not installed yet, route to\n[`doca-setup`](..\u002F..\u002Fdoca-setup\u002FSKILL.md) first.\n\nThis skill is the **next-gen programmable-CC surface**.\n[`doca-pcc`](..\u002F..\u002Flibs\u002Fdoca-pcc\u002FSKILL.md) is the established\nPCC story; SPCX is the documented extension that authors\nSPCX-class algorithms on the same DPA hardware substrate.\n[`doca-pcc-ztr-rttcc-algo`](..\u002F..\u002Flibs\u002Fdoca-pcc-ztr-rttcc-algo\u002FSKILL.md)\nis one shipped reference algorithm (zero-touch RTT-based\nCC) that can be loaded through either the PCC or SPCX path\ndepending on the install and the user's algorithm choice;\nthe agent surfaces this decision tree explicitly per\n[`CAPABILITIES.md ## Capabilities and modes`](CAPABILITIES.md#capabilities-and-modes).\n\n## Example questions this skill answers well\n\nThe CLASSES of `doca_spcx_cc` questions this skill is built\nto answer, each with one worked example. The class is the\nload-bearing piece; the worked example is one instance.\n\n- **\"Should I use SPCX or `doca-pcc` for my custom CC\n  algorithm?\"** — worked example: *\"I want to write a new\n  RTT-based congestion-control algorithm for my RoCE\n  fabric — which surface do I target?\"*. Answered by the\n  SPCX-vs-PCC-vs-factory-firmware decision tree in\n  [`CAPABILITIES.md ## Capabilities and modes`](CAPABILITIES.md#capabilities-and-modes)\n  + the\n  *\"is SPCX the right surface on this install?\"* gate in\n  [`TASKS.md ## configure`](TASKS.md#configure) step 1.\n- **\"How do I evaluate my authored SPCX algorithm on a\n  real RDMA link before letting it touch production?\"** —\n  worked example: *\"I have a DPACC-compiled SPCX algorithm\n  and a non-prod BlueField pair; how do I run a\n  contention-positive evaluation?\"*. Answered by the\n  authoring vs consumption split + the live-link\n  precondition in\n  [`CAPABILITIES.md ## Capabilities and modes`](CAPABILITIES.md#capabilities-and-modes)\n  + the replica-first evaluation flow in\n  [`TASKS.md ## test`](TASKS.md#test).\n- **\"My SPCX algorithm appears to load cleanly but the\n  link's throughput \u002F latency curve is unchanged — what's\n  going on?\"** — worked example: *\"the host-side `doca_pcc\n  --status` reports `Active` and a stable session, but my\n  RoCE flows look like the factory algorithm is still in\n  charge\"*. Answered by the live-link \u002F contention rule\n  in\n  [`CAPABILITIES.md ## Capabilities and modes`](CAPABILITIES.md#capabilities-and-modes)\n  + the\n  *\"algorithm has no signal under no contention\"*\n  guidance in\n  [`TASKS.md ## test`](TASKS.md#test) +\n  [`TASKS.md ## debug`](TASKS.md#debug) (route through\n  the layered error taxonomy before blaming the\n  algorithm).\n- **\"My SPCX algorithm passed replica testing — what's\n  the gate before I roll it forward to production?\"** —\n  worked example: *\"my CC algorithm works on the two\n  BlueField pairs in the lab; can I push it to the\n  fleet?\"*. Answered by the safety overlay in\n  [`CAPABILITIES.md ## Safety policy`](CAPABILITIES.md#safety-policy)\n  (heavily cross-linked to\n  [`doca-hardware-safety CAPABILITIES.md ## Safety policy`](..\u002F..\u002Fdoca-hardware-safety\u002FCAPABILITIES.md#safety-policy)):\n  blast-radius bounded, observability gate proven, OOB\n  reachable, factory-PCC rollback rehearsed, escalation\n  path documented before any production cutover.\n- **\"Is `doca_spcx_cc` on my install, and is it paired\n  with the matching `doca-pcc` library and DPACC compiler\n  version?\"** — worked example: *\"is the SPCX surface\n  available on my DOCA install?\"*. Answered by the\n  version-overlay in\n  [`CAPABILITIES.md ## Version compatibility`](CAPABILITIES.md#version-compatibility),\n  which redirects to the canonical\n  [`doca-version`](..\u002F..\u002Fdoca-version\u002FSKILL.md) chain\n  and adds the *tool ↔ `doca-pcc` library ↔ DPACC\n  compiler ↔ firmware custom-PCC slot* match rule.\n- **\"My SPCX session errored — is it the tool, the\n  algorithm, the device, or the firmware?\"** — worked\n  example: *\"`doca_spcx_cc` exits with\n  `DOCA_PCC_PS_ERROR` on start\"*. Answered by the\n  layered error taxonomy in\n  [`CAPABILITIES.md ## Error taxonomy`](CAPABILITIES.md#error-taxonomy)\n  + the layered walk in\n  [`TASKS.md ## debug`](TASKS.md#debug).\n\n## Audience\n\nThis skill serves **external developers, platform\noperators, and AI agents authoring, loading, and\nevaluating an SPCX-class Programmable Congestion Control\nalgorithm on a BlueField with a DPA processor, against a\nlive RDMA \u002F RoCE fabric**. Concretely:\n\n- A CC researcher \u002F developer who has authored an\n  SPCX-class DPA-side algorithm (or who is consuming a\n  documented shipped reference such as the zero-touch\n  RTT-based algorithm via\n  [`doca-pcc-ztr-rttcc-algo`](..\u002F..\u002Flibs\u002Fdoca-pcc-ztr-rttcc-algo\u002FSKILL.md)\n  on the SPCX path when the install + algorithm support\n  it) and needs the operator-side harness to load,\n  parameterize, start, observe, and stop the algorithm.\n- A platform operator running a programmable-CC pilot\n  on a non-prod RDMA fabric to characterise the\n  algorithm's behaviour under controlled contention.\n- An AI agent producing a *\"is this SPCX algorithm safe\n  to roll forward\"* answer honestly — with evidence\n  from a contention-positive evaluation, a documented\n  rollback to the factory PCC, and an explicit blast-\n  radius bound — instead of a guess from datasheet\n  prose.\n\nIt is **not** for users debugging the `doca_spcx_cc`\nbinary itself, **not** a substitute for the live public\nDOCA SPCX \u002F DOCA PCC programming guides, **not** the\nright place for the DPA-side algorithm authoring detail\n(that path goes through the public DOCA SPCX programming\nguide and the\n[`doca-pcc`](..\u002F..\u002Flibs\u002Fdoca-pcc\u002FSKILL.md) +\n[`doca-dpa`](..\u002F..\u002Flibs\u002Fdoca-dpa\u002FSKILL.md) skills), and\n**not** the right place for default factory PCC\nconfiguration (no host-side library or SPCX tool needed;\nroute via\n[`doca-public-knowledge-map`](..\u002F..\u002Fdoca-public-knowledge-map\u002FSKILL.md)).\n\nThe tool is shipped as a **CLI binary** under\n`\u002Fopt\u002Fmellanox\u002Fdoca\u002Ftools\u002F`, not a library you link\nagainst. The skill uses the same `kind: tool`\nthree-file shape as the rest of the bundle so the\nagent's task-verb contract is uniform across libraries,\nservices, and tools.\n\n## Language scope\n\n`doca_spcx_cc` is a C host-side CLI that links the\nhost-side [`doca-pcc`](..\u002F..\u002Flibs\u002Fdoca-pcc\u002FSKILL.md)\nlibrary and loads a DPA-side SPCX algorithm image built\nby the DPACC compiler. The algorithm body is a separate\nDPA-side translation unit written in the language DPACC\naccepts. The skill keeps workflow guidance\nlanguage-neutral and routes per-language questions to\nthe public DOCA SPCX \u002F DOCA PCC \u002F DPACC guides via\n[`doca-public-knowledge-map`](..\u002F..\u002Fdoca-public-knowledge-map\u002FSKILL.md).\n\n## When to load this skill\n\nLoad this skill when the user is — or the agent needs to\n— invoke `doca_spcx_cc` on a real host with DOCA\ninstalled, paired with a BlueField that has its DPA\nprocessor exposed AND the firmware custom-PCC slot\nenabled, against a port carrying RDMA \u002F RoCE traffic with\n**actual contention**. Concretely:\n\n- Loading an authored SPCX algorithm (or a documented\n  shipped reference) onto the BlueField via the SPCX\n  surface, parameterizing it, starting it, and observing\n  its effect on the live link.\n- Evaluating an SPCX algorithm on a non-prod replica\n  before any production rollout — capturing the\n  contention-positive run as evidence.\n- Comparing SPCX vs `doca-pcc` paths for the same\n  algorithm class on the same install (where both paths\n  are available) and deciding which to commit to.\n- Producing a *\"safe to roll forward\"* recommendation\n  with the documented evidence + rollback plan, or\n  refusing the recommendation when the evidence \u002F\n  rollback is missing per\n  [`CAPABILITIES.md ## Safety policy`](CAPABILITIES.md#safety-policy).\n- Diagnosing a `DOCA_PCC_PS_ERROR` or a silent-no-effect\n  symptom against the layered error taxonomy.\n\nDo **not** load this skill for general DOCA orientation,\nDPA-side algorithm authoring detail, raw cycle profiling\nof the DPA, the factory PCC algorithm shipped in the\nfirmware, or DOCA install. For those, route to\n[`doca-public-knowledge-map`](..\u002F..\u002Fdoca-public-knowledge-map\u002FSKILL.md),\n[`doca-pcc`](..\u002F..\u002Flibs\u002Fdoca-pcc\u002FSKILL.md),\n[`doca-dpa`](..\u002F..\u002Flibs\u002Fdoca-dpa\u002FSKILL.md), or\n[`doca-setup`](..\u002F..\u002Fdoca-setup\u002FSKILL.md).\n\n## What this skill provides\n\nThis is a **thin loader**. Substantive material lives\nin two companion files:\n\n- `CAPABILITIES.md` — what SPCX expresses that PCC does\n  not (and where the surfaces overlap), the\n  SPCX-vs-PCC-vs-factory-firmware decision tree, the\n  authoring vs consumption split, the role decision\n  (RP \u002F NP), the documented probe-packet format axis,\n  the live-link \u002F contention precondition rule (the\n  load-bearing safety invariant — *\"a CC algorithm has\n  no signal under no contention\"*), the runtime\n  observability surface (per-port \u002F per-flow trace\n  formats + the host-side status surface), the\n  triple-axis precondition rule\n  ([`doca-pcc`](..\u002F..\u002Flibs\u002Fdoca-pcc\u002FSKILL.md): DPA-capable\n  BlueField + firmware custom-PCC slot enabled +\n  `doca_pcc_cap_*` agreement) extended with SPCX-specific\n  availability, the version overlay (tool ↔ library ↔\n  DPACC ↔ firmware), the layered error taxonomy\n  (install \u002F device-binding \u002F fw-slot \u002F DPA-image \u002F\n  algorithm-precondition \u002F live-link-precondition \u002F\n  runtime \u002F version \u002F cross-cutting), the observability\n  surface, and the heavily-overlaid safety posture (a\n  wrong CC algorithm on production can melt the\n  fabric).\n- `TASKS.md` — step-by-step workflows for the in-scope\n  task verbs: `install` (host-side DOCA install + DPA\n  prerequisites + firmware custom-PCC slot), `configure`\n  (SPCX-vs-PCC decision + role + algorithm + parameters\n  + probe-packet format), `build` (route to install —\n  the host-side tool is shipped; the DPA-side algorithm\n  is user-built by DPACC), `modify` (refuse — do not\n  patch the binary; modify the invocation, algorithm,\n  and parameters), `run` (the\n  prepare → smoke → contention-positive evaluation\n  flow), `test` (iterative loop on the replica before\n  production), `debug` (walk the error taxonomy),\n  `use` (the *\"safe to roll forward\"* decision with\n  evidence + rollback + escalation), plus a `Deferred\n  task verbs` block.\n\nThe skill assumes a host where DOCA is already\ninstalled, a BlueField with a DPA processor and the\nfirmware-level custom-PCC slot enabled is present and\nvisible, the DPACC compiler is installed at a version\nmatched to the host-side DOCA, the user already knows\nhow (at sketch level) to write the DPA-side SPCX\nalgorithm (or has a shipped reference algorithm to\nconsume), and a non-prod RDMA \u002F RoCE fabric with\ncontrollable contention is available for evaluation.\n\n## What this skill deliberately does not ship\n\nThis skill is **agent guidance**, not a samples or\nscripts bundle. To keep the boundary clean, it\ndeliberately does not contain — and pull requests\nshould not add:\n\n- **A specific congestion-control algorithm.** SPCX\n  *loads* an algorithm the user supplies; the skill\n  refuses to invent algorithm bodies and routes any\n  *\"what algorithm should I write\"* question to the\n  public DOCA SPCX \u002F DOCA PCC programming guides and\n  to the user's own domain expertise.\n- **Pre-baked example output** (throughput \u002F latency\n  curves, per-flow counter snapshots). Output is\n  device-, firmware-, fabric-topology-, and\n  workload-specific; pinning one would mislead\n  operators elsewhere.\n- **Specific flag strings, subcommand names,\n  probe-packet format tokens, or metric names beyond\n  what the public DOCA SPCX page and `--help`\n  document.** The SPCX surface is the newer of the\n  programmable-CC surfaces and the documented flag\n  set evolves; the installed `--help` is the\n  authoritative inventory.\n- **Wrappers, parsers, or scripts** in any language\n  that consume the tool's output. The output format\n  is documented; users who want to script against it\n  should read the live guide and write the parser\n  against their installed version.\n- **A specific tuning recommendation derived from a\n  single observation.** CC tuning on a live fabric\n  is high-stakes; the skill prescribes how to\n  *capture evidence and compare against the factory\n  PCC baseline* and refuses to translate a single\n  observation into a parameter-change recommendation\n  without the user's own domain analysis.\n- **A `samples\u002F` or `reference\u002F` subtree.** This is\n  a thin loader for a shipped CLI; substantive\n  material lives on the public page, in `--help`,\n  and in\n  [`doca-pcc`](..\u002F..\u002Flibs\u002Fdoca-pcc\u002FSKILL.md) +\n  [`doca-dpa`](..\u002F..\u002Flibs\u002Fdoca-dpa\u002FSKILL.md).\n\n## Loading order\n\n1. Read this `SKILL.md` first to confirm the user's\n   question is in scope (SPCX-side custom CC work,\n   not factory firmware PCC, not raw DPA cycle\n   profiling, and not algorithm authoring detail).\n2. **For the SPCX-vs-PCC decision tree, the authoring\n   vs consumption split, the live-link precondition,\n   the version overlay, the error taxonomy, the\n   observability surface, and the safety posture,\n   see [CAPABILITIES.md](CAPABILITIES.md).**\n3. **For the documented invocations and the\n   prepare → smoke → contention-positive evaluation\n   workflow — `install`, `configure`, `build`,\n   `modify`, `run`, `test`, `debug`, `use` — see\n   [TASKS.md](TASKS.md).**\n\n## Related skills\n\n- [`doca-pcc`](..\u002F..\u002Flibs\u002Fdoca-pcc\u002FSKILL.md) — the\n  established host-side library for Programmable\n  Congestion Control. The SPCX tool builds on and\n  links this library; the SPCX-vs-PCC decision tree\n  in\n  [`CAPABILITIES.md ## Capabilities and modes`](CAPABILITIES.md#capabilities-and-modes)\n  is the load-bearing routing rule. Conflating the\n  two is the most common programmable-CC first-touch\n  error.\n- [`doca-pcc-ztr-rttcc-algo`](..\u002F..\u002Flibs\u002Fdoca-pcc-ztr-rttcc-algo\u002FSKILL.md)\n  — the shipped reference zero-touch RTT-based CC\n  algorithm. When the user wants to deploy a\n  documented reference algorithm via the SPCX path\n  (rather than author one), this is the\n  algorithm-side skill paired with this tool's\n  operator-side workflow.\n- [`doca-dpa`](..\u002F..\u002Flibs\u002Fdoca-dpa\u002FSKILL.md) — the\n  host-side DPA control library the SPCX algorithm's\n  DPA-side body builds on. For DPA-level questions\n  (kernel-launch model, DPACC build flags, DPA-side\n  comms \u002F verbs), this is the skill the agent loads\n  alongside.\n- [`doca-rdma`](..\u002F..\u002Flibs\u002Fdoca-rdma\u002FSKILL.md) — the\n  library whose RDMA \u002F RoCE flows on the attached\n  BlueField port the SPCX algorithm is controlling.\n  Without RDMA traffic in flight and contention on\n  the fabric, the algorithm has no signal — surface\n  this precondition with the user before any\n  evaluation.\n- [`doca-pcc-counters`](..\u002Fdoca-pcc-counters\u002FSKILL.md) —\n  the sibling tool for read-only PCC counter\n  inspection. SPCX exposes its own runtime\n  observability surface; the PCC counter tool is the\n  cheaper *\"is anything happening on this port\"*\n  first step before \u002F during an SPCX evaluation.\n- [`doca-hardware-safety`](..\u002F..\u002Fdoca-hardware-safety\u002FSKILL.md)\n  — the bundle-wide hardware-safety meta-policy\n  (pre-flight inventory, OOB requirement,\n  replica-first, observability-before-workload,\n  rollback discipline, escalation). The `## Safety\n  policy` overlay in this skill is heavily layered\n  on the meta-policy; deploying a wrong CC algorithm\n  on a production fabric is a *meta-policy STOP*\n  case.\n- [`doca-public-knowledge-map`](..\u002F..\u002Fdoca-public-knowledge-map\u002FSKILL.md)\n  — routing to the public DOCA SPCX programming\n  guide, the public DOCA PCC programming guide, the\n  public DOCA DPA \u002F DPACC guides, and the rest of\n  the public DOCA documentation set.\n- [`doca-version`](..\u002F..\u002Fdoca-version\u002FSKILL.md) —\n  canonical DOCA version-handling rules. The\n  `## Version compatibility` section in\n  [`CAPABILITIES.md`](CAPABILITIES.md) is a concise\n  overlay that redirects here for the body and adds\n  the *tool ↔ `doca-pcc` library ↔ DPACC ↔ firmware\n  custom-PCC slot* matching rule.\n- [`doca-setup`](..\u002F..\u002Fdoca-setup\u002FSKILL.md) — env\n  preparation, install verification, DPACC compiler\n  install \u002F verification, BlueField firmware\n  configuration (custom-PCC slot enablement is a\n  firmware-level setting), and the *I have no\n  install yet* path with the public NGC DOCA\n  container.\n- [`doca-debug`](..\u002F..\u002Fdoca-debug\u002FSKILL.md) — the\n  cross-cutting debug ladder. SPCX-specific debug\n  layers on top of that ladder; cross-link the\n  captured runtime evidence + counter snapshots\n  into a `doca-debug` session when the cause is\n  below DOCA.\n- [`doca-structured-tools-contract`](..\u002F..\u002Fdoca-structured-tools-contract\u002FSKILL.md)\n  — the bundle's detect → prefer → fall back →\n  report contract for structured helper tools. The\n  command appendix in [`TASKS.md`](TASKS.md)\n  honors this contract.\n- [`doca-programming-guide`](..\u002F..\u002Fdoca-programming-guide\u002FSKILL.md)\n  — general DOCA programming patterns shared by\n  every library \u002F tool surface, including the\n  cross-library `DOCA_ERROR_*` taxonomy this\n  tool's host-side error layer overlays on top of.\n\nThe default factory PCC algorithms shipped inside\nConnectX firmware are **not in scope** for this skill —\nthose work without `doca_spcx_cc` and are configured\nthrough firmware-level knobs, not through any host-side\nlibrary or tool API. Route via\n[`doca-public-knowledge-map`](..\u002F..\u002Fdoca-public-knowledge-map\u002FSKILL.md).\nConflating the factory PCC story with SPCX is the\nsingle most common programmable-CC first-touch error.\n",{"data":32,"body":36},{"license":23,"name":4,"description":6,"metadata":33,"compatibility":35},{"kind":34},"tool","Requires DOCA SDK installed at \u002Fopt\u002Fmellanox\u002Fdoca on Linux (Ubuntu 22.04\u002F24.04 or RHEL\u002FSLES) with the SPCX optional component, a BlueField exposing its DPA processor with the firmware custom-PCC slot enabled, the DPACC compiler installed and version-matched, and a non-prod RDMA \u002F RoCE fabric with controllable contention reachable for evaluation. Probes via `pkg-config doca-pcc` and `doca_spcx_cc --help`.\n",{"type":37,"children":38},"root",[39,48,153,200,207,219,569,575,587,622,692,720,726,755,761,779,837,885,891,903,1037,1042,1048,1060,1200,1206,1298,1304,1570],{"type":40,"tag":41,"props":42,"children":44},"element","h1",{"id":43},"doca-spcx-congestion-control-tool",[45],{"type":46,"value":47},"text","DOCA SPCX Congestion-Control Tool",{"type":40,"tag":49,"props":50,"children":51},"p",{},[52,58,60,67,69,79,81,91,93,102,104,118,120,125,127,132,134,139,141,151],{"type":40,"tag":53,"props":54,"children":55},"strong",{},[56],{"type":46,"value":57},"Where to start:",{"type":46,"value":59}," This is a tool skill for invoking\n",{"type":40,"tag":61,"props":62,"children":64},"code",{"className":63},[],[65],{"type":46,"value":66},"doca_spcx_cc",{"type":46,"value":68}," — the documented host-side CLI that exercises\nan SPCX-class Programmable Congestion Control algorithm on a\nlive RDMA \u002F RoCE fabric driven by a BlueField with a DPA\nprocessor. Open ",{"type":40,"tag":70,"props":71,"children":73},"a",{"href":72},"TASKS.md",[74],{"type":40,"tag":61,"props":75,"children":77},{"className":76},[],[78],{"type":46,"value":72},{"type":46,"value":80}," and start at\n",{"type":40,"tag":70,"props":82,"children":84},{"href":83},"TASKS.md#configure",[85],{"type":40,"tag":61,"props":86,"children":88},{"className":87},[],[89],{"type":46,"value":90},"## configure",{"type":46,"value":92}," for the\nSPCX-vs-PCC-vs-factory-firmware decision tree (load-bearing\ngate before any code), the role decision (RP \u002F NP), the\nDPA-side algorithm authoring vs consumption split, and the\nlive-link \u002F contention precondition. Open\n",{"type":40,"tag":70,"props":94,"children":96},{"href":95},"CAPABILITIES.md",[97],{"type":40,"tag":61,"props":98,"children":100},{"className":99},[],[101],{"type":46,"value":95},{"type":46,"value":103}," when the question is\n",{"type":40,"tag":105,"props":106,"children":107},"em",{},[108,110,116],{"type":46,"value":109},"what does SPCX let me express that ",{"type":40,"tag":61,"props":111,"children":113},{"className":112},[],[114],{"type":46,"value":115},"doca-pcc",{"type":46,"value":117}," does not",{"type":46,"value":119},",\n",{"type":40,"tag":105,"props":121,"children":122},{},[123],{"type":46,"value":124},"what is the SPCX-vs-PCC tradeoff",{"type":46,"value":126},", ",{"type":40,"tag":105,"props":128,"children":129},{},[130],{"type":46,"value":131},"what runtime metrics\ndoes the tool surface",{"type":46,"value":133},", or ",{"type":40,"tag":105,"props":135,"children":136},{},[137],{"type":46,"value":138},"what is the safety posture for\nloading a custom CC algorithm on a production fabric",{"type":46,"value":140},". If\nDOCA is not installed yet, route to\n",{"type":40,"tag":70,"props":142,"children":144},{"href":143},"..\u002F..\u002Fdoca-setup\u002FSKILL.md",[145],{"type":40,"tag":61,"props":146,"children":148},{"className":147},[],[149],{"type":46,"value":150},"doca-setup",{"type":46,"value":152}," first.",{"type":40,"tag":49,"props":154,"children":155},{},[156,158,163,165,174,176,186,188,198],{"type":46,"value":157},"This skill is the ",{"type":40,"tag":53,"props":159,"children":160},{},[161],{"type":46,"value":162},"next-gen programmable-CC surface",{"type":46,"value":164},".\n",{"type":40,"tag":70,"props":166,"children":168},{"href":167},"..\u002F..\u002Flibs\u002Fdoca-pcc\u002FSKILL.md",[169],{"type":40,"tag":61,"props":170,"children":172},{"className":171},[],[173],{"type":46,"value":115},{"type":46,"value":175}," is the established\nPCC story; SPCX is the documented extension that authors\nSPCX-class algorithms on the same DPA hardware substrate.\n",{"type":40,"tag":70,"props":177,"children":179},{"href":178},"..\u002F..\u002Flibs\u002Fdoca-pcc-ztr-rttcc-algo\u002FSKILL.md",[180],{"type":40,"tag":61,"props":181,"children":183},{"className":182},[],[184],{"type":46,"value":185},"doca-pcc-ztr-rttcc-algo",{"type":46,"value":187},"\nis one shipped reference algorithm (zero-touch RTT-based\nCC) that can be loaded through either the PCC or SPCX path\ndepending on the install and the user's algorithm choice;\nthe agent surfaces this decision tree explicitly per\n",{"type":40,"tag":70,"props":189,"children":191},{"href":190},"CAPABILITIES.md#capabilities-and-modes",[192],{"type":40,"tag":61,"props":193,"children":195},{"className":194},[],[196],{"type":46,"value":197},"CAPABILITIES.md ## Capabilities and modes",{"type":46,"value":199},".",{"type":40,"tag":201,"props":202,"children":204},"h2",{"id":203},"example-questions-this-skill-answers-well",[205],{"type":46,"value":206},"Example questions this skill answers well",{"type":40,"tag":49,"props":208,"children":209},{},[210,212,217],{"type":46,"value":211},"The CLASSES of ",{"type":40,"tag":61,"props":213,"children":215},{"className":214},[],[216],{"type":46,"value":66},{"type":46,"value":218}," questions this skill is built\nto answer, each with one worked example. The class is the\nload-bearing piece; the worked example is one instance.",{"type":40,"tag":220,"props":221,"children":222},"ul",{},[223,282,326,402,442,510],{"type":40,"tag":224,"props":225,"children":226},"li",{},[227,239,241,246,248,256],{"type":40,"tag":53,"props":228,"children":229},{},[230,232,237],{"type":46,"value":231},"\"Should I use SPCX or ",{"type":40,"tag":61,"props":233,"children":235},{"className":234},[],[236],{"type":46,"value":115},{"type":46,"value":238}," for my custom CC\nalgorithm?\"",{"type":46,"value":240}," — worked example: ",{"type":40,"tag":105,"props":242,"children":243},{},[244],{"type":46,"value":245},"\"I want to write a new\nRTT-based congestion-control algorithm for my RoCE\nfabric — which surface do I target?\"",{"type":46,"value":247},". Answered by the\nSPCX-vs-PCC-vs-factory-firmware decision tree in\n",{"type":40,"tag":70,"props":249,"children":250},{"href":190},[251],{"type":40,"tag":61,"props":252,"children":254},{"className":253},[],[255],{"type":46,"value":197},{"type":40,"tag":220,"props":257,"children":258},{},[259],{"type":40,"tag":224,"props":260,"children":261},{},[262,264,269,271,280],{"type":46,"value":263},"the\n",{"type":40,"tag":105,"props":265,"children":266},{},[267],{"type":46,"value":268},"\"is SPCX the right surface on this install?\"",{"type":46,"value":270}," gate in\n",{"type":40,"tag":70,"props":272,"children":273},{"href":83},[274],{"type":40,"tag":61,"props":275,"children":277},{"className":276},[],[278],{"type":46,"value":279},"TASKS.md ## configure",{"type":46,"value":281}," step 1.",{"type":40,"tag":224,"props":283,"children":284},{},[285,290,292,297,299,307],{"type":40,"tag":53,"props":286,"children":287},{},[288],{"type":46,"value":289},"\"How do I evaluate my authored SPCX algorithm on a\nreal RDMA link before letting it touch production?\"",{"type":46,"value":291}," —\nworked example: ",{"type":40,"tag":105,"props":293,"children":294},{},[295],{"type":46,"value":296},"\"I have a DPACC-compiled SPCX algorithm\nand a non-prod BlueField pair; how do I run a\ncontention-positive evaluation?\"",{"type":46,"value":298},". Answered by the\nauthoring vs consumption split + the live-link\nprecondition in\n",{"type":40,"tag":70,"props":300,"children":301},{"href":190},[302],{"type":40,"tag":61,"props":303,"children":305},{"className":304},[],[306],{"type":46,"value":197},{"type":40,"tag":220,"props":308,"children":309},{},[310],{"type":40,"tag":224,"props":311,"children":312},{},[313,315,325],{"type":46,"value":314},"the replica-first evaluation flow in\n",{"type":40,"tag":70,"props":316,"children":318},{"href":317},"TASKS.md#test",[319],{"type":40,"tag":61,"props":320,"children":322},{"className":321},[],[323],{"type":46,"value":324},"TASKS.md ## test",{"type":46,"value":199},{"type":40,"tag":224,"props":327,"children":328},{},[329,334,335,356,358,366],{"type":40,"tag":53,"props":330,"children":331},{},[332],{"type":46,"value":333},"\"My SPCX algorithm appears to load cleanly but the\nlink's throughput \u002F latency curve is unchanged — what's\ngoing on?\"",{"type":46,"value":240},{"type":40,"tag":105,"props":336,"children":337},{},[338,340,346,348,354],{"type":46,"value":339},"\"the host-side ",{"type":40,"tag":61,"props":341,"children":343},{"className":342},[],[344],{"type":46,"value":345},"doca_pcc --status",{"type":46,"value":347}," reports ",{"type":40,"tag":61,"props":349,"children":351},{"className":350},[],[352],{"type":46,"value":353},"Active",{"type":46,"value":355}," and a stable session, but my\nRoCE flows look like the factory algorithm is still in\ncharge\"",{"type":46,"value":357},". Answered by the live-link \u002F contention rule\nin\n",{"type":40,"tag":70,"props":359,"children":360},{"href":190},[361],{"type":40,"tag":61,"props":362,"children":364},{"className":363},[],[365],{"type":46,"value":197},{"type":40,"tag":220,"props":367,"children":368},{},[369],{"type":40,"tag":224,"props":370,"children":371},{},[372,373,378,380,388,390,400],{"type":46,"value":263},{"type":40,"tag":105,"props":374,"children":375},{},[376],{"type":46,"value":377},"\"algorithm has no signal under no contention\"",{"type":46,"value":379},"\nguidance in\n",{"type":40,"tag":70,"props":381,"children":382},{"href":317},[383],{"type":40,"tag":61,"props":384,"children":386},{"className":385},[],[387],{"type":46,"value":324},{"type":46,"value":389}," +\n",{"type":40,"tag":70,"props":391,"children":393},{"href":392},"TASKS.md#debug",[394],{"type":40,"tag":61,"props":395,"children":397},{"className":396},[],[398],{"type":46,"value":399},"TASKS.md ## debug",{"type":46,"value":401}," (route through\nthe layered error taxonomy before blaming the\nalgorithm).",{"type":40,"tag":224,"props":403,"children":404},{},[405,410,411,416,418,428,430,440],{"type":40,"tag":53,"props":406,"children":407},{},[408],{"type":46,"value":409},"\"My SPCX algorithm passed replica testing — what's\nthe gate before I roll it forward to production?\"",{"type":46,"value":291},{"type":40,"tag":105,"props":412,"children":413},{},[414],{"type":46,"value":415},"\"my CC algorithm works on the two\nBlueField pairs in the lab; can I push it to the\nfleet?\"",{"type":46,"value":417},". Answered by the safety overlay in\n",{"type":40,"tag":70,"props":419,"children":421},{"href":420},"CAPABILITIES.md#safety-policy",[422],{"type":40,"tag":61,"props":423,"children":425},{"className":424},[],[426],{"type":46,"value":427},"CAPABILITIES.md ## Safety policy",{"type":46,"value":429},"\n(heavily cross-linked to\n",{"type":40,"tag":70,"props":431,"children":433},{"href":432},"..\u002F..\u002Fdoca-hardware-safety\u002FCAPABILITIES.md#safety-policy",[434],{"type":40,"tag":61,"props":435,"children":437},{"className":436},[],[438],{"type":46,"value":439},"doca-hardware-safety CAPABILITIES.md ## Safety policy",{"type":46,"value":441},"):\nblast-radius bounded, observability gate proven, OOB\nreachable, factory-PCC rollback rehearsed, escalation\npath documented before any production cutover.",{"type":40,"tag":224,"props":443,"children":444},{},[445,464,465,470,472,482,484,494,496,508],{"type":40,"tag":53,"props":446,"children":447},{},[448,450,455,457,462],{"type":46,"value":449},"\"Is ",{"type":40,"tag":61,"props":451,"children":453},{"className":452},[],[454],{"type":46,"value":66},{"type":46,"value":456}," on my install, and is it paired\nwith the matching ",{"type":40,"tag":61,"props":458,"children":460},{"className":459},[],[461],{"type":46,"value":115},{"type":46,"value":463}," library and DPACC compiler\nversion?\"",{"type":46,"value":240},{"type":40,"tag":105,"props":466,"children":467},{},[468],{"type":46,"value":469},"\"is the SPCX surface\navailable on my DOCA install?\"",{"type":46,"value":471},". Answered by the\nversion-overlay in\n",{"type":40,"tag":70,"props":473,"children":475},{"href":474},"CAPABILITIES.md#version-compatibility",[476],{"type":40,"tag":61,"props":477,"children":479},{"className":478},[],[480],{"type":46,"value":481},"CAPABILITIES.md ## Version compatibility",{"type":46,"value":483},",\nwhich redirects to the canonical\n",{"type":40,"tag":70,"props":485,"children":487},{"href":486},"..\u002F..\u002Fdoca-version\u002FSKILL.md",[488],{"type":40,"tag":61,"props":489,"children":491},{"className":490},[],[492],{"type":46,"value":493},"doca-version",{"type":46,"value":495}," chain\nand adds the ",{"type":40,"tag":105,"props":497,"children":498},{},[499,501,506],{"type":46,"value":500},"tool ↔ ",{"type":40,"tag":61,"props":502,"children":504},{"className":503},[],[505],{"type":46,"value":115},{"type":46,"value":507}," library ↔ DPACC\ncompiler ↔ firmware custom-PCC slot",{"type":46,"value":509}," match rule.",{"type":40,"tag":224,"props":511,"children":512},{},[513,518,520,540,542,552],{"type":40,"tag":53,"props":514,"children":515},{},[516],{"type":46,"value":517},"\"My SPCX session errored — is it the tool, the\nalgorithm, the device, or the firmware?\"",{"type":46,"value":519}," — worked\nexample: ",{"type":40,"tag":105,"props":521,"children":522},{},[523,525,530,532,538],{"type":46,"value":524},"\"",{"type":40,"tag":61,"props":526,"children":528},{"className":527},[],[529],{"type":46,"value":66},{"type":46,"value":531}," exits with\n",{"type":40,"tag":61,"props":533,"children":535},{"className":534},[],[536],{"type":46,"value":537},"DOCA_PCC_PS_ERROR",{"type":46,"value":539}," on start\"",{"type":46,"value":541},". Answered by the\nlayered error taxonomy in\n",{"type":40,"tag":70,"props":543,"children":545},{"href":544},"CAPABILITIES.md#error-taxonomy",[546],{"type":40,"tag":61,"props":547,"children":549},{"className":548},[],[550],{"type":46,"value":551},"CAPABILITIES.md ## Error taxonomy",{"type":40,"tag":220,"props":553,"children":554},{},[555],{"type":40,"tag":224,"props":556,"children":557},{},[558,560,568],{"type":46,"value":559},"the layered walk in\n",{"type":40,"tag":70,"props":561,"children":562},{"href":392},[563],{"type":40,"tag":61,"props":564,"children":566},{"className":565},[],[567],{"type":46,"value":399},{"type":46,"value":199},{"type":40,"tag":201,"props":570,"children":572},{"id":571},"audience",[573],{"type":46,"value":574},"Audience",{"type":40,"tag":49,"props":576,"children":577},{},[578,580,585],{"type":46,"value":579},"This skill serves ",{"type":40,"tag":53,"props":581,"children":582},{},[583],{"type":46,"value":584},"external developers, platform\noperators, and AI agents authoring, loading, and\nevaluating an SPCX-class Programmable Congestion Control\nalgorithm on a BlueField with a DPA processor, against a\nlive RDMA \u002F RoCE fabric",{"type":46,"value":586},". Concretely:",{"type":40,"tag":220,"props":588,"children":589},{},[590,605,610],{"type":40,"tag":224,"props":591,"children":592},{},[593,595,603],{"type":46,"value":594},"A CC researcher \u002F developer who has authored an\nSPCX-class DPA-side algorithm (or who is consuming a\ndocumented shipped reference such as the zero-touch\nRTT-based algorithm via\n",{"type":40,"tag":70,"props":596,"children":597},{"href":178},[598],{"type":40,"tag":61,"props":599,"children":601},{"className":600},[],[602],{"type":46,"value":185},{"type":46,"value":604},"\non the SPCX path when the install + algorithm support\nit) and needs the operator-side harness to load,\nparameterize, start, observe, and stop the algorithm.",{"type":40,"tag":224,"props":606,"children":607},{},[608],{"type":46,"value":609},"A platform operator running a programmable-CC pilot\non a non-prod RDMA fabric to characterise the\nalgorithm's behaviour under controlled contention.",{"type":40,"tag":224,"props":611,"children":612},{},[613,615,620],{"type":46,"value":614},"An AI agent producing a ",{"type":40,"tag":105,"props":616,"children":617},{},[618],{"type":46,"value":619},"\"is this SPCX algorithm safe\nto roll forward\"",{"type":46,"value":621}," answer honestly — with evidence\nfrom a contention-positive evaluation, a documented\nrollback to the factory PCC, and an explicit blast-\nradius bound — instead of a guess from datasheet\nprose.",{"type":40,"tag":49,"props":623,"children":624},{},[625,627,632,634,639,641,645,647,651,653,661,662,672,674,678,680,690],{"type":46,"value":626},"It is ",{"type":40,"tag":53,"props":628,"children":629},{},[630],{"type":46,"value":631},"not",{"type":46,"value":633}," for users debugging the ",{"type":40,"tag":61,"props":635,"children":637},{"className":636},[],[638],{"type":46,"value":66},{"type":46,"value":640},"\nbinary itself, ",{"type":40,"tag":53,"props":642,"children":643},{},[644],{"type":46,"value":631},{"type":46,"value":646}," a substitute for the live public\nDOCA SPCX \u002F DOCA PCC programming guides, ",{"type":40,"tag":53,"props":648,"children":649},{},[650],{"type":46,"value":631},{"type":46,"value":652}," the\nright place for the DPA-side algorithm authoring detail\n(that path goes through the public DOCA SPCX programming\nguide and the\n",{"type":40,"tag":70,"props":654,"children":655},{"href":167},[656],{"type":40,"tag":61,"props":657,"children":659},{"className":658},[],[660],{"type":46,"value":115},{"type":46,"value":389},{"type":40,"tag":70,"props":663,"children":665},{"href":664},"..\u002F..\u002Flibs\u002Fdoca-dpa\u002FSKILL.md",[666],{"type":40,"tag":61,"props":667,"children":669},{"className":668},[],[670],{"type":46,"value":671},"doca-dpa",{"type":46,"value":673}," skills), and\n",{"type":40,"tag":53,"props":675,"children":676},{},[677],{"type":46,"value":631},{"type":46,"value":679}," the right place for default factory PCC\nconfiguration (no host-side library or SPCX tool needed;\nroute via\n",{"type":40,"tag":70,"props":681,"children":683},{"href":682},"..\u002F..\u002Fdoca-public-knowledge-map\u002FSKILL.md",[684],{"type":40,"tag":61,"props":685,"children":687},{"className":686},[],[688],{"type":46,"value":689},"doca-public-knowledge-map",{"type":46,"value":691},").",{"type":40,"tag":49,"props":693,"children":694},{},[695,697,702,704,710,712,718],{"type":46,"value":696},"The tool is shipped as a ",{"type":40,"tag":53,"props":698,"children":699},{},[700],{"type":46,"value":701},"CLI binary",{"type":46,"value":703}," under\n",{"type":40,"tag":61,"props":705,"children":707},{"className":706},[],[708],{"type":46,"value":709},"\u002Fopt\u002Fmellanox\u002Fdoca\u002Ftools\u002F",{"type":46,"value":711},", not a library you link\nagainst. The skill uses the same ",{"type":40,"tag":61,"props":713,"children":715},{"className":714},[],[716],{"type":46,"value":717},"kind: tool",{"type":46,"value":719},"\nthree-file shape as the rest of the bundle so the\nagent's task-verb contract is uniform across libraries,\nservices, and tools.",{"type":40,"tag":201,"props":721,"children":723},{"id":722},"language-scope",[724],{"type":46,"value":725},"Language scope",{"type":40,"tag":49,"props":727,"children":728},{},[729,734,736,744,746,754],{"type":40,"tag":61,"props":730,"children":732},{"className":731},[],[733],{"type":46,"value":66},{"type":46,"value":735}," is a C host-side CLI that links the\nhost-side ",{"type":40,"tag":70,"props":737,"children":738},{"href":167},[739],{"type":40,"tag":61,"props":740,"children":742},{"className":741},[],[743],{"type":46,"value":115},{"type":46,"value":745},"\nlibrary and loads a DPA-side SPCX algorithm image built\nby the DPACC compiler. The algorithm body is a separate\nDPA-side translation unit written in the language DPACC\naccepts. The skill keeps workflow guidance\nlanguage-neutral and routes per-language questions to\nthe public DOCA SPCX \u002F DOCA PCC \u002F DPACC guides via\n",{"type":40,"tag":70,"props":747,"children":748},{"href":682},[749],{"type":40,"tag":61,"props":750,"children":752},{"className":751},[],[753],{"type":46,"value":689},{"type":46,"value":199},{"type":40,"tag":201,"props":756,"children":758},{"id":757},"when-to-load-this-skill",[759],{"type":46,"value":760},"When to load this skill",{"type":40,"tag":49,"props":762,"children":763},{},[764,766,771,773,778],{"type":46,"value":765},"Load this skill when the user is — or the agent needs to\n— invoke ",{"type":40,"tag":61,"props":767,"children":769},{"className":768},[],[770],{"type":46,"value":66},{"type":46,"value":772}," on a real host with DOCA\ninstalled, paired with a BlueField that has its DPA\nprocessor exposed AND the firmware custom-PCC slot\nenabled, against a port carrying RDMA \u002F RoCE traffic with\n",{"type":40,"tag":53,"props":774,"children":775},{},[776],{"type":46,"value":777},"actual contention",{"type":46,"value":586},{"type":40,"tag":220,"props":780,"children":781},{},[782,787,792,804,825],{"type":40,"tag":224,"props":783,"children":784},{},[785],{"type":46,"value":786},"Loading an authored SPCX algorithm (or a documented\nshipped reference) onto the BlueField via the SPCX\nsurface, parameterizing it, starting it, and observing\nits effect on the live link.",{"type":40,"tag":224,"props":788,"children":789},{},[790],{"type":46,"value":791},"Evaluating an SPCX algorithm on a non-prod replica\nbefore any production rollout — capturing the\ncontention-positive run as evidence.",{"type":40,"tag":224,"props":793,"children":794},{},[795,797,802],{"type":46,"value":796},"Comparing SPCX vs ",{"type":40,"tag":61,"props":798,"children":800},{"className":799},[],[801],{"type":46,"value":115},{"type":46,"value":803}," paths for the same\nalgorithm class on the same install (where both paths\nare available) and deciding which to commit to.",{"type":40,"tag":224,"props":805,"children":806},{},[807,809,814,816,824],{"type":46,"value":808},"Producing a ",{"type":40,"tag":105,"props":810,"children":811},{},[812],{"type":46,"value":813},"\"safe to roll forward\"",{"type":46,"value":815}," recommendation\nwith the documented evidence + rollback plan, or\nrefusing the recommendation when the evidence \u002F\nrollback is missing per\n",{"type":40,"tag":70,"props":817,"children":818},{"href":420},[819],{"type":40,"tag":61,"props":820,"children":822},{"className":821},[],[823],{"type":46,"value":427},{"type":46,"value":199},{"type":40,"tag":224,"props":826,"children":827},{},[828,830,835],{"type":46,"value":829},"Diagnosing a ",{"type":40,"tag":61,"props":831,"children":833},{"className":832},[],[834],{"type":46,"value":537},{"type":46,"value":836}," or a silent-no-effect\nsymptom against the layered error taxonomy.",{"type":40,"tag":49,"props":838,"children":839},{},[840,842,846,848,856,857,865,866,874,876,884],{"type":46,"value":841},"Do ",{"type":40,"tag":53,"props":843,"children":844},{},[845],{"type":46,"value":631},{"type":46,"value":847}," load this skill for general DOCA orientation,\nDPA-side algorithm authoring detail, raw cycle profiling\nof the DPA, the factory PCC algorithm shipped in the\nfirmware, or DOCA install. For those, route to\n",{"type":40,"tag":70,"props":849,"children":850},{"href":682},[851],{"type":40,"tag":61,"props":852,"children":854},{"className":853},[],[855],{"type":46,"value":689},{"type":46,"value":119},{"type":40,"tag":70,"props":858,"children":859},{"href":167},[860],{"type":40,"tag":61,"props":861,"children":863},{"className":862},[],[864],{"type":46,"value":115},{"type":46,"value":119},{"type":40,"tag":70,"props":867,"children":868},{"href":664},[869],{"type":40,"tag":61,"props":870,"children":872},{"className":871},[],[873],{"type":46,"value":671},{"type":46,"value":875},", or\n",{"type":40,"tag":70,"props":877,"children":878},{"href":143},[879],{"type":40,"tag":61,"props":880,"children":882},{"className":881},[],[883],{"type":46,"value":150},{"type":46,"value":199},{"type":40,"tag":201,"props":886,"children":888},{"id":887},"what-this-skill-provides",[889],{"type":46,"value":890},"What this skill provides",{"type":40,"tag":49,"props":892,"children":893},{},[894,896,901],{"type":46,"value":895},"This is a ",{"type":40,"tag":53,"props":897,"children":898},{},[899],{"type":46,"value":900},"thin loader",{"type":46,"value":902},". Substantive material lives\nin two companion files:",{"type":40,"tag":220,"props":904,"children":905},{},[906,941],{"type":40,"tag":224,"props":907,"children":908},{},[909,914,916,921,923,931,933,939],{"type":40,"tag":61,"props":910,"children":912},{"className":911},[],[913],{"type":46,"value":95},{"type":46,"value":915}," — what SPCX expresses that PCC does\nnot (and where the surfaces overlap), the\nSPCX-vs-PCC-vs-factory-firmware decision tree, the\nauthoring vs consumption split, the role decision\n(RP \u002F NP), the documented probe-packet format axis,\nthe live-link \u002F contention precondition rule (the\nload-bearing safety invariant — ",{"type":40,"tag":105,"props":917,"children":918},{},[919],{"type":46,"value":920},"\"a CC algorithm has\nno signal under no contention\"",{"type":46,"value":922},"), the runtime\nobservability surface (per-port \u002F per-flow trace\nformats + the host-side status surface), the\ntriple-axis precondition rule\n(",{"type":40,"tag":70,"props":924,"children":925},{"href":167},[926],{"type":40,"tag":61,"props":927,"children":929},{"className":928},[],[930],{"type":46,"value":115},{"type":46,"value":932},": DPA-capable\nBlueField + firmware custom-PCC slot enabled +\n",{"type":40,"tag":61,"props":934,"children":936},{"className":935},[],[937],{"type":46,"value":938},"doca_pcc_cap_*",{"type":46,"value":940}," agreement) extended with SPCX-specific\navailability, the version overlay (tool ↔ library ↔\nDPACC ↔ firmware), the layered error taxonomy\n(install \u002F device-binding \u002F fw-slot \u002F DPA-image \u002F\nalgorithm-precondition \u002F live-link-precondition \u002F\nruntime \u002F version \u002F cross-cutting), the observability\nsurface, and the heavily-overlaid safety posture (a\nwrong CC algorithm on production can melt the\nfabric).",{"type":40,"tag":224,"props":942,"children":943},{},[944,949,951,957,959,965,967],{"type":40,"tag":61,"props":945,"children":947},{"className":946},[],[948],{"type":46,"value":72},{"type":46,"value":950}," — step-by-step workflows for the in-scope\ntask verbs: ",{"type":40,"tag":61,"props":952,"children":954},{"className":953},[],[955],{"type":46,"value":956},"install",{"type":46,"value":958}," (host-side DOCA install + DPA\nprerequisites + firmware custom-PCC slot), ",{"type":40,"tag":61,"props":960,"children":962},{"className":961},[],[963],{"type":46,"value":964},"configure",{"type":46,"value":966},"\n(SPCX-vs-PCC decision + role + algorithm + parameters\n",{"type":40,"tag":220,"props":968,"children":969},{},[970],{"type":40,"tag":224,"props":971,"children":972},{},[973,975,981,983,989,991,997,999,1005,1007,1013,1015,1021,1023,1027,1029,1035],{"type":46,"value":974},"probe-packet format), ",{"type":40,"tag":61,"props":976,"children":978},{"className":977},[],[979],{"type":46,"value":980},"build",{"type":46,"value":982}," (route to install —\nthe host-side tool is shipped; the DPA-side algorithm\nis user-built by DPACC), ",{"type":40,"tag":61,"props":984,"children":986},{"className":985},[],[987],{"type":46,"value":988},"modify",{"type":46,"value":990}," (refuse — do not\npatch the binary; modify the invocation, algorithm,\nand parameters), ",{"type":40,"tag":61,"props":992,"children":994},{"className":993},[],[995],{"type":46,"value":996},"run",{"type":46,"value":998}," (the\nprepare → smoke → contention-positive evaluation\nflow), ",{"type":40,"tag":61,"props":1000,"children":1002},{"className":1001},[],[1003],{"type":46,"value":1004},"test",{"type":46,"value":1006}," (iterative loop on the replica before\nproduction), ",{"type":40,"tag":61,"props":1008,"children":1010},{"className":1009},[],[1011],{"type":46,"value":1012},"debug",{"type":46,"value":1014}," (walk the error taxonomy),\n",{"type":40,"tag":61,"props":1016,"children":1018},{"className":1017},[],[1019],{"type":46,"value":1020},"use",{"type":46,"value":1022}," (the ",{"type":40,"tag":105,"props":1024,"children":1025},{},[1026],{"type":46,"value":813},{"type":46,"value":1028}," decision with\nevidence + rollback + escalation), plus a ",{"type":40,"tag":61,"props":1030,"children":1032},{"className":1031},[],[1033],{"type":46,"value":1034},"Deferred task verbs",{"type":46,"value":1036}," block.",{"type":40,"tag":49,"props":1038,"children":1039},{},[1040],{"type":46,"value":1041},"The skill assumes a host where DOCA is already\ninstalled, a BlueField with a DPA processor and the\nfirmware-level custom-PCC slot enabled is present and\nvisible, the DPACC compiler is installed at a version\nmatched to the host-side DOCA, the user already knows\nhow (at sketch level) to write the DPA-side SPCX\nalgorithm (or has a shipped reference algorithm to\nconsume), and a non-prod RDMA \u002F RoCE fabric with\ncontrollable contention is available for evaluation.",{"type":40,"tag":201,"props":1043,"children":1045},{"id":1044},"what-this-skill-deliberately-does-not-ship",[1046],{"type":46,"value":1047},"What this skill deliberately does not ship",{"type":40,"tag":49,"props":1049,"children":1050},{},[1051,1053,1058],{"type":46,"value":1052},"This skill is ",{"type":40,"tag":53,"props":1054,"children":1055},{},[1056],{"type":46,"value":1057},"agent guidance",{"type":46,"value":1059},", not a samples or\nscripts bundle. To keep the boundary clean, it\ndeliberately does not contain — and pull requests\nshould not add:",{"type":40,"tag":220,"props":1061,"children":1062},{},[1063,1087,1097,1122,1132,1149],{"type":40,"tag":224,"props":1064,"children":1065},{},[1066,1071,1073,1078,1080,1085],{"type":40,"tag":53,"props":1067,"children":1068},{},[1069],{"type":46,"value":1070},"A specific congestion-control algorithm.",{"type":46,"value":1072}," SPCX\n",{"type":40,"tag":105,"props":1074,"children":1075},{},[1076],{"type":46,"value":1077},"loads",{"type":46,"value":1079}," an algorithm the user supplies; the skill\nrefuses to invent algorithm bodies and routes any\n",{"type":40,"tag":105,"props":1081,"children":1082},{},[1083],{"type":46,"value":1084},"\"what algorithm should I write\"",{"type":46,"value":1086}," question to the\npublic DOCA SPCX \u002F DOCA PCC programming guides and\nto the user's own domain expertise.",{"type":40,"tag":224,"props":1088,"children":1089},{},[1090,1095],{"type":40,"tag":53,"props":1091,"children":1092},{},[1093],{"type":46,"value":1094},"Pre-baked example output",{"type":46,"value":1096}," (throughput \u002F latency\ncurves, per-flow counter snapshots). Output is\ndevice-, firmware-, fabric-topology-, and\nworkload-specific; pinning one would mislead\noperators elsewhere.",{"type":40,"tag":224,"props":1098,"children":1099},{},[1100,1113,1115,1120],{"type":40,"tag":53,"props":1101,"children":1102},{},[1103,1105,1111],{"type":46,"value":1104},"Specific flag strings, subcommand names,\nprobe-packet format tokens, or metric names beyond\nwhat the public DOCA SPCX page and ",{"type":40,"tag":61,"props":1106,"children":1108},{"className":1107},[],[1109],{"type":46,"value":1110},"--help",{"type":46,"value":1112},"\ndocument.",{"type":46,"value":1114}," The SPCX surface is the newer of the\nprogrammable-CC surfaces and the documented flag\nset evolves; the installed ",{"type":40,"tag":61,"props":1116,"children":1118},{"className":1117},[],[1119],{"type":46,"value":1110},{"type":46,"value":1121}," is the\nauthoritative inventory.",{"type":40,"tag":224,"props":1123,"children":1124},{},[1125,1130],{"type":40,"tag":53,"props":1126,"children":1127},{},[1128],{"type":46,"value":1129},"Wrappers, parsers, or scripts",{"type":46,"value":1131}," in any language\nthat consume the tool's output. The output format\nis documented; users who want to script against it\nshould read the live guide and write the parser\nagainst their installed version.",{"type":40,"tag":224,"props":1133,"children":1134},{},[1135,1140,1142,1147],{"type":40,"tag":53,"props":1136,"children":1137},{},[1138],{"type":46,"value":1139},"A specific tuning recommendation derived from a\nsingle observation.",{"type":46,"value":1141}," CC tuning on a live fabric\nis high-stakes; the skill prescribes how to\n",{"type":40,"tag":105,"props":1143,"children":1144},{},[1145],{"type":46,"value":1146},"capture evidence and compare against the factory\nPCC baseline",{"type":46,"value":1148}," and refuses to translate a single\nobservation into a parameter-change recommendation\nwithout the user's own domain analysis.",{"type":40,"tag":224,"props":1150,"children":1151},{},[1152,1173,1175,1180,1182,1190,1191,1199],{"type":40,"tag":53,"props":1153,"children":1154},{},[1155,1157,1163,1165,1171],{"type":46,"value":1156},"A ",{"type":40,"tag":61,"props":1158,"children":1160},{"className":1159},[],[1161],{"type":46,"value":1162},"samples\u002F",{"type":46,"value":1164}," or ",{"type":40,"tag":61,"props":1166,"children":1168},{"className":1167},[],[1169],{"type":46,"value":1170},"reference\u002F",{"type":46,"value":1172}," subtree.",{"type":46,"value":1174}," This is\na thin loader for a shipped CLI; substantive\nmaterial lives on the public page, in ",{"type":40,"tag":61,"props":1176,"children":1178},{"className":1177},[],[1179],{"type":46,"value":1110},{"type":46,"value":1181},",\nand in\n",{"type":40,"tag":70,"props":1183,"children":1184},{"href":167},[1185],{"type":40,"tag":61,"props":1186,"children":1188},{"className":1187},[],[1189],{"type":46,"value":115},{"type":46,"value":389},{"type":40,"tag":70,"props":1192,"children":1193},{"href":664},[1194],{"type":40,"tag":61,"props":1195,"children":1197},{"className":1196},[],[1198],{"type":46,"value":671},{"type":46,"value":199},{"type":40,"tag":201,"props":1201,"children":1203},{"id":1202},"loading-order",[1204],{"type":46,"value":1205},"Loading order",{"type":40,"tag":1207,"props":1208,"children":1209},"ol",{},[1210,1223,1236],{"type":40,"tag":224,"props":1211,"children":1212},{},[1213,1215,1221],{"type":46,"value":1214},"Read this ",{"type":40,"tag":61,"props":1216,"children":1218},{"className":1217},[],[1219],{"type":46,"value":1220},"SKILL.md",{"type":46,"value":1222}," first to confirm the user's\nquestion is in scope (SPCX-side custom CC work,\nnot factory firmware PCC, not raw DPA cycle\nprofiling, and not algorithm authoring detail).",{"type":40,"tag":224,"props":1224,"children":1225},{},[1226],{"type":40,"tag":53,"props":1227,"children":1228},{},[1229,1231,1235],{"type":46,"value":1230},"For the SPCX-vs-PCC decision tree, the authoring\nvs consumption split, the live-link precondition,\nthe version overlay, the error taxonomy, the\nobservability surface, and the safety posture,\nsee ",{"type":40,"tag":70,"props":1232,"children":1233},{"href":95},[1234],{"type":46,"value":95},{"type":46,"value":199},{"type":40,"tag":224,"props":1237,"children":1238},{},[1239],{"type":40,"tag":53,"props":1240,"children":1241},{},[1242,1244,1249,1250,1255,1256,1261,1262,1267,1268,1273,1274,1279,1280,1285,1286,1291,1293,1297],{"type":46,"value":1243},"For the documented invocations and the\nprepare → smoke → contention-positive evaluation\nworkflow — ",{"type":40,"tag":61,"props":1245,"children":1247},{"className":1246},[],[1248],{"type":46,"value":956},{"type":46,"value":126},{"type":40,"tag":61,"props":1251,"children":1253},{"className":1252},[],[1254],{"type":46,"value":964},{"type":46,"value":126},{"type":40,"tag":61,"props":1257,"children":1259},{"className":1258},[],[1260],{"type":46,"value":980},{"type":46,"value":119},{"type":40,"tag":61,"props":1263,"children":1265},{"className":1264},[],[1266],{"type":46,"value":988},{"type":46,"value":126},{"type":40,"tag":61,"props":1269,"children":1271},{"className":1270},[],[1272],{"type":46,"value":996},{"type":46,"value":126},{"type":40,"tag":61,"props":1275,"children":1277},{"className":1276},[],[1278],{"type":46,"value":1004},{"type":46,"value":126},{"type":40,"tag":61,"props":1281,"children":1283},{"className":1282},[],[1284],{"type":46,"value":1012},{"type":46,"value":126},{"type":40,"tag":61,"props":1287,"children":1289},{"className":1288},[],[1290],{"type":46,"value":1020},{"type":46,"value":1292}," — see\n",{"type":40,"tag":70,"props":1294,"children":1295},{"href":72},[1296],{"type":46,"value":72},{"type":46,"value":199},{"type":40,"tag":201,"props":1299,"children":1301},{"id":1300},"related-skills",[1302],{"type":46,"value":1303},"Related skills",{"type":40,"tag":220,"props":1305,"children":1306},{},[1307,1330,1343,1356,1371,1393,1423,1436,1480,1500,1522,1547],{"type":40,"tag":224,"props":1308,"children":1309},{},[1310,1318,1320,1328],{"type":40,"tag":70,"props":1311,"children":1312},{"href":167},[1313],{"type":40,"tag":61,"props":1314,"children":1316},{"className":1315},[],[1317],{"type":46,"value":115},{"type":46,"value":1319}," — the\nestablished host-side library for Programmable\nCongestion Control. The SPCX tool builds on and\nlinks this library; the SPCX-vs-PCC decision tree\nin\n",{"type":40,"tag":70,"props":1321,"children":1322},{"href":190},[1323],{"type":40,"tag":61,"props":1324,"children":1326},{"className":1325},[],[1327],{"type":46,"value":197},{"type":46,"value":1329},"\nis the load-bearing routing rule. Conflating the\ntwo is the most common programmable-CC first-touch\nerror.",{"type":40,"tag":224,"props":1331,"children":1332},{},[1333,1341],{"type":40,"tag":70,"props":1334,"children":1335},{"href":178},[1336],{"type":40,"tag":61,"props":1337,"children":1339},{"className":1338},[],[1340],{"type":46,"value":185},{"type":46,"value":1342},"\n— the shipped reference zero-touch RTT-based CC\nalgorithm. When the user wants to deploy a\ndocumented reference algorithm via the SPCX path\n(rather than author one), this is the\nalgorithm-side skill paired with this tool's\noperator-side workflow.",{"type":40,"tag":224,"props":1344,"children":1345},{},[1346,1354],{"type":40,"tag":70,"props":1347,"children":1348},{"href":664},[1349],{"type":40,"tag":61,"props":1350,"children":1352},{"className":1351},[],[1353],{"type":46,"value":671},{"type":46,"value":1355}," — the\nhost-side DPA control library the SPCX algorithm's\nDPA-side body builds on. For DPA-level questions\n(kernel-launch model, DPACC build flags, DPA-side\ncomms \u002F verbs), this is the skill the agent loads\nalongside.",{"type":40,"tag":224,"props":1357,"children":1358},{},[1359,1369],{"type":40,"tag":70,"props":1360,"children":1362},{"href":1361},"..\u002F..\u002Flibs\u002Fdoca-rdma\u002FSKILL.md",[1363],{"type":40,"tag":61,"props":1364,"children":1366},{"className":1365},[],[1367],{"type":46,"value":1368},"doca-rdma",{"type":46,"value":1370}," — the\nlibrary whose RDMA \u002F RoCE flows on the attached\nBlueField port the SPCX algorithm is controlling.\nWithout RDMA traffic in flight and contention on\nthe fabric, the algorithm has no signal — surface\nthis precondition with the user before any\nevaluation.",{"type":40,"tag":224,"props":1372,"children":1373},{},[1374,1384,1386,1391],{"type":40,"tag":70,"props":1375,"children":1377},{"href":1376},"..\u002Fdoca-pcc-counters\u002FSKILL.md",[1378],{"type":40,"tag":61,"props":1379,"children":1381},{"className":1380},[],[1382],{"type":46,"value":1383},"doca-pcc-counters",{"type":46,"value":1385}," —\nthe sibling tool for read-only PCC counter\ninspection. SPCX exposes its own runtime\nobservability surface; the PCC counter tool is the\ncheaper ",{"type":40,"tag":105,"props":1387,"children":1388},{},[1389],{"type":46,"value":1390},"\"is anything happening on this port\"",{"type":46,"value":1392},"\nfirst step before \u002F during an SPCX evaluation.",{"type":40,"tag":224,"props":1394,"children":1395},{},[1396,1406,1408,1414,1416,1421],{"type":40,"tag":70,"props":1397,"children":1399},{"href":1398},"..\u002F..\u002Fdoca-hardware-safety\u002FSKILL.md",[1400],{"type":40,"tag":61,"props":1401,"children":1403},{"className":1402},[],[1404],{"type":46,"value":1405},"doca-hardware-safety",{"type":46,"value":1407},"\n— the bundle-wide hardware-safety meta-policy\n(pre-flight inventory, OOB requirement,\nreplica-first, observability-before-workload,\nrollback discipline, escalation). The ",{"type":40,"tag":61,"props":1409,"children":1411},{"className":1410},[],[1412],{"type":46,"value":1413},"## Safety policy",{"type":46,"value":1415}," overlay in this skill is heavily layered\non the meta-policy; deploying a wrong CC algorithm\non a production fabric is a ",{"type":40,"tag":105,"props":1417,"children":1418},{},[1419],{"type":46,"value":1420},"meta-policy STOP",{"type":46,"value":1422},"\ncase.",{"type":40,"tag":224,"props":1424,"children":1425},{},[1426,1434],{"type":40,"tag":70,"props":1427,"children":1428},{"href":682},[1429],{"type":40,"tag":61,"props":1430,"children":1432},{"className":1431},[],[1433],{"type":46,"value":689},{"type":46,"value":1435},"\n— routing to the public DOCA SPCX programming\nguide, the public DOCA PCC programming guide, the\npublic DOCA DPA \u002F DPACC guides, and the rest of\nthe public DOCA documentation set.",{"type":40,"tag":224,"props":1437,"children":1438},{},[1439,1447,1449,1455,1457,1465,1467,1478],{"type":40,"tag":70,"props":1440,"children":1441},{"href":486},[1442],{"type":40,"tag":61,"props":1443,"children":1445},{"className":1444},[],[1446],{"type":46,"value":493},{"type":46,"value":1448}," —\ncanonical DOCA version-handling rules. The\n",{"type":40,"tag":61,"props":1450,"children":1452},{"className":1451},[],[1453],{"type":46,"value":1454},"## Version compatibility",{"type":46,"value":1456}," section in\n",{"type":40,"tag":70,"props":1458,"children":1459},{"href":95},[1460],{"type":40,"tag":61,"props":1461,"children":1463},{"className":1462},[],[1464],{"type":46,"value":95},{"type":46,"value":1466}," is a concise\noverlay that redirects here for the body and adds\nthe ",{"type":40,"tag":105,"props":1468,"children":1469},{},[1470,1471,1476],{"type":46,"value":500},{"type":40,"tag":61,"props":1472,"children":1474},{"className":1473},[],[1475],{"type":46,"value":115},{"type":46,"value":1477}," library ↔ DPACC ↔ firmware\ncustom-PCC slot",{"type":46,"value":1479}," matching rule.",{"type":40,"tag":224,"props":1481,"children":1482},{},[1483,1491,1493,1498],{"type":40,"tag":70,"props":1484,"children":1485},{"href":143},[1486],{"type":40,"tag":61,"props":1487,"children":1489},{"className":1488},[],[1490],{"type":46,"value":150},{"type":46,"value":1492}," — env\npreparation, install verification, DPACC compiler\ninstall \u002F verification, BlueField firmware\nconfiguration (custom-PCC slot enablement is a\nfirmware-level setting), and the ",{"type":40,"tag":105,"props":1494,"children":1495},{},[1496],{"type":46,"value":1497},"I have no\ninstall yet",{"type":46,"value":1499}," path with the public NGC DOCA\ncontainer.",{"type":40,"tag":224,"props":1501,"children":1502},{},[1503,1513,1515,1520],{"type":40,"tag":70,"props":1504,"children":1506},{"href":1505},"..\u002F..\u002Fdoca-debug\u002FSKILL.md",[1507],{"type":40,"tag":61,"props":1508,"children":1510},{"className":1509},[],[1511],{"type":46,"value":1512},"doca-debug",{"type":46,"value":1514}," — the\ncross-cutting debug ladder. SPCX-specific debug\nlayers on top of that ladder; cross-link the\ncaptured runtime evidence + counter snapshots\ninto a ",{"type":40,"tag":61,"props":1516,"children":1518},{"className":1517},[],[1519],{"type":46,"value":1512},{"type":46,"value":1521}," session when the cause is\nbelow DOCA.",{"type":40,"tag":224,"props":1523,"children":1524},{},[1525,1535,1537,1545],{"type":40,"tag":70,"props":1526,"children":1528},{"href":1527},"..\u002F..\u002Fdoca-structured-tools-contract\u002FSKILL.md",[1529],{"type":40,"tag":61,"props":1530,"children":1532},{"className":1531},[],[1533],{"type":46,"value":1534},"doca-structured-tools-contract",{"type":46,"value":1536},"\n— the bundle's detect → prefer → fall back →\nreport contract for structured helper tools. The\ncommand appendix in ",{"type":40,"tag":70,"props":1538,"children":1539},{"href":72},[1540],{"type":40,"tag":61,"props":1541,"children":1543},{"className":1542},[],[1544],{"type":46,"value":72},{"type":46,"value":1546},"\nhonors this contract.",{"type":40,"tag":224,"props":1548,"children":1549},{},[1550,1560,1562,1568],{"type":40,"tag":70,"props":1551,"children":1553},{"href":1552},"..\u002F..\u002Fdoca-programming-guide\u002FSKILL.md",[1554],{"type":40,"tag":61,"props":1555,"children":1557},{"className":1556},[],[1558],{"type":46,"value":1559},"doca-programming-guide",{"type":46,"value":1561},"\n— general DOCA programming patterns shared by\nevery library \u002F tool surface, including the\ncross-library ",{"type":40,"tag":61,"props":1563,"children":1565},{"className":1564},[],[1566],{"type":46,"value":1567},"DOCA_ERROR_*",{"type":46,"value":1569}," taxonomy this\ntool's host-side error layer overlays on top of.",{"type":40,"tag":49,"props":1571,"children":1572},{},[1573,1575,1580,1582,1587,1589,1597],{"type":46,"value":1574},"The default factory PCC algorithms shipped inside\nConnectX firmware are ",{"type":40,"tag":53,"props":1576,"children":1577},{},[1578],{"type":46,"value":1579},"not in scope",{"type":46,"value":1581}," for this skill —\nthose work without ",{"type":40,"tag":61,"props":1583,"children":1585},{"className":1584},[],[1586],{"type":46,"value":66},{"type":46,"value":1588}," and are configured\nthrough firmware-level knobs, not through any host-side\nlibrary or tool API. Route via\n",{"type":40,"tag":70,"props":1590,"children":1591},{"href":682},[1592],{"type":40,"tag":61,"props":1593,"children":1595},{"className":1594},[],[1596],{"type":46,"value":689},{"type":46,"value":1598},".\nConflating the factory PCC story with SPCX is the\nsingle most common programmable-CC first-touch error.",{"items":1600,"total":1702},[1601,1616,1630,1644,1656,1673,1688],{"slug":1602,"name":1602,"fn":1603,"description":1604,"org":1605,"tags":1606,"stars":20,"repoUrl":21,"updatedAt":1615},"accelerated-computing-cudf","accelerate data processing with cuDF","Official NVIDIA-authored guidance for NVIDIA cuDF GPU DataFrames, pandas acceleration, dask-cuDF, ETL, joins, groupby, CSV\u002FParquet I\u002FO, nullable semantics, and multi-GPU DataFrame workloads.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1607,1610,1613,1614],{"name":1608,"slug":1609,"type":15},"Data Analysis","data-analysis",{"name":1611,"slug":1612,"type":15},"Data Engineering","data-engineering",{"name":9,"slug":8,"type":15},{"name":13,"slug":14,"type":15},"2026-07-14T05:28:43.176466",{"slug":1617,"name":1617,"fn":1618,"description":1619,"org":1620,"tags":1621,"stars":20,"repoUrl":21,"updatedAt":1629},"aiq-deploy","deploy and manage NVIDIA AI-Q infrastructure","Use when asked to install, deploy, run, validate, troubleshoot, or stop NVIDIA AI-Q Blueprint infrastructure.\n",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1622,1625,1628],{"name":1623,"slug":1624,"type":15},"Deployment","deployment",{"name":1626,"slug":1627,"type":15},"Infrastructure","infrastructure",{"name":9,"slug":8,"type":15},"2026-07-14T05:29:06.667109",{"slug":1631,"name":1631,"fn":1632,"description":1633,"org":1634,"tags":1635,"stars":20,"repoUrl":21,"updatedAt":1643},"aiq-research","conduct deep research with AI-Q","Use when asked to run deep research or AI-Q research through a reachable NVIDIA AI-Q Blueprint backend.\n",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1636,1639,1640],{"name":1637,"slug":1638,"type":15},"Agents","agents",{"name":9,"slug":8,"type":15},{"name":1641,"slug":1642,"type":15},"Research","research","2026-07-14T05:28:06.816956",{"slug":1645,"name":1645,"fn":1646,"description":1647,"org":1648,"tags":1649,"stars":20,"repoUrl":21,"updatedAt":1655},"amc-run-sample-calibration","run AMC sample dataset calibration","Run end-to-end calibration on the shipped sample dataset (sdg_08_2_sample_data_010926.zip) against a running AMC microservice. Use when user says 'test sample dataset', 'run sample calibration', 'verify AMC install', or 'launch and test'.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1650,1651,1652],{"name":1608,"slug":1609,"type":15},{"name":9,"slug":8,"type":15},{"name":1653,"slug":1654,"type":15},"Testing","testing","2026-07-17T05:29:03.913266",{"slug":1657,"name":1657,"fn":1658,"description":1659,"org":1660,"tags":1661,"stars":20,"repoUrl":21,"updatedAt":1672},"amc-run-video-calibration","calibrate video datasets with AutoMagicCalib","Calibrate a new dataset from pre-recorded video files via the AutoMagicCalib REST API. Use when user has local MP4s and says 'calibrate my videos', 'run AMC on these videos', or similar. For RTSP\u002Flive streams, use amc-run-rtsp-calibration instead.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1662,1665,1668,1669],{"name":1663,"slug":1664,"type":15},"Automation","automation",{"name":1666,"slug":1667,"type":15},"Imaging","imaging",{"name":9,"slug":8,"type":15},{"name":1670,"slug":1671,"type":15},"Video","video","2026-07-17T05:28:53.905004",{"slug":1674,"name":1674,"fn":1675,"description":1676,"org":1677,"tags":1678,"stars":20,"repoUrl":21,"updatedAt":1687},"amc-setup-calibration-stack","deploy AutoMagicCalib microservice with Docker","Launch AutoMagicCalib microservice and web UI from NGC release images via Docker Compose. Use when user says 'deploy auto calibration', 'launch auto calibration', 'launch AMC', 'start MS+UI', or 'set up auto-magic-calib'. Requires NGC API key.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1679,1680,1683,1684],{"name":1623,"slug":1624,"type":15},{"name":1681,"slug":1682,"type":15},"Docker","docker",{"name":9,"slug":8,"type":15},{"name":1685,"slug":1686,"type":15},"Operations","operations","2026-07-17T05:28:56.913999",{"slug":1689,"name":1689,"fn":1690,"description":1691,"org":1692,"tags":1693,"stars":20,"repoUrl":21,"updatedAt":1701},"cudaq-guide","develop quantum applications with CUDA-Q","CUDA-Q onboarding guide for installation, test programs, GPU simulation, QPU hardware, and quantum applications.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1694,1695,1698],{"name":9,"slug":8,"type":15},{"name":1696,"slug":1697,"type":15},"Quantum Computing","quantum-computing",{"name":1699,"slug":1700,"type":15},"Simulation","simulation","2026-07-14T05:26:58.898253",305,{"items":1704,"total":1855},[1705,1723,1739,1750,1762,1776,1789,1803,1814,1823,1837,1846],{"slug":1706,"name":1706,"fn":1707,"description":1708,"org":1709,"tags":1710,"stars":1720,"repoUrl":1721,"updatedAt":1722},"nemoclaw-user-guide","retrieve NemoClaw documentation and configuration","Guides human users' AI agents to the NemoClaw docs MCP server and canonical Fern documentation in Markdown form. Use when users ask how to install, configure, operate, troubleshoot, secure, or learn NemoClaw with an AI coding assistant. Trigger keywords - nemoclaw docs, use nemoclaw with ai agent, nemoclaw mcp docs, nemoclaw install help, nemoclaw quickstart, nemoclaw markdown docs, llms.txt, agent skills.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1711,1714,1717],{"name":1712,"slug":1713,"type":15},"Documentation","documentation",{"name":1715,"slug":1716,"type":15},"MCP","mcp",{"name":1718,"slug":1719,"type":15},"Search","search",21777,"https:\u002F\u002Fgithub.com\u002FNVIDIA\u002FNemoClaw","2026-07-20T06:00:01.461044",{"slug":1724,"name":1724,"fn":1725,"description":1726,"org":1727,"tags":1728,"stars":1736,"repoUrl":1737,"updatedAt":1738},"mcore-build-and-dependency","manage Megatron-LM development environments","Container-based dev environment setup and dependency management for Megatron-LM. Covers acquiring and launching the CI container, uv package management, and updating uv.lock.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1729,1732,1733],{"name":1730,"slug":1731,"type":15},"Containers","containers",{"name":1623,"slug":1624,"type":15},{"name":1734,"slug":1735,"type":15},"Python","python",17049,"https:\u002F\u002Fgithub.com\u002FNVIDIA\u002FMegatron-LM","2026-07-27T06:06:11.249662",{"slug":1740,"name":1740,"fn":1741,"description":1742,"org":1743,"tags":1744,"stars":1736,"repoUrl":1737,"updatedAt":1749},"mcore-bump-base-image","update NVIDIA PyTorch base images","Bump the NVIDIA PyTorch base image (`nvcr.io\u002Fnvidia\u002Fpytorch:YY.MM-py3`) used by Megatron-LM CI. Covers the two pin sites (GitHub CI in `docker\u002F.ngc_version.dev` and GitLab CI in `.gitlab\u002Fstages\u002F01.build.yml`), the post-bump CI loop (re-run functional tests, refresh golden values, mark broken tests), and the gotchas that bit PRs",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1745,1748],{"name":1746,"slug":1747,"type":15},"CI\u002FCD","ci-cd",{"name":1623,"slug":1624,"type":15},"2026-07-14T05:25:59.97109",{"slug":1751,"name":1751,"fn":1752,"description":1753,"org":1754,"tags":1755,"stars":1736,"repoUrl":1737,"updatedAt":1761},"mcore-cicd","manage CI\u002FCD pipelines for Megatron-LM","CI\u002FCD reference for Megatron-LM. Covers CI pipeline structure, PR scope labels, triggering internal GitLab CI (which force-pushes the current branch to a pull-request\u002FBRANCH ref — always dry-run and verify the destination first; never run against shared or protected branches), and CI failure investigation.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1756,1757,1758],{"name":1746,"slug":1747,"type":15},{"name":1623,"slug":1624,"type":15},{"name":1759,"slug":1760,"type":15},"GitHub","github","2026-07-27T06:06:12.278222",{"slug":1763,"name":1763,"fn":1764,"description":1765,"org":1766,"tags":1767,"stars":1736,"repoUrl":1737,"updatedAt":1775},"mcore-create-issue","investigate CI failures and create issues","Investigate a failing GitHub Actions run or job and create a GitHub issue for the failure.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1768,1771,1772],{"name":1769,"slug":1770,"type":15},"Debugging","debugging",{"name":1759,"slug":1760,"type":15},{"name":1773,"slug":1774,"type":15},"Triage","triage","2026-07-14T05:25:57.442089",{"slug":1777,"name":1777,"fn":1778,"description":1779,"org":1780,"tags":1781,"stars":1736,"repoUrl":1737,"updatedAt":1788},"mcore-linting-and-formatting","lint and format Megatron-LM code","Linting and formatting for Megatron-LM. Covers running autoformat.sh, tools (ruff, black, isort, pylint, mypy), and code style rules.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1782,1785],{"name":1783,"slug":1784,"type":15},"Best Practices","best-practices",{"name":1786,"slug":1787,"type":15},"Code Analysis","code-analysis","2026-07-14T05:25:56.18433",{"slug":1790,"name":1790,"fn":1791,"description":1792,"org":1793,"tags":1794,"stars":1736,"repoUrl":1737,"updatedAt":1802},"mcore-migrate-gpt-to-hybrid","migrate Megatron-LM models to HybridModel","Migration guide for moving Megatron Core GPTModel checkpoints, model providers, training commands, and layer mappings to HybridModel.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1795,1798,1801],{"name":1796,"slug":1797,"type":15},"Machine Learning","machine-learning",{"name":1799,"slug":1800,"type":15},"Migration","migration",{"name":9,"slug":8,"type":15},"2026-07-17T06:07:11.777011",{"slug":1804,"name":1804,"fn":1805,"description":1806,"org":1807,"tags":1808,"stars":1736,"repoUrl":1737,"updatedAt":1813},"mcore-onboard-gb200-1node-tests","onboard functional tests for GB200","Onboard 1-node GitHub MR functional tests for GB200 from existing mr-scoped 2-node tests.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1809,1812],{"name":1810,"slug":1811,"type":15},"QA","qa",{"name":1653,"slug":1654,"type":15},"2026-07-14T05:25:53.673039",{"slug":1815,"name":1815,"fn":1816,"description":1817,"org":1818,"tags":1819,"stars":1736,"repoUrl":1737,"updatedAt":1822},"mcore-run-on-slurm","launch distributed training jobs on SLURM","How to launch distributed Megatron-LM training jobs on a SLURM cluster. Covers a minimal sbatch skeleton, environment-variable setup for torch.distributed.run, CUDA_DEVICE_MAX_CONNECTIONS rules across hardware and parallelism modes, container conventions, monitoring, and per-rank failure diagnosis.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1820,1821],{"name":1623,"slug":1624,"type":15},{"name":1626,"slug":1627,"type":15},"2026-07-14T05:25:49.362534",{"slug":1824,"name":1824,"fn":1825,"description":1826,"org":1827,"tags":1828,"stars":1736,"repoUrl":1737,"updatedAt":1836},"mcore-split-pr","split pull requests to reduce review load","Split a PR into multiple PRs to reduce the number of required CODEOWNERS reviewer groups.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1829,1832,1833],{"name":1830,"slug":1831,"type":15},"Code Review","code-review",{"name":1759,"slug":1760,"type":15},{"name":1834,"slug":1835,"type":15},"Pull Requests","pull-requests","2026-07-14T05:26:01.226578",{"slug":1838,"name":1838,"fn":1839,"description":1840,"org":1841,"tags":1842,"stars":1736,"repoUrl":1737,"updatedAt":1845},"mcore-testing","run and manage Megatron-LM tests","Test system for Megatron-LM. Covers test layout, recipe YAML structure, adding and running unit and functional tests, golden values, marker filters, and CI parity.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1843,1844],{"name":1810,"slug":1811,"type":15},{"name":1653,"slug":1654,"type":15},"2026-07-14T05:25:54.928983",{"slug":1847,"name":1847,"fn":1848,"description":1849,"org":1850,"tags":1851,"stars":1736,"repoUrl":1737,"updatedAt":1854},"nightly-sync","manage nightly main-to-dev sync workflows","Domain knowledge for the nightly main-to-dev sync workflow. Covers merge strategy, CI architecture, failure investigation, and known issues.",{"slug":8,"name":9,"logoUrl":10,"githubOrg":9},[1852,1853],{"name":1663,"slug":1664,"type":15},{"name":1746,"slug":1747,"type":15},"2026-07-30T05:29:03.275638",496]