cd /news/ai-agents/from-agent-handoffs-to-shared-eviden… · home › topics › ai-agents › article
[ARTICLE · art-173648] src=dev.to ↗ pub= topic=ai-agents verified=true sentiment=↑ positive

From Agent Handoffs to Shared Evidence: Building a Security Alert Investigation Board

A developer built Alert Investigation Board, a solo prototype for the NVIDIA hackathon that coordinates three specialist AI workers through a shared, typed evidence board rather than free-form agent handoffs, letting a security analyst review claims, provenance and verification verdicts before approving any containment action. The prototype ran on NVIDIA LaunchPad with two H100 GPUs, using Nemotron 3 Nano FP8 served locally by vLLM, with a stack of Python, FastAPI, Strawberry GraphQL, PostgreSQL, Redis Streams and NeMo Guardrails. The developer stresses the demo uses synthetic records and that layered screening—a deterministic phrase rule plus NeMo Guardrails heuristics and a typed verifier—does not solve prompt injection.

recommendation

When independent evidence gathering and auditability matter more than open-ended delegation, give each worker a narrow typed contract and an allowlisted evidence projection, persist the case as authoritative, and treat subscriptions as best-effort notifications.

more in playbook: Designing agent systems
by read4 min views1 publishedNov 21, 2026

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.

The demo alert is investigated by three focused workers:

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.

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.

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.

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.

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.

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.

All examples use synthetic alerts and evidence. The demo does not perform external containment.

── more in #ai-agents 4 stories · sorted by recency
── more on @nvidia 3 stories trending now
sponsored brought to you by zahid.host 4,200+ EU-deployed projects
reading about agents? ship yours in a single git push.

Run your AI side-project on zahid.host

EU-based hosting, git-push deploys, automatic HTTPS, no cold starts. Free tier with a custom domain — perfect for shipping the agent you just read about.

$git push zahid main
→ Live at https://your-agent.zahid.host ✓
Get free account → Pricing
from €0/mo · no card required
LIVE [news/from-agent-handoffs-…] indexed:0 read:4min 2026-11-21 · —