Project Info
The name's Bond. James Bond...
Inspiration
Physical security and compliance monitoring is a $130B+ market running on human eyeballs. Security guards watch camera feeds for 8+ hours, with attention dropping drastically within a few hours. Compliance audits are manual, infrequent, and retrospective. Every new rule requires retraining staff and hoping humans remember. We saw an opportunity to put AI-powered compliance monitoring directly in the user's hands, with the option to keep all data local. With increasingly centralized compute, especially for AI applications, consumers face risks exposing sensitive personal information to data breaches and marketing. Companies and other entities require even stricter enforcement and legal requirements around security and data storage. However, as Edge AI hardware and open-source AI becomes more capable, we saw potential to personalize to tailor local AI solutions to specific technological needs, in areas like security and privacy.
What it does
Agent 00Vision is an AI-powered video compliance monitoring platform that lets users define any compliance policy in plain English, point it at any camera (live webcam or uploaded video), and get structured, audit-ready compliance reports automatically. A Vision Language Model (VLM) performs inference-time, user-directed identification of people, objects, and actions in video frames A Large Language Model (LLM) takes agentic action based on user-defined compliance rulesets, evaluating observations against policies and generating structured verdicts A dual-mode compliance system (Incidents vs. Checklists) prevents alert fatigue while maintaining safety standards An optional on-premise deployment mode using NVIDIA DGX Spark ensures video data never leaves the building Email notification capability to notify stakeholders remotely and log violations. No model training. No computer vision expertise. Write the rule, point the camera, get the report.
How we built it
Backend: Python 3.11 with FastAPI, serving REST and WebSocket endpoints for real-time monitoring Frontend: React 19 + TypeScript + Vite + Tailwind CSS for a responsive policy-builder and live monitoring dashboard Cloud AI pipeline: OpenAI GPT-4o Vision for scene understanding, GPT-4o-mini for policy evaluation, and Whisper for audio transcription Local AI pipeline on NVIDIA DGX Spark: Deployed Cosmos-Reason2 8B with vLLM as the Vision Language Model Deployed Nemotron-3-Nano 30B with Ollama as the compliance evaluation LLM Split VRAM between the two models for concurrent inference Deployed Cosmos-Reason2 8B with vLLM as the Vision Language Model Deployed Nemotron-3-Nano 30B with Ollama as the compliance evaluation LLM Split VRAM between the two models for concurrent inference Smart frame sampling: Built a dual-metric change detection engine (histogram correlation + structural similarity) with a threaded pipeline, reducing frames sent to cloud API calls Async processing: Celery + Redis for background video analysis with real-time progress updates via WebSocket
Challenges we ran into
Hallucinations in both the VLM and LLM led to inaccurate compliance verdicts. We mitigated this with structured JSON output schemas, Pydantic validation, and retry logic with stricter prompts on parse failure Time constraints limited our ability to pretrain or fine-tune models on compliance-specific data, so we relied on prompt engineering and few-shot examples Splitting VRAM between Cosmos and Nemotron on the DGX Spark required careful configuration to keep both models loaded simultaneously Rate limiting from cloud API providers required exponential backoff with jitter and usage tracking to stay within quotas during demo-heavy periods Video seeking performance in compressed formats (H.264/H.265) was initially very slow. We switched from cap.set(POS_FRAMES) to sequential cap.read() with frame counting for a 5-10x speedup
Accomplishments we're proud of
Building a complete end-to-end pipeline, from raw video to structured compliance reports, in a single hackathon Achieving reduction in API calls through our intelligent frame sampling, making the product economically viable at scale Implementing dual-mode compliance (Incidents vs. Checklists) with temporal memory so the system remembers what it has already verified Successfully running inference on the NVIDIA DGX Spark with two models sharing VRAM, proving that local deployment is feasible today
What we learned
Local inference is the future for light consumer workloads. Privacy-sensitive applications don't need to send data to the cloud when edge hardware can handle it NVIDIA has a great variety of open-source models suitable for deployment. Cosmos and Nemotron worked well out of the box with minimal prompt tuning Transformer-based models give great flexibility by not limiting you to an ultra-specific use case. Traditional CV-based CNNs are hyper-specialized at the cost of generalization. VLMs can handle "any rule you can describe in English" without retraining Dual-mode compliance prevents alert fatigue. Continuously re-alerting on the same compliant hard hat every 6 seconds creates noise. Checklist mode with validity periods solves this
What's next
TensorRT optimization for DGX models to reduce inference latency Modal.com deployment for elastic cloud scaling across multiple cameras Notification channels: SMS via Twilio, Slack, and Microsoft Teams alerts for critical violations Multi-camera orchestration: Dashboard for managing dozens of feeds with independent policies As local inference gets cheaper, Agent 00Vision becomes a viable option for privacy-focused customers to explore wide-ranging use cases, from off-the-grid home security to endangered animal identification in the wild
Agent 00Vision
AI-Powered Video Compliance Monitoring
Define any compliance policy in plain English. Point it at any camera. Get structured, audit-ready reports.
Quick Start
Prerequisites: Python 3.11+, Node.js 18+, an OpenAI API key
git clone https://github.com/kuzeykantarcioglu/treehacks2026.git
cd treehacks2026
# Add your API key
echo "OPENAI_API_KEY=sk-your-key-here" > .env
# Run everything
./run.sh
That's it. The script creates a virtualenv, installs dependencies, and starts both servers.
- Frontend: http://localhost:5173
- Backend API: http://localhost:8082
- API Docs: http://localhost:8082/docs
Press Ctrl+C to stop all services.
Manual Setup
If you prefer to run things separately:
# Backend (terminal 1)
python3 -m venv venv && source venv/bin/activate
pip install -r backend/requirements.txt
PYTHONPATH=$(pwd) uvicorn backend.main:app --reload --host 0.0.0.0 --port 8082
# Frontend (terminal 2)
cd frontend && npm install && npm run dev
What It Does
Agent 00Vision watches video feeds and enforces compliance rules you write in plain English.
"All personnel must wear a hard hat and yellow safety vest"
|
v
AI watches the camera feed
|
v
Structured report: 2 violations detected, timestamps, severity, recommendations
Two modes of operation:
| Mode | Input | Use Case |
|---|---|---|
| Live monitoring | Webcam feed | Real-time compliance with continuous alerts |
| File analysis | Uploaded video | Batch processing with full report |
Two AI backends:
| Provider | Models | Data Residency |
|---|---|---|
| OpenAI (cloud) | GPT-4o Vision + GPT-4o-mini + Whisper | Cloud |
| NVIDIA DGX Spark (local) | Cosmos-Reason2 8B + Nemotron-3-Nano 30B | On-premise |
Features
- Policy-as-prompt — Write any compliance rule in English, no model training needed
- Dual-mode compliance — Incident mode (alert every violation) vs. Checklist mode (check once per validity period) to prevent alert fatigue
- Smart frame sampling — Change detection reduces frames sent to the VLM by 80-95%, making the product economically viable
- Reference image matching — Upload photos of authorized personnel or badges for identity verification
- Audio compliance — Whisper transcription for speech-based rules (safety briefings, verbal confirmations)
- Structured reports — Machine-readable JSON output with severity, timestamps, and recommendations
- AI policy assistant — Chatbot that helps you build compliance policies
Architecture
Frontend (React + TypeScript + Vite + Tailwind)
|
| /api proxy (Vite -> :8082)
v
Backend (FastAPI)
|
|-- POST /analyze/ Full video pipeline (sync)
|-- POST /analyze/frame Single frame analysis (webcam)
|-- POST /polly/chat AI policy assistant
|-- GET /health System status
|
v
Processing Pipeline
1. Frame Extraction + Change Detection (OpenCV)
2. Visual Analysis (GPT-4o Vision or Cosmos-Reason2)
3. Audio Transcription (Whisper) [optional]
4. Policy Evaluation (GPT-4o-mini or Nemotron-3-Nano)
5. Report Generation (structured JSON)
Project Structure
treehacks2026/
├── backend/
│ ├── main.py # FastAPI entry point
│ ├── core/config.py # Environment + OpenAI client config
│ ├── models/schemas.py # Pydantic data models
│ ├── routers/
│ │ ├── analyze.py # /analyze, /analyze/frame endpoints
│ │ ├── async_analyze.py # /async/analyze (requires Redis)
│ │ ├── polly.py # /polly/chat AI assistant
│ │ └── websocket.py # WebSocket for task updates
│ └── services/
│ ├── video.py # Frame extraction + keyframe sampling
│ ├── vlm.py # GPT-4o Vision calls
│ ├── policy.py # Compliance evaluation engine
│ ├── dgx.py # NVIDIA DGX Spark integration
│ ├── whisper.py # Audio transcription
│ └── api_utils.py # Retry logic + rate limiting
├── frontend/
│ ├── src/
│ │ ├── App.tsx # Main app component
│ │ ├── api.ts # Backend API client
│ │ └── components/
│ │ ├── PolicyConfig.tsx # Rule builder UI
│ │ ├── LiveReportView.tsx # Real-time monitoring
│ │ ├── ReportView.tsx # Analysis results
│ │ ├── VideoInput.tsx # Webcam/file input
│ │ ├── ReferenceImages.tsx # Reference photo management
│ │ ├── PollyChat.tsx # AI policy assistant
│ │ └── DualModeReport.tsx # Incident vs. Checklist display
│ └── vite.config.ts # Vite config (proxies /api -> :8082)
├── scene_detection.py # OpenCV change detection engine
├── run.sh # Single script to start everything
├── stop.sh # Stop all services
└── .env # OPENAI_API_KEY (not committed)
Configuration
# .env
OPENAI_API_KEY=sk-your-key-here
# Optional — only needed for async features
REDIS_URL=redis://localhost:6379/0
# Optional — DGX Spark local inference
DGX_SPARK_IP=10.19.176.53
DGX_PROXY_PORT=8001
Built With
AI/ML: OpenAI GPT-4o Vision, GPT-4o-mini, Whisper, NVIDIA Cosmos-Reason2 8B, NVIDIA Nemotron-3-Nano 30B
Backend: Python, FastAPI, OpenCV, Celery, Redis, WebSockets
Frontend: React 19, TypeScript, Vite, Tailwind CSS
Infrastructure: NVIDIA DGX Spark, vLLM, Ollama
Built at TreeHacks 2026
Analysis
View
Metric
- 11
- 6
- 5
- 2
Figures cover GitHub contributors during the hackathon window. A co-authored commit counts in full for each author, so per-member totals add up to more than the whole-team figures.
Technology
- CSSIn code
- FastAPIIn code
- HTMLIn code
- JavaScriptIn code
- OpenAIIn code
- PythonIn code
- ReactIn code
- RedisIn code
- Tailwind CSSIn code
- TypeScriptIn code
- OllamaClaimed
10 of 11 appear in the indexed code. 1 claimed on Devpost could not be matched to code, which may simply mean the tool leaves no trace in the repository.
AI coding agents
No AI coding agent signals were found in this repository.
Detected from committed agent config files and commit authorship. Absence of a signal is not proof an agent was unused.
Codebase size
Source size
539 KB
Source files
60
Counts recognized source files only; vendored directories, binaries and lockfiles are excluded, so this is smaller than the repository on disk.
Repository
kuzeykantarcioglu/compliance_vision_cloud
74 files · 719 KB · @ d9e44f4
Structure
Interface
16 files · 22%Screens, components and styles rendered to the user.
Application logic
39 files · 53%Domain rules, services and shared utilities.
+1 moreData & schema
2 files · 3%Schema definitions, migrations and data access.
Supporting
Layers are inferred from where files sit in the tree, not from reading the code. A project that names its directories unconventionally will read oddly here — open the file browser to check anything the diagram implies.
Languages
- Python48%
- TypeScript35%
- JavaScript6%
- HTML4%
- CSS4%
- Markdown2%
- Other (1)1%
Share of indexed source by file size. Binary and vendored files are excluded.
Dependencies
backend/requirements.txt
pypi · 13- celery[redis]
- fastapi
- httpx
- numpy
- openai
- opencv-python-headless
- python-dotenv
- python-multipart
- redis
- requests
- setuptools
- uvicorn[standard]
- websockets
frontend/package.json
npm · 11- @tailwindcss/vite
- @types/react
- @types/react-dom
- @vitejs/plugin-react
- axios
- lucide-react
- react
- react-dom
- tailwindcss
- +2 more
local_ui/requirements.txt
pypi · 6- fastapi
- opencv-python
- pydantic
- python-multipart
- requests
- uvicorn[standard]
Declared in the repository’s manifests at the indexed commit. A declared package is not proof it is used, and runtime dependencies are listed first.
This project’s features have not been analysed yet.
Export this project's context (description, README, evidence, key source files) to chat with an AI agent elsewhere.