
Claura is incident response for AI data centers. NVIDIA Nemotron agents run inside the facility and contain a breached GPU host under policy. The humans coordinate from a command center that lives outside the compromised network, so everyone works from one live record.
Try it: Console demo (works on a phone too) · Landing page · Code: github.com/zero-abd/claura
Tracks: Winstead PC (Cyber Incident Response Dashboard) · NVIDIA (Use Nemotron Beyond a Chatbot) · NMC^2 (Data Center Safety) · Best Design
What's real and what's simulated. Real: the console, the SpacetimeDB module on Maincloud (database
claura, which holds all incident state, identities, roles, the policy gate, the War Room, data scope and documentation), four agents driven by Nemotron running locally, and the Secure Shell certificate flow. Simulated: the attack telemetry is a replayed fixture, containment changes state in the database instead of touching real hypervisors, and the shell targets are real OpenSSH daemons in sandboxes standing in for GPU hosts. The replay's 9.4 s clock, its 2,048 hosts and its 61,207 agent sandboxes are illustrative, and so are the log excerpts and scores in the evidence viewer. What we measured on a laptop with a local 4B model against Maincloud: about 38 to 50 s from first signal to contained, including a human approval, and about 335 ms for a click on one console to show up on another.

Winstead's brief told us to assume the worst: the attacker can read normal communications, ransomware has locked the data, phones are down, email is unreliable and nobody knows what's going on. That's a real playbook. CISA and the FBI describe a group, Scattered Spider, that searches victims' Slack, Teams and Exchange for talk about the response and "frequently join[s] incident remediation and response calls" (CISA AA23-320A). The SIEM, the tickets, the chat, the bridge call, the runbook on the file share and the long-lived SSH keys all sit on the network the attacker already owns. You can't run an investigation in front of the suspect.
Then we moved that night into an AI data center. One GPU host there runs many customers' workloads, and only software keeps them apart. On 30 Sep 2026 NVIDIA disclosed CVE-2026-47498, which lets a user inside a guest VM trigger an out-of-bounds write in the host's vGPU Manager (NVD). A year earlier, Wiz's NVIDIAScape showed a three-line Dockerfile getting root on a GPU host (The Hacker News). Attackers are getting faster: in a campaign Anthropic disrupted, AI did 80 to 90 percent of the work (Anthropic), and the fastest breakout CrowdStrike recorded in 2025 took 27 seconds (CrowdStrike).
So we set four rules. A machine responds first. A human has the last word. Policy decides everything in between. The command post lives outside the crime scene.

