Developer Projects

Sentinel Stream is a defensive AI tool that finds threats in the LLM agent event stream — a surface no existing security tool covers. It is built on ClickHouse, which provides the high-volume low-latency analytics the detection layer depends on. The evals prove the system meets its detection and latency targets on 5M rows. The Omega-Claw multi-agent framework used to build it is itself a demonstration that team-agent orchestration with metaprompting can produce a coherent, working security tool in under an hour. The next step is to integrate with real LLM frameworks via an SDK drop-in, and to add ML-based anomaly detection for novel attack patterns.

**CyberRange Arena** is a live red-vs-blue cybersecurity simulation where two AI agents (powered by Claude) compete against each other in real time — one attacks, one defends **The red agent** probes a deliberately vulnerable web app, discovers and exploits SQL injection, weak credentials, and path traversal vulnerabilities, and scores points for each successful attack **The blue agent** monitors incoming request logs, spots attack patterns, raises alerts, and patches vulnerabilities to shut red out — patching all three ends the match, but score still decides the winner **Two embedded exploit demos** show real LLM attack techniques: a poisoned README that hijacks an AI agent's tool calls, and an agent manipulation demo that tricks a model into overreaching its intended scope — making the project both a live simulation and an educational showcase of AI security risks

Companies are handing AI agents their email, their code and their money. One bad email can take over the agent: it reads untrusted text as instructions and sends the payment. Albert AI closes the loop in five steps: 1. Prevent: before code is written, the coding agent gets a security brief built from verified sources (Senso). 2. Detect: Semgrep Guardian plus our custom rules flag agent flaws while the code is written, such as email text reaching a payment tool. 3. Prove: an automated attacker hits every proposed fix with OpenAI and open models on AkashML, with the agent isolated in Guild. If any attack still works, the fix is rejected. 4. Learn: every successful attack becomes a new Semgrep rule, swept across every agent in the org and added to the brief. 5. Watch: every agent action goes through a real-time guard and is logged to ClickHouse with live detections. Live demo: a payments agent with its own email inbox reads invoices and pays them through a mock ledger. A legit ACME invoice is paid. A CEO-override email asking to wire $48,500 to a new account makes the agent try to pay, and Albert AI blocks it before any money moves, with the reason shown. Existing tools attack, scan, or monitor separately. Albert AI connects them so every attack makes the next build safer.

**Hacker-Bot** is a defensive security agent that does real work on the open web — and provably can't overstep. It runs continuously: monitoring live vulnerability feeds (OSV, NVD, ThreatFox), scanning its own drafts with Semgrep before it writes, and publishing verified advisories — each with the fix and upgrade command — to a live site. Every action crosses a deterministic governance gate that answers EXECUTE or REFUSE. No AI sits in the enforcement path, and both outcomes are written as signed, tamper-evident receipts. An advisory publishes only with two independent corroborating sources. When a CVE has just one source, the agent proves the fix itself: it spins up an ephemeral sandbox container on Akash, fetches the package source at the fixed version and the prior release, and diffs them to isolate the real fix changeset — no untrusted code executed. You watch the containers spin up live. Then it hands you the controls: connect any MCP agent (Claude Code, Cursor) and yours is governed too — it asks check_dependency before adding a dependency, and the gate refuses with the CVE and the fix. Or paste your lockfile to see what hits you. Sponsors: ClickHouse (every decision a queryable row), Semgrep (findings are gate inputs — a custom rule caught a real vuln in AI-generated code), Akash (decision relay + validation sandbox).

AI agents now browse the web, read files, and hold real credentials. One poisoned page can turn them against you through indirect prompt injection, and they misuse legitimate tools and valid tokens, so traditional tools see normal traffic. AgentWatch streams every agent action (tool calls, file reads, network requests, credential use) into ClickHouse. Five detection-as-code rules, each with ATT&CK mapping and must-fire/must-not-fire tests, scan 20M events in about 1.2 seconds. They catch an agent that steals AWS and SSH keys, hits the cloud metadata service, uses an admin token, and exfiltrates data, with zero false positives against decoys. AgentWatch then revokes the token, quarantines the session, and blocks the exfil host, and verifies containment by query: 3 of 3 retries denied. While building LLM-powered hunting, I found ClickHouse query-level readonly can be overridden within the same query. The guardrail is layered (validation, row limit, locked read-only user), with a custom Semgrep rule flagging the pattern. Built with ClickHouse (embedded via chDB), Python, pytest, Semgrep, Streamlit. Voiceover by ElevenLabs. Telemetry and attack are simulated for reproducibility; LLM triage is an OpenAI-compatible layer shown in labeled mock mode.

ESCAPE ROOM is an autonomous cyberdefense system for AI agents. It detects security breaches, investigates root causes, executes authorized remediation, and verifies recovery with real evidence. Built on Docker, it simulates unauthorized network access and synthetic canary exposure. Semgrep detects configuration drift, while real container probes confirm breaches. An autonomous Incident Commander selects allowlisted actions, remediates threats, and retests containment. Four recorded scenarios demonstrate its capabilities: STANDARD BREACH : Restores configuration and verifies recovery. FAILED VERIFICATION : Detects a failed repair, identifies a persistent override, quarantines it, and retests. OUT OF AUTHORITY : Refuses unauthorized actions and escalates to a human. REPEATED DRIFT : Blocks recurrence and generates a regression rule. Technologies: • Semgrep: Threat detection and prevention rules. • ClickHouse Cloud: 83 security events uploaded and verified. • OpenAI GPT-4o mini: AI-assisted incident analysis. • GitHub: Incident reports published and verified via API. • ElevenLabs: AI-generated cinematic voiceover and original demo soundtrack. Our recorded baseline achieved verified recovery in 6.9 seconds, with both security probes passing. The public dashboard provides interactive playback of real local Docker executions and transparent decision evidence. ESCAPE ROOM transforms cybersecurity from passive alerts into verifiable, autonomous defense.

**I built Python based agent that monitors agent communication. It watches for prompt injection, data theft, privacy exposure, unauthorized access. I used Guild SKILLs with Gemini  Coding agent to build Python app. I installed Clickhouse twith docker to store all security policy in hackernews  database. I used Semgrep to sanitize my code. I followed PI security mandate.  I also used ElevenLabs audio to text agent to even take audio calls as input. Because, security incidents can be reported by somebody calling. **

LogWhisperer helps security teams find attackers by asking their logs questions instead of writing query after query. We loaded 19.4 million real login events from Los Alamos National Laboratory's public dataset, recorded during a red-team exercise. How it works: a spoken or typed question goes to a Query Agent that writes one read-only SQL query. ClickHouse scans the full day of logins in about 1-2 seconds. An Analysis Agent looks for attack patterns like lateral movement, rates the risk, and explains the findings in plain English with next steps. The app shows the answer, a risk badge, an event timeline, the exact SQL, and rows scanned with query time, and can read the answer aloud. ClickHouse stores the logs and powers every answer; the speed line on screen shows rows scanned and milliseconds. AkashML runs both agents on the open Kimi-K3 model through an OpenAI-compatible API; after comparing models, we cut answers from about 30 seconds to about 10. Guild.ai hosts the LogWhisperer agent; every answer links to a Guild session log of each ClickHouse and AkashML call, with credentials kept out of agent code. Results: checked against LANL's red-team labels, which the AI never sees, it found 12 real attacker accounts on our main question and highlights 25 attack events in red. Safety: a read-only database user, a SELECT-only guard, and keys kept on the server.

**Agent Immune System (AIS) is a runtime defense for AI agents. **Agents act on whatever is in their context, so an attacker can hide instructions in a retrieved document or support ticket and make the agent exfiltrate data. This is indirect prompt injection, the defining attack surface for agents. Detection tools raise an alert but never say which input caused it or how to fix it. AIS closes that gap in one loop. **When a session is flagged, AIS does 3 things that most defenses miss**. First, AIS detects from **provenance **flow, not keywords, so that an external send of sensitive data while untrusted input is present is stopped fast and hard.  Second, Causal replay re-runs the session with each untrusted input removed to prove the exact input responsible. Third, AIS vaccinates with an open model on AkashML that generates evasive variants, a guardrail is synthesized, and it is verified against the entire recorded corpus in ClickHouse, deploying only on zero false positives. Re-running the attack is then blocked. Live on ClickHouse Cloud on over 601,000 rows.   Detection in ~59 ms, verification in ~74 ms, 9 of 9 variants blocked with 0 false positives. **The novel and innovative part is the combination of runtime causal attribution plus auto-remediation regression-tested against production history.**

**SentryPlane** is an autonomous** cyberdefense** agent that ingests high-throughput security telemetry into **ClickHouse**, enriches it with **Senso.ai** for adaptive detection and behavioral context, and orchestrates specialized response workflows via **Guild.ai**. The system continuously investigates alerts, correlates attacker behavior, and executes policy-governed remediation with all automation validated by **Semgrep** before execution.

