NVIDIA has published a deployment guide that lets enterprises connect video analytics directly to Jira and other business systems, automatically turning footage findings into actionable tickets, reports, and escalations. The new integration, based on the Video Search and Summarization (VSS) agent version 3.2.0, combines retrieval-augmented generation (RAG) and the NemoClaw orchestration framework to move beyond static video summaries. In one real-world use, partner Computacenter cut footage-to-work-order time from 30–45 minutes to roughly 19 seconds across multiple asset classes.

The setup means a factory's inspection video can be checked against OEM maintenance procedures and a work order drafted in seconds. While the stack runs primarily on Linux, Windows administrators will find it relevant as a management endpoint or destination for downstream business systems, making it a practical addition to hybrid infrastructure.

What Exactly Changed?

NVIDIA’s latest VSS agent (3.2.0) introduces guided, context-aware video analysis that ends in structured action rather than just a report. The workflow starts with a user—or an automated job—defining what to look for in a video: the scenario, events of interest, objects to track, and optional reference documents to consult. VSS processes live or archived footage, while the RAG component retrieves relevant internal documents such as operating procedures, manuals, or policies. NemoClaw then orchestrates everything, producing a timestamped report that can include detected events, narrative findings, citations, and recommended next steps—and, crucially, it can automatically open a Jira ticket or trigger another workflow.

Three agent tools work together under VSS 3.2.0:
- Long video summary (LVS): Collects user intent through human-in-the-loop (HITL) prompts or programmatic input, then performs hierarchical video summarization.
- Knowledge retrieval (frag): Queries the RAG Blueprint for organization-specific context from indexed documents.
- Report generation: Combines video analysis and retrieved context into a structured, timestamped report with citations.

NemoClaw then reads that report and can create Jira tickets, escalate anomalies, bundle evidence for compliance, or route patterns into other business processes. The NVIDIA blueprint treats video understanding as a trigger for coordinated action across existing enterprise tools, not a dead-end analysis.

Why This Matters for Windows IT Environments

While the VSS stack itself is Linux-first (it requires Docker, an NVIDIA GPU with at least 24GB of VRAM, and several microservices), the downstream impact lands squarely in the Windows world. Jira, ServiceNow, Slack, and other business applications often run on or are accessed from Windows endpoints. Administrators can manage the stack remotely from Windows workstations, and the automated tickets or alerts appear in the same tools teams already use.

For enterprise IT professionals, this means:
- Hybrid infrastructure teams can deploy the AI pipeline on GPU-capable Linux servers or edge appliances but control and monitor everything from Windows.
- DevOps engineers can script entire video-to-ticket loops that feed into existing Windows-based CI/CD or incident management tools.
- Security and facilities managers can set up automated alerting from camera feeds directly into their Windows-based operations centers, with full audit trails.

NVIDIA’s published architecture keeps human approval available before analysis and report creation, but it also supports fully programmatic supply of parameters for batch jobs. However, the quality of the downstream action depends on both the video model’s interpretation and the accuracy of the documents indexed by the RAG system. Administrators should treat automated ticket creation as controlled workflow steps, with review and authorization rules appropriate to the consequences.

The Technology Stack: How It All Fits Together

The deployment guide reveals a modular, composable architecture:

  • VSS agent (3.2.0): Handles video ingestion, search, understanding, and the three core tools (LVS, knowledge retrieval, report generation). It exposes a health endpoint on port 8000.
  • RAG Blueprint: A separate deployment that indexes enterprise documents into a GPU-accelerated vector store (Milvus) and exposes a search API. The agent calls it via RAG_SERVER_URL.
  • NemoClaw agent framework: Orchestrates the entire workflow, applying sandbox policies and skills. It connects to VSS on port 8000 and can be driven through a terminal UI.
  • Supporting services: Redis, Elasticsearch, Kafka, and NVIDIA inference microservices (NeMo LLM, Visual Language Model) all run in Docker containers, managed via Docker Compose.

The published configuration supports hardware profiles including H100, L40S, RTX Pro cards, DGX Spark, and certain edge platforms. The stack requires Docker Engine with Compose v2, an NGC API key, and an NVIDIA Build API key.

From Video to Ticket: A Step-by-Step Breakdown

NVIDIA’s example uses a “healthy eating coach” to illustrate the flow, but the pattern generalizes directly to industrial inspection, security, or retail:

  1. Video upload and intent capture: A user drops a video into the VSS interface and answers HITL prompts (scenario, events, objects, knowledge query). For automated runs, these are supplied programmatically.
  2. Knowledge retrieval: The agent calls the RAG Blueprint with the knowledge query; the blueprint returns relevant snippets from indexed documents.
  3. Video summarization: The LVS service processes the video hierarchically, weaving in the retrieved context.
  4. Report generation: A structured, timestamped report is produced with narrative analysis, citations, and recommended actions.
  5. Orchestration and action: NemoClaw reads the report, creates a Jira ticket with the findings and recommendations, and can also send notifications or escalate anomalies.