Claura turns a scattered attack into one incident, one policy-gated containment decision and one live record for every responder. In the demo, one customer's AI workload tries to break out of its virtual machine onto the GPU host it shares with eleven other tenants. Claura's agents spot it in the telemetry, work out who could be affected and propose containment. Policy and one human approval decide what actually happens, and every stakeholder coordinates from a command plane hosted outside the compromised network.
The machine side
- Overview. A 3D data center you can click through, from halls to racks to hosts, with the suspect host lit up.
- Four defender agents on NVIDIA Nemotron, running in the facility. Sentry correlates six weak signals (an IOMMU fault, a vGPU driver fault, a suspicious ioctl, qemu spawning a shell, a flow to the management port and a token used outside its scope) and opens the incident. Triage checks host inventory and reachability and records the blast radius: one host, eleven co-resident tenants. Warden proposes containment with reversible steps first: isolate the network, revoke credentials, cordon the host, pause the guest, capture memory and move the neighbors to clean hosts. In the demo these steps are recorded as state in SpacetimeDB, not executed on real hardware. Scribe writes the plain-language brief and the shift handoff.
- A policy gate the model can't argue with. Every agent action is a proposal to a SpacetimeDB reducer, which rules on it from the policy table: auto, needs approval or denied. Unknown actions and hosts that don't exist are refused by default. A labelled red-team probe from our test harness (not Nemotron) asks to reimage the host, and the gate denies it.
- One human step. Quarantining the host needs a person. Evidence, scope and rollback sit on one card, approved with Cmd+Enter on a laptop or one tap on a phone.
- Evidence you can open. Each evidence file on the card opens in a read-only terminal: the memory image, the qemu core dump and the packet capture, each with its hash and chain of custody. "Why quarantine?" opens a decision trace that shows the raw log lines with the flagged tokens highlighted, how the six flags were correlated into an incident, and how the policy ruled on every proposed action. In the replay this content is a labelled fixture.
The human side (Winstead's five requirements)
| Requirement | What Claura does |
|---|---|
| Highly secure, isolated from a compromised network | The command plane runs outside the corporate network on SpacetimeDB and doesn't depend on corporate SSO, email or phones. Approvals and admin actions are identity-checked inside the reducers, and only admins can add people or change policy. |
| Access control, admin adds individuals | People & Access: the admin adds someone, such as outside counsel, with a role and a single-use break-glass enrollment code. No email, phone or SSO is involved, and the access event goes into the audit log. |
| Documentation to incident standards, real-time status | Reports: the incident record follows NIST SP 800-61, with live phase status, a SHA-256 chain of custody for evidence and a PDF export for counsel. |
| Scope of compromised data and its status | Data Scope: every data asset has a status: intact, accessed, exfiltration suspected, exfiltration confirmed, locked by ransomware, restored or evidence preserved. |
| Real-time communications | War Room: channels for #command, #legal, #exec, #comms-pr and #vendors, Scribe's brief ("what we know / what we don't know yet"), tasks with owners, a decision log of who decided what and when, and example notification clocks marked "confirm with counsel". Every console updates live. Counsel, not the software, decides what's privileged and who sees it. |
Secure Shell. Click a host and Claura's own SSH certificate authority issues a short-lived OpenSSH user certificate. The host proves itself with a CA-signed host certificate, so there's no trust-on-first-use. Connecting needs a passkey or Touch ID, a suspect host also needs a second approver and only accepts a read-only forensic login, and every session is recorded in a hash-chained ledger.
From a phone. The whole console works on a phone, with a bottom tab bar, a tap-to-approve sheet and the War Room in one column, because incidents don't wait for someone to get to a desk.
Also built. Ask Claura is push-to-talk voice in the console and it's read-only, so it can't approve anything. With the local gateway, Nemotron answers from the incident record and ElevenLabs speaks the answer. On the hosted demo, answers are drawn straight from the incident record without a model and ElevenLabs speaks them, and the panel says so. Evidence anchoring writes the SHA-256 of the incident record to a Solana devnet Memo transaction and can read the chain back to verify it. The code and its checks are done. The live send waits on devnet funding, so for now the console labels the anchor "Simulated" and leaves it out of the PDF.

IN THE FACILITY (next to the hardware) OUT OF BAND (outside the corporate network)
Agent runner (Node + TypeScript) ── reducers ──▶ SpacetimeDB module on Maincloud
Nemotron 3 Nano 4B via Ollama ◀─ subscribe ── tables: hosts, guests, signals, incidents,
Sentry · Triage · Warden · Scribe findings, proposals, policy, operators, roles,
War Room messages, data scope, evidence, reports
Secure Shell gateway reducers: policy gate, approvals, access
SSH CA · passkeys · session ledger control, documentation
▲
│ live subscriptions
Liquid Glass consoles (laptop and phone)
- SpacetimeDB is the backend. One TypeScript module on Maincloud (database
claura: 18 tables, 18 role-gated views, 24 reducers) holds all incident state plus operator identities, roles and the War Room. The policy gate is thepropose_actionreducer. In one transaction it reads the policy row, checks the target, and commits the proposal as executed, pending approval or blocked. Blocked proposals stay in the record for audit, but their actions never run. Admin-only reducers handle enrollment and policy changes. Every console is a live subscription, which is why two laptops show the same incident at the same moment. Only two processes run outside SpacetimeDB, because they have to sit next to the hardware: the agent runner and the SSH gateway. - Nemotron agents that do real work. A Node and TypeScript runner drives NVIDIA Nemotron 3 Nano (
nemotron-3-nano:4b, 2.9 GB) through Ollama on local hardware, with no cloud model API in the loop. The four agents share twelve tools (list_recent_signals,open_incident,get_host_inventory,check_reachability,record_finding,record_scope,get_policy,propose_action,list_events,set_brief,file_report,post_handoff), and every effect goes through a reducer. The loop validates every argument against a JSON schema, retries once with the error fed back, detects stalls, enforces step and time limits, and judges completion from database state. Each agent also has a deterministic fallback, and every output is taggedmodel,model+fallbackorfallback, so you can see exactly what Nemotron did. - The console. TypeScript and Vite with a Liquid Glass design. It stays calm when nothing is wrong and shows one card when it needs you. The 3D data center is three.js and deterministic, so the film and the live view match. A separate phone layout covers every view.
- Secure Shell. A Node, Express and WebSocket gateway with xterm.js in the browser, passkeys through SimpleWebAuthn, and OpenSSH certificates signed by
ssh-keygenwith one principal each and a 15-minute maximum. Each targetsshdaccepts only the principals in itsAuthorizedPrincipalsFile(no keys, no passwords) and presents a host certificate from Claura's host CA. Each ledger entry includes the SHA-256 of the one before it, so editing any entry breaks every hash after it. - Hosting, brand and film. The landing page, the console and the voice endpoint run on Cloudflare Workers, with the ElevenLabs key kept server-side as a Worker secret. The Cradle mark is a C-shaped aura holding the breach orb, red until it's sealed and green after. The demo film was built with HyperFrames, with voices and music from ElevenLabs.

- Making a 4B model a reliable tool user. Early runs produced malformed arguments and stopped early. Schema checks with readable errors, a single retry and judging "done" from the database fixed it. In one live run Nemotron wrote a finding that was too short, was told why, and fixed it on the retry.
- Showing a forbidden action honestly. We wanted the gate to refuse a destructive step on camera, but across four prompt variants Nemotron never proposed one. So the demo doesn't pin it on the model. A labelled red-team probe from our test harness sends the request through the same gate, and the gate denies it (details in
backend/agents/README.md). - Access control without the usual identity stack. If SSO, email and phones are compromised, you can't use them to invite people. Single-use break-glass codes and identities stored in SpacetimeDB solved that.
- SSH without trust-on-first-use. That took a host CA as well as a user CA, short certificate lifetimes, and a suspect host that only accepts the read-only forensic role.
- Data scope is different from infrastructure scope. "One host, eleven guests" doesn't tell you whether a dataset was encrypted or copied, so we track data assets and their status separately.

