AI coding agents are increasingly used in development workflows, but general-purpose agents lack domain-specific knowledge for infrastructure software such as NVIDIA DOCA. Without DOCA-specific information, agents often resort to guesswork, which in infrastructure projects turns each correction cycle into lost deployment time.
DOCA is the unified software platform that enables the full capabilities of NVIDIA BlueField data processing units (DPUs). It covers accelerated networking, AI-native storage, in-silicon security, telemetry, and lifecycle management, and serves as the development platform for teams building on BlueField.
NVIDIA has published DOCA AI agent skills on GitHub (NVIDIA/skills). These skills provide a machine-readable, structured foundation so agents can work from verified API signatures, hardware capability requirements, and build constraints rather than general training patterns.
What are DOCA AI agent skills?
DOCA AI agent skills are a lightweight, standardized format that gives AI agents targeted expertise. Each skill is organized around a SKILL.md file containing actual DOCA API signatures, hardware capability manifests, and build constraints. Together, the skills form an operational and reasoning framework for DOCA development.
The skills cover the DOCA library surface—Flow, GPUNetIO, PCC, and more. They don’t replace an agent; they provide the domain knowledge that lets an agent reason like an experienced DOCA developer.
Each skill is scoped to a specific DOCA component or workflow. For example, a DOCA Flow skill supplies real function signatures, the correct pkg-config module names, build-container constraints, common failure modes, and mitigations. These skills are not mere documentation summaries but machine-readable specifications the agent can use directly.
Why do AI agents need a foundation for DOCA development?
When a general-purpose AI agent is asked to perform DOCA-specific tasks—create a DOCA Comch, configure an RDMA context, or debug a DOCA Flow link failure—it typically relies on pattern matching from its training data, not on verified DOCA API contracts, hardware manifests, or build specifications. The DOCA surface is large, fast-moving, and hardware-specific in ways generic training data does not capture. There is no machine-readable contract for agents to reason from and no guaranteed stable interface between what the agent knows and what the hardware and software actually support.
To measure this gap, NVIDIA ran 65 real DOCA developer prompts comparing agent performance with and without skills. Prompts ranged from single-line questions to detailed, multi-requirement tasks, and were graded against a required-answer checklist (pass/fail criteria for each task). Without skills, agents repeatedly made the same errors:
- Misuse of APIs and flags: 59/65 prompts
- Hardware capability not verified: 46/65 prompts
- Wrong tool routing: 39/65 prompts
- Skipped smoke tests: 34/65 prompts
- Guessed versions: 30/65 prompts
Overall, agents without skills satisfied only 19% of graded checklist items on real DOCA tasks. Agents with skills satisfied 100% across all 65 prompts. Without skills, each agent mistake typically became a developer debugging session and extended the path to working code.
Benefits for developers
DOCA agent skills let you equip agents with domain expertise so you can build faster, ship more stable code, and deploy with fewer unknowns:
- Build faster: the agent uses verified API calls from the start, reducing time spent on corrections.
- Ship more stable code: the agent checks device support before writing any code rather than after running on hardware.
- Deploy with fewer unknowns: the agent applies preflight checks, rollback plans, and cold power-cycle awareness before touching hardware.
Fewer correction cycles compound across teams, tasks, and deployments when agents are used at scale.
Four capability areas illustrated with prompts
The publication details four capability areas, each shown with an example prompt and the benefits of using the relevant skill.
Build faster with real APIs
Problem addressed: agents inventing nonexistent functions, flags, and image tags. This was the most frequent misstep (59/65 prompts). Without skills, agents generate code that references DOCA functions that don’t exist, incorrect flag names, and image tags that fail at runtime.
Example prompt: setting up a DOCA Comch (Comm channel) between a host-side process and a DPU-side agent to exchange small control messages (under 4 KiB each).
An agent with the DOCA Comch skill uses only real DOCA Comch API calls—correct argument order, verified flags and lifecycle sequence, nothing invented. When the agent’s first response uses the correct API surface, developers can move directly to integration instead of starting with debugging. Across 63 prompts that tested API accuracy, the with-skills result was better every time.
Verify hardware before writing any code
Problem addressed: agents writing code for features the device doesn’t support. Hardware capability verification was missed in 46/65 prompts without skills. The agent often assumes a capability is present and generates code that later fails on real hardware.
Example prompt: two hosts connected by a high-speed InfiniBand fabric, each with an NVIDIA GPU and a ConnectX NIC, DOCA installed; measure RDMA WRITE latency when the WR is posted from a CUDA kernel so the developer can decide whether to use the GPUNetIO Verbs interface.
An agent with skills checks the device’s actual support before writing code: it verifies GPU–NIC PCIe topology, confirms GPUNetIO support, and names alternative API surfaces and their applicable situations.
Ship code that compiles and links
Problem addressed: agents producing code that won’t compile or link in the DOCA container. Build correctness was tested in 10 prompts; when it fails, development cannot proceed.
Example prompt: building a DOCA Flow sample where the compile step succeeds but linking fails with an undefined reference to doca_flow_init.
A with-skills agent identifies the issue as a link-time failure and uses the build tool (pkg-config) to retrieve correct linker flags for doca-flow. An agent that invents an incorrect linker flag leads the developer down an unresolvable path; the with-skills agent immediately names the correct diagnostic approach and tool.
Execute hardware-affecting changes safely
Problem addressed: agents applying firmware-level changes on live hardware without preflight checks, rollback plans, or cold power-cycle awareness. The largest performance gap appeared in the highest-complexity scenario—firmware-level changes on live hardware.
Example prompt: a production BlueField-3 DPU running a DOCA workload; the next step is to write an mlxconfig-class firmware-level parameter.
The with-skills agent applies the full discipline required for firmware changes: preflight inventory, assuming an out-of-band (OOB) path as a precondition, an explicit maintenance window, a rollback plan, and noting that mlxconfig-class writes take effect only on a cold power cycle, not a warm reboot. The with-skills agent met every requirement; the without-skills agent met none. On a live production DPU, these misses are not recoverable debugging steps.
Measured efficiency gains
Across all 65 prompts, agents equipped with DOCA skills reached the correct answer every time, reducing correction cycles and speeding time to working code. In a side-by-side demo, two agents were tasked with building a Go-based RDMA application using NVIDIA DOCA on a BlueField-3 platform. Both completed the task, but the with-skills agent produced 73% less handwritten code (189 lines versus 695) and executed roughly half the hardware commands (20 versus 37, a 46% reduction).
How to get started
DOCA AI agent skills provide the domain knowledge agents need to succeed and let teams build with greater efficiency and accuracy. To get started, visit the NVIDIA/skills GitHub repository and explore the general skills for a quick onramp and the library-specific skills for DOCA Flow, GPUNetIO, RDMA, and more.