Computacenter’s predictive maintenance use case follows the same pattern but at scale: drone, borescope, and thermal inspection footage is analyzed with OEM context from the RAG Blueprint, and NemoClaw auto-drafts IBM Maximo work orders. The company reported slashing the footage-to-work-order time from 30–45 minutes to about 19 seconds across four asset classes.

Potential Pitfalls and Prerequisites

Adopting this blueprint isn’t a simple software install. Key considerations:

  • GPU requirements: A minimum of 24GB VRAM per GPU; the guide recommends H100 or L40S for production. Even with hardware, the inference microservices take 5–15 minutes to load after deployment.
  • Document quality: If the RAG Blueprint indexes outdated or incorrect manuals, policies, or SOPs, the generated reports and tickets will be flawed. A thorough document curation process is essential.
  • Network and security: The RAG Blueprint must be reachable from the VSS agent, and both must be secured. NemoClaw’s sandbox policy should be reviewed to limit agent access appropriately.
  • HITL vs. automation: While fully automatic ticket creation is possible, NVIDIA’s design retains human-in-the-loop prompts for the LVS tool. Enterprises should start with a human-approval step for critical workflows and gradually automate as confidence grows.

Getting Started: Deployment Overview

For Windows administrators or DevOps teams looking to pilot this, the following streamlined steps are based on NVIDIA’s official guide. All commands assume a Linux host (physical or VM) with Docker and an NVIDIA GPU.

1. Clone the VSS repository and authenticate 

git clone https://github.com/NVIDIA-AI-Blueprints/video-search-and-summarization.git ~/vss-public
cd ~/vss-public
echo \"$NGC_CLI_API_KEY\" | docker login nvcr.io --username '$oauthtoken' --password-stdin

2. Configure the environment

Edit deploy/docker/developer-profiles/dev-profile-lvs/.env. Set your paths, hardware profile (H100, L40S, etc.), and enable the RAG configuration:

VSS_AGENT_VERSION=3.2.0
VSS_AGENT_CONFIG_FILE=./deploy/docker/developer-profiles/dev-profile-lvs/vss-agent/configs/config_rag.yml
RAG_SERVER_URL='http://<RAG_SERVER>:8081/v1'
RAG_API_KEY='<YOUR_RAG_API_KEY>'
KNOWLEDGE_COLLECTION='<YOUR_COLLECTION>'

The three RAG_ values are all the agent needs; the RAG Blueprint handles embedding, reranking, and vector search internally.

3. Deploy the VSS stack

Use the helper script or docker compose directly:

cd ~/vss-public/deploy/docker
./scripts/dev-profile.sh up --profile lvs --hardware-profile H100

This brings up all infrastructure: Redis, Elasticsearch, the LVS service, NVIDIA inference microservices, and the VSS agent itself.

4. Verify service health

Wait up to 15 minutes for the NIMs to load, then check:

curl -sS http://localhost:8000/health   # VSS agent
curl -f http://127.0.0.1:38111/v1/ready # LVS backend

5. Install NemoClaw and test

From the VSS repo root, run the installer:

NEMOCLAW_PROVIDER=build \\
NVIDIA_API_KEY=\"$NVIDIA_API_KEY\" \\
bash deploy/docker/scripts/nemoclaw/init_nemoclaw.sh demo

Then connect to the NemoClaw TUI and start a session:

nemoclaw SANDBOX_NAME connect openclaw tui
/ new
I want to generate a video summary report for <VIDEO_NAME>.

The agent will walk through the HITL prompts and create a Jira ticket if configured.

6. Integrate with your enterprise tools

Modify the skill definition (SKILL.md) to point NemoClaw to your own Jira instance, Slack channels, or other systems. Start with a single tightly scoped workflow—for example, a specific camera feed for quality control—and validate report accuracy, permissions, and escalation logic before expanding.

The Road Ahead

NVIDIA’s publication of VSS 3.2.0 with these integrations marks a clear pivot: video analytics is no longer about generating passive reports but about driving real-time, auditable business actions. As GPU infrastructure becomes more accessible and edge devices grow in capability, we can expect these blueprints to land in more Windows-managed environments, from manufacturing floors to retail.

The immediate next step for IT administrators is to pilot a single video-to-ticket loop, measure its accuracy and business value, and then scale thoughtfully. NVIDIA has provided the composable pieces; the onus is now on enterprises to wire them into their existing workflows and governance frameworks.