- The decision loop runs live on a laptop. In one logged run, Nemotron took 15 turns and made 14 tool calls across Sentry, Triage and Warden (19 and 18 with Scribe) with zero malformed calls. The policy gate ruled on every proposal, and after a human approval the containment state committed in SpacetimeDB (
backend/runs/). - We measured it. In dress-rehearsal live runs (Maincloud, a 4B model on a laptop) the breach appeared about 8 s after the start and the approval card at a median of about 45 s. First signal to contained took about 38 to 50 s, including the human approval. Scribe's brief landed about 21 s after the approval and the filed report about 33 s after it.
- Changing one policy row changes behavior with no code change. Set quarantine to auto and the same proposal runs with no human; set it back and it waits (verified end to end,
backend/spacetime/README.md). - All five Winstead requirements live in one console that stays simple under stress: one card, one approval and one plain-language brief, on a laptop or a phone.
- Two consoles stay in sync with no refresh. A War Room message or an approval on one reached the other's screen in about 335 ms against Maincloud (
apps/dashboard/shots/live-run.json). - Real OpenSSH certificates and a tamper-evident session ledger sit behind a single click.

- Policy decides. A deterministic gate is what makes a small local model safe to act on production systems.
- Incident response is mostly coordination. Detection gets the headlines, but the night is lost when people can't talk safely or can't agree on what's true. The communications plane has to sit outside the blast radius.
- Plain language is a security feature. Writing "what we know / what we don't know yet" stops guesses from spreading as facts.
- Labelling the simulated parts builds trust. It cost us nothing, and it makes the live parts more believable. That's why we show the replay's 9.4 s as a demo clock and report our measured 38 to 50 s separately.

None of this is built yet.
- Real sensors: hypervisor, IOMMU, vGPU, EDR, BMC and identity connectors, with design partners measuring time-to-contain and false-positive rates to replace our illustrative numbers.
- An agent firewall: the same policy gate in front of every AI agent's tool calls in the building.
- Voice beyond the console: Ask Claura reaching an executive on a phone call, with the same read-only answers from the incident record.
- Autonomous recovery: reimage, re-attest and return hosts to the pool, with one human sign-off.
- DPU enforcement: containment on NVIDIA BlueField-class DPUs, below the hypervisor, so a compromised host can't undo its own quarantine.
- Confidential-computing attestation: prove a destination host and GPU are clean before any tenant fails over onto it.
- Insurance and compliance evidence: signed proof-of-containment packs for auditors, regulators and cyber insurers.
- Cross-cloud threat sharing on SpacetimeDB: operators trade signed "antibodies" (escape fingerprints and policy rules, never tenant data), so one breach protects the whole fleet.
- Sovereign deployments: an air-gapped edition with local Nemotron and self-hosted SpacetimeDB for national AI compute and critical infrastructure.
Why it matters. McKinsey projects $6.7 trillion of data-center spending by 2030, $5.2 trillion of it for AI (McKinsey). The customers we want first, multi-tenant GPU clouds, passed $25 billion in revenue in 2025, and Synergy forecasts close to $400 billion by 2031 (Synergy Research). The average breach now costs a record $4.99 million (IBM via Baker Donelson). We haven't validated pricing yet; talking to GPU-cloud operators is our next step.
Built With
- claude
- cloudflare-workers
- elevenlabs
- express.js
- hyperframes
- node.js
- nvidia-nemotron
- ollama
- openssh
- passkeys
- solana
- spacetimedb
- three.js
- typescript
- vite
- webauthn
- websockets
- xterm.js