As somebody who loves to travel around Asia, it's always very difficult to buy local. We use the video understanding models to convert video footage of markets into real high-quality e-commerce stores so that local people can reach travelers and expats, investing more dollars into local economies.  Built today on the event stack: walkthrough videos go into our team's VAST S3 bucket; on the workshop VM each video is cut into 5-second pieces, NVIDIA Cosmos Reason on CoreWeave GPUs lists every item for sale, Llama 3.3 70B on Weights & Biases Inference turns that into clean catalogue entries, Cosmos Embed1 indexes every item and moment, and it all lives in VastDB. The shop reads that catalogue: 97 pieces from markets in New York, Bali and Chiang Mai, each linked to the exact 5 seconds it appears on camera. A 60-second walkthrough takes about 90 to 120 s of compute on one worker and scales out linearly.

Sentiment Engine turns gaming reaction videos into searchable, time-indexed intelligence by pairing what happens on screen with how the player reacts. For any gameplay video, SE finds the moments that matter — the in-game event (the stimulus) and the player's facial expression at that instant (the response) — then lets you search hours of footage in plain language and auto-writes a studio insight brief when something lands. How it works: Ingest — yt-dlp pulls the video stream; ffmpeg samples frames. Game understanding — NVIDIA model captions the on-screen event per window. Reaction lane — SE locates the creator's webcam corner, crops the player's face at each event, and the VLM reads the facial expression + intensity. Fusion — events × reaction intensity × cross-video synchrony rank the "notable moments." Action — NVIDIA model writes a 2-sentence design/marketing brief for the top moment. Search — plain-language queries return the moment + reaction.

A news desk gets hours of raw footage from remote cameras in conflict zones and disaster areas, two or three hours per feed. Somewhere inside are the five seconds that matter. Nobody can watch every feed live. Vision Zero Agent watches for them. It cuts each incoming feed into 5 s segments and sends each one to NVIDIA Cosmos Reason on CoreWeave GPUs as it arrives. When Cosmos sees the event, the agent saves the clip and alerts the desk: a pop-up and chime on the page, a desktop notification, and an email or webhook. The event is just a prompt: we built and measured it on explosions, and the same trigger can watch for fires, floods, building collapses or crowd surges. Measured on public-domain Wikimedia Commons war films: 51 of 56 explosions found in 222 hand-checked clips (91% recall, 85% precision). On three films it had never seen, every blast raised a live alert, with 0 false alarms in 36 segments. Known limits: it misses the first flash before the cloud forms, and confuses parachutes with bombs. The same agent protects people on everyday cameras. Across 3,500+ street and warehouse clips stored and searched on VAST, it flags cars cutting close to pedestrians and cyclists, and workers in the path of forklifts and robots (8/10 and 6/6 agree with human review). Reviewers confirm alerts, plain-English watch rules search the archive (gpt-oss-120b on W&B Inference), and one click writes an incident report. Every call is traced in W&B Weave. Built in one day with Cursor.

Rehab is boring and requires grit most people don’t have two weeks after surgery. The day-7 “how are you walking?” call hears “fine,” and decline shows up later—in the ED. Rise turns post-op check-ins into RehabNinja: stand in front of your phone, do today’s move, and clean reps slice fruit on your joints. Knees cave in or you push off with your hands—and the fruit becomes a bomb. Patients only see hits, misses, and a plain coach. Behind the game, the same camera pose tracking runs a CDC STEADI–style chair stand so the care team gets real function, trend vs last time, and a deterministic triage card (escalate, nurse callback, or continue)—rules-first, human-approved, never model-written patient copy. Built for the VAST Real-Time Video Agents Hack (NYC). On-device pose (YOLO with MediaPipe fallback), spoken + captioned coaching, red-flag symptoms that jump straight to emergency instructions. All patients are synthetic. Play it like a game; measure it like rehab.

Road Marking Audit Dashboard (NYC Cycling Edition) — an app that answers "which streets have missing or faded road markings?" from dashcam footage. We re-ingested NYC cycling video through the VAST pipeline with a custom audit prompt, so Cosmos Reason tags every segment with marking type (bike lane, crosswalk, stop line), condition (intact to missing), confidence, and street name. The dashboard filters and groups findings by street with before/event/after clip evidence, ranks streets by risk (marking condition x pedestrian exposure from YOLO detections), and uses a W&B serverless LLM to write a plain-language per-street repair report.

!

its in the video :)

AisleGuard is an autonomous warehouse safety agent that turns passive video footage into actionable safety intelligence. It identifies worker–forklift proximity events, uses NVIDIA Cosmos and YOLO11 to understand what is happening in the footage, and searches the VAST video archive for similar historical incidents. AisleGuard then uses Weights & Biases serverless inference on CoreWeave-powered infrastructure to reason across the current event and related evidence, determine whether the behavior represents a recurring hazard, and automatically generate a safety alert with a recommended action. Instead of forcing safety teams to manually review hours of warehouse footage, AisleGuard lets them investigate incidents, search the archive in plain language, ask questions about past events, and surface patterns that may otherwise go unnoticed. The result is a real-time video agent that can detect, retrieve, reason, and act—helping teams identify recurring operational risks before they lead to more serious incidents.

1. Perception: MediaPipe Hand Landmarker reads 21 hand landmarks from each OpenCV webcam frame. We turn them into a 65-number feature vector. 2. Classification: A scikit-learn logistic regression, trained on public HaGRIDv2 landmarks plus synthetic and calibration data, labels each frame. A hold timer weighted by confidence keeps random hand movement from firing commands. 3. Action: PyObjC calls macOS directly (Quartz events, the Accessibility API, overlays). It sends keystrokes, moves windows with its own snapping, and draws on-screen feedback. 4. Self-improvement loop (the hackathon part): Every gesture event is logged. The intent pipeline goes segments → video clips → Cosmos Reason → JEV check → tagger → review → export: - Cosmos Reason (the shared NIM, cosmos3-nano-reasoner) watches each clip and judges what the user meant to do: a real command, a misfire, or a missed gesture. - A JEV pass (over OpenRouter) cross-checks Cosmos's verdict. - An LLM tagger with escalation to a stronger model settles disagreements and writes corrected labels. - The corrected labels go back into retraining.

Sightline turns any video feed into a self-configuring monitoring agent. Instead of making users define rules, detectors, or searches, Sightline first watches the footage, identifies the environment and important entities, decides what events matter, and writes its own NVIDIA Cosmos analysis prompt. Users can search the VAST archive and click “Add to Monitor,” or upload a completely new clip. Sightline then configures itself for that feed, monitors it, places events directly on a scrubbable timeline, and investigates important moments using before/after context, YOLO detections, related footage, other camera angles, a Cosmos second look, and a W&B reasoning verdict. The same engine adapts across environments: a warehouse feed generated worker/forklift safety objectives, while street footage generated pedestrian/vehicle objectives. Sightline uses VAST Data, NVIDIA Cosmos Reason + Embed, YOLO11, CoreWeave, Weights & Biases Inference, and Cursor.

**Put a claim about your video archive on trial: one agent prosecutes with search, another cross-examines every exhibit against physical evidence, a judge rules, and the tape itself takes the stand. Nothing counts until it survives.**Video search runs on captions, and captions are written by a model under someone else's prompt. They hallucinate (a "truck in the bike lane" that is really a bus at a stop) and they leave out whatever the prompt never asked about. Every search tool today asks you to believe them. Exhibit A refuses. This tool is useful for investigations and for analyzing relevant evidence. This is helpful for security and safety applications as well as efficiency. **Video index.** Video search runs against the VAST VSS retrieval API  **Captions and embeddings.** Captions come from NVIDIA Cosmos3-Reason (cosmos3-nano-reasoner) and embeddings from Cosmos-Embed1, **Detections.** A YOLO11 (COCO-80) sidecar provides max-per-frame counts, boxes for the densest frame, and frames-seen per class. **Tape witness.** The tape witness is Cosmos3-Reason  **Courtroom agents.** The courtroom roles run on Weights & Biases serverless inference: Llama 3.1 8B plays the prosecutor and bailiff, and Llama 3.3 70B plays the defense and judge.

Replay is a video review board for the VAST Builders Challenge. A person picks a camera, watches the replay with person boxes and a scene caption, and asks for a specific violation. The page keeps the clip that matches and states the rule that applies. This stack was proven on our own recorded clips. During the hackathon, we had team members perform a variety of violations - such as trespassing areas, and touching the fire alarm. Our solution helps finds these violations with predefined rules, and also allows additional rules to be defined via natural language. Clips were hybrid indexed and retrieved using VAST Data. Cursor was used to do development. Coreweave was used to host the Nvidia Cosmos reasoning used for captioning clips.

2.5 million workplace injuries and illnesses were reported in the U.S. in 2024. Cameras already record warehouses, hospitals, factories, and construction sites — but investigating an incident still means searching through hours of footage. What if you could ask your cameras what happened and get proof? RECEIPTS remembers what cameras see and tracks changes over time. Every answer comes with a timestamp and video clip. It knows when evidence is missing or outdated — there’s a difference between knowing it was safe and knowing it is safe. Ask what happened. See the evidence. Know if it’s still true.