Alert Investigation Board:從 Agent 交接到共享證據,構建安全警報調查看板
From Agent Handoffs to Shared Evidence: Building a Security Alert Investigation Board
作者為 NVIDIA hackathon 構建 Alert Investigation Board 原型,以共享案件看板協調三名專責 Agent 收集和呈現安全警報證據,並由確定性驗證器核對受支援的聲明。原型以 vLLM 本機部署 Nemotron 3 Nano FP8,使用合成警報及證據;Agent 只可提出行動,批准由人員負責。示範未連接外部遏止 API,亦未提供可重現的效能數據。
The business problem: an alert is only useful if someone can investigate it
Security teams receive more alerts than they can investigate deeply. The operational problem is not simply getting an AI to summarize an alert. An investigation needs context from identity, network activity, recent changes, and asset records—and the analyst needs to see where each conclusion came from before deciding what to do.
For the NVIDIA hackathon, I built Alert Investigation Board, a solo prototype for that investigation step. Its goal is to help an analyst reach a reviewable, evidence-backed decision sooner. It does not claim a measured reduction in investigation time or false positives: the demo uses synthetic records, and the performance figures in the submission packet are not yet tied to a reproducible, versioned raw-results artifact.
The key business boundary is simple: agents can gather and explain evidence; they cannot approve containment. The prototype records a human approval in its demo state and does not call an external containment API.
Three specialists, one shared case
The demo alert is investigated by three focused workers:
- Identity checks principal and token context.
- Runner and network checks registration and source-network context.
- Change and asset checks approved changes, credential activity, and asset classification.
They do not hand free-form messages to one another. Each receives its bounded work, reads its allowlisted evidence projection, and posts typed claims with source references to the case board. A deterministic verifier checks supported claim types against the synthetic records. The analyst can inspect the claims, provenance, verification verdicts, and proposed action together.
The persisted case is authoritative. Redis Streams deliver worker jobs; GraphQL subscriptions are best-effort notifications for the viewer, which refetches persisted state after reconnecting.
Why use a blackboard instead of a supervisor?
A supervisor model can decide which specialist to call, carry context between calls, and summarize the final answer. That can be a sensible choice. It also makes the coordinating model a central dependency for both task flow and the story told about each finding.
The blackboard pattern puts shared work in an explicit, typed place. Application code still handles authentication, task creation, delivery, retries, and permissions; the design does not remove orchestration. It removes the need for a central model to relay every specialist conversation. That makes contributions easier to inspect and gives each worker a narrow contract.
It also gives agent sprawl a concrete limit: the application defines three roles and their allowed fields. A worker cannot invent another worker or delegate freely. This is not a universal replacement for supervisor designs; it is a useful fit when independent evidence gathering and auditability matter more than open-ended delegation.
What is actually running
The prototype ran on NVIDIA LaunchPad with two H100 GPUs available to the environment. The language model used in the live demo was Nemotron 3 Nano FP8 served locally by vLLM. It was not an NVIDIA NIM deployment, and the GPUs were environment resources rather than a claim about per-request hardware utilization.
The application stack is Python, FastAPI, Strawberry GraphQL, PostgreSQL, Redis Streams, and NeMo Guardrails. A PostgreSQL outbox records specialist work before it is dispatched to Redis Streams. The worker consumers are separate from GraphQL subscriptions, which only notify the analyst UI that persisted case state changed.
The poisoned annotation: contain the instruction, keep the evidence
One synthetic alert includes attacker-controlled annotation text that tries to redirect the investigation. The important design decision is that raw annotation content is omitted from specialist prompts even when screening allows it. If screening cannot initialize or complete, the worker omits the annotation and continues with structured evidence.
The demonstrated short instruction override is caught by a deterministic phrase rule before the NeMo Guardrails heuristic runs. I describe this honestly as layered screening, not as NeMo Guardrails alone catching that exact phrase and not as prompt injection being solved. Guardrails provide an additional heuristic check; the typed verifier checks supported claims against records; neither proves that every malicious instruction is harmless.
Human authority is enforced in the application
Agents may propose an action, but the demo's authorization path restricts approval to the human role. The decision is recorded in the board. That control is demonstrated against the prototype's own API and data model; it is not a connection to a real identity provider or containment system. This distinction matters: a compelling demo should make the boundary visible without implying that a simulated approval has changed a real security environment.
What I learned
The strongest part of the design is not “more agents.” It is making their work bounded and inspectable: typed claims, evidence references, a verifier with a narrow job, and a human at the action boundary. GraphQL gives the case a clear typed interface, while PostgreSQL and the outbox keep workflow state durable.
The next evaluation should pin a source revision, preserve per-alert outputs, and compare the deployed blackboard path with a supervisor on the same fixtures. Until that is reproducible, I am leaving performance claims out. The current demonstration shows the workflow and its controls; it does not establish production impact.
Try it
All examples use synthetic alerts and evidence. The demo does not perform external containment.
來源:DEV Community · dev.to
