Project Info
Preview: what's below? New algorithm for invisible facial encryption: the image looks identical to humans but is catastrophic to generative models, tested and tuned with Runpod Complex multi-agent orchestration, featuring local agents on the DGX Spark (Nemotron) collaborating with Claude Agent SDK for data-secure, high reasoning tasks Multi-agent feedback loops, using OpenAI API to enable agent self-verification Bright Data for complex web scraping tasks (tracking your identity across the web) Overview As the misuse of AI-generated media and data collection rapidly rises, individuals and organizations need a way to benefit from powerful models while keeping their identity and sensitive data under their own control. Cena is an invisible companion that travels the web with you and safeguards your digital identity. It does this as an embedded platform on your desktop consisting of 3 main features: Personal image protection: encrypt your photos before you post them so they look normal to people but aren’t usable for AI models to analyze or generate impersonations, using an agent feedback loop. Safeguarding personal data: a local-remote agent system intelligently de-references personal and sensitive identifiers in your LLM prompts and uploaded files before sending them to cloud AI models, ensuring utility without giving up raw personal information. Deepfake monitoring: scans the web for images and videos of your likeness and alerts you of likely AI impersonations.
Inspiration
While the capabilities of AI assistants have expanded rapidly over the past few years, a tradeoff for users has emerged between the value they provide and the personal security risks that come with sharing sensitive data. What if we could ensure individual data security while still attaining the same, high-level chatbot utility for users? Enter Cena. Our inspiration for Cena originated from the exponential growth of the threat of deepfakes and personal data leakages. These threats can affect any one, at any time. Recently, deepfakes of public images have been exploited for blackmail, slander, and the nonconsensual production of sexual content. In fact, deepfake fraud attempts have surged by over 3,000% annually in recent years. Over the past two years, the number of deepfakes online have increased by 16-fold. As AI models grow in capability and ease of access improves, these effects will become all the more ubiquitous. When using LLMs, many people worry that the personal details they share can be stored or reused into future model training beyond their control, especially in settings such as HIPAA-regulated healthcare, legal and financial work, and internal company workflows. There has been a 57% increase in AI-driven attacks on user information within the last year. Additionally, 81% of users believe that information collected by AI companies will be used in ways they are uncomfortable with. What Cena Does 1. Encrypting your digital likeness to protect against deepfake generation. Applies undetectable transformations to images that seem identical to the human eye, but make generating convincing deepfakes impossible. Expanded on image processing techniques to perturb pixel distributions in existing facial images. Survives workarounds such as screenshotting, cropping and resolution altering. Workflow of the encryptor, generator and evaluator working in tandem to provide maximal security on input images. 2. Running multi-agent feedback loops before releasing images into the wild for maximum security. Coordinates a triple-agent model: 1) encryptor, 2) generator, 3) evaluator. The encryptor runs the algorithm described above to encrypt an image of a face, where the encrypted image looks identical to the human eye. This encrypted image is then passed to the locally-hosted generator, which attempts to generate deepfakes from this image. These deepfakes are passed to the evaluator, which determines how realistic they are. If the generated deepfakes are deemed convincing above a threshold, the encryption algorithm is re-run on the encrypted image once again. This process repeats until a sufficiently encrypted image is obtained. 3. Data de-referencing to prevent sensitive information from leaking into cloud-based LLMs. Assigned a utility score and sensitivity score to each phrase of text. Utility score measures importance of specificity to ensure the cloud LLM runs accurately. Sensitivity score measures importance of keeping text secure, including a multiplier for contextual inference. We use NVIDIA's Nemotron, hosted on a DGX Spark (using vLLM for fast inference!) to handle and de-reference all private data, aiming to stay cryptographically secure. These agents are then in collaboration with the Claude SDK which performs cloud-based heavy reasoning tasks. The combination of local and cloud agents enables secure, high reasoning workflows, and allows us to push the boundaries of what is possible with either agent alone! 4. Adversarial multi-agent system to safely stress-test your documents. Attacker model that tests cloud LLM’s performance on inferring information from de-referenced prompt to push local agent towards securing personal data. We use the OpenAI API to enable this agentic self-verification! Workflow of de-referencing personal information using local agents with access to remote cloud models for computationally-intensive tasks. 5. Web agent to identify deepfakes and AI-generated content online. Agent developed with Claude Agent SDK to search online images using Bright Data. Identifies images as AI generated from a collection of 3 independent signals: visual artifacts using Claude Vision, metadata inspection for AI tool signatures, and frequency analysis using FFT to detect spectral patterns that diffusion models leave behind. How We Built It Native macOS front-end (SwiftUI) Menu-bar app with translucent overlay HUD, agent chat window, and settings pane Real-time communication with the backend over WebSocket FastAPI + Uvicorn – main API server with WebSocket endpoints for the agent chat Flask – GPU-accelerated image encryption/glazing server Jinja2 templates + SSE for a deepfake-detection web UI Local AI model – NVIDIA Nemotron nvidia/NVIDIA-Nemotron-Nano-9B-v2 served locally via vLLM Handles PII redaction orchestration and privacy-preserving query rewriting so sensitive data never leaves the device Cloud AI Models Anthropic Claude (Sonnet, Haiku) via the Claude Agent SDK – used for the cloud relay chat agent and vision-based deepfake artifact analysis OpenAI GPT (gpt-4o, gpt-4-turbo) – alternative cloud LLM option Bright Data SERP API + Scraping Browser for reverse image search (Google Lens) in deepfake detection Image protection & computer vision (GPU) Stable Diffusion Inpainting (runwayml/stable-diffusion-inpainting via HuggingFace Diffusers) + a RunPod-tuned a PGD algorithm for adversarial attack InsightFace (buffalo_l, ArcFace 512-D embeddings) – face detection and identity matching OpenCV, Pillow, NumPy – general image processing and DCT frequency-domain forensics GPU compute & deployment Primary target: NVIDIA DGX Spark (ASUS Ascent GX10) via SSH + Docker RunPod GPU pods used for tuning the algorithm, testing it, and providing extra compute needed through their Flash instances PyTorch with CUDA; models run in FP16 Deployment automated via deploy.sh (Docker build & push to remote) Challenges We Ran Into Facial image encryption process: making the difference between original images and encrypted images imperceptible to humans but the encrypted images unusable by AI tools. Separation of local and cloud agents: navigating the dynamic between the local agent’s de-referencing of information before sending to remote cloud agents for higher computational analysis. Orchestration of agents: ensuring communication between agents with various roles. Latency: especially during multi-agent feedback loops, improving performance proved challenging. Accomplishments Proposing a new facial encryption algorithm to perform modifications to a face which are both undetectable by the human eye and also make your face immune to deepfakes. Pushing state-of-the-art techniques in image processing to achieve stronger performance in new contexts. Handling complex edge-cases in document dereferencing. Merging different expertises and working styles to form a cohesive team environment. What We Learned Interfacing with high-performance hardware like NVIDIA DGX Spark. Building a cohesive tech stack across cloud technologies like GCP and Runpod and LLM backends like the OpenAI API and Claude SDK. Coordinating complex, multi-agent systems that interact with real-time feedback to alter their course of action. What's Next for Cena Cross-platform + mobile support. Increasing number of data modalities (e.g., audio to prevent non-consensual voice cloning). More granular control over document data, including the kinds of PII that should be prioritized over others.
Cena — Personal Data Privacy in the Age of AI
TreeHacks '26 — A suite of tools that protect your personal data from AI exploitation.
Cena is a native macOS app with two core features:
-
Automatic Likeness Encryption — A translucent system overlay that intercepts images/videos before upload and encrypts your likeness to defeat deepfake generation and AI inpainting. A small loading indicator and checkmark appear in a translucent bubble, seamlessly replacing the original with an encrypted version.
-
Cena Agent — A native chat interface for talking to cloud LLMs with full privacy. Documents, images, and messages are dereferenced/redacted locally before being sent to the cloud. Images uploaded here also get likeness encryption. Personal information never leaves your device unprotected.
Both features are native SwiftUI, unified in a single menu-bar app.
Key principle: All personalized information is processed locally (on the DGX Spark) — the local agent, encryption, redaction — before being dereferenced/encrypted and sent to the cloud.
Architecture
┌─────────────────────────────────────────────────────────────────────────────┐
│ YOUR MACHINE (DGX Spark / SSH) │
│ │
│ ┌──────────────────────────────────────────────────────────────────────┐ │
│ │ Cena (native macOS) │ │
│ │ ├─ Automatic Likeness Encryption (translucent overlay) │ │
│ │ │ ├─ Clipboard monitor → auto-encrypt on copy/upload │ │
│ │ │ └─ Translucent HUD with progress │ │
│ │ └─ Agent Chat (native SwiftUI window) │ │
│ │ ├─ WebSocket → FastAPI backend │ │
│ │ └─ Model picker (Claude / GPT) │ │
│ └──────────────────────────────────────────────────────────────────────┘ │
│ │ │
│ ┌───────────────────────────▼──────────────────────────────────────────┐ │
│ │ Cena Backend (FastAPI :8000 + Flask :5000) │ │
│ │ ├─ Local Guardian (Nemotron via vLLM) │ │
│ │ │ ├─ PII Redactor │ │
│ │ │ ├─ Likeness Encryptor (Cena Encryption) │ │
│ │ │ └─ Re-referencing engine │ │
│ │ └─ Encryption Server (PGD + SD Inpainting + Fawkes) │ │
│ └──────────────────────────────────────────────────────────────────────┘ │
└──────────────────────────────────────────┬──────────────────────────────────┘
│ redacted / encrypted data only
▼
┌──────────────────────────┐
│ Cloud Relay │
│ ├─ Claude (Agent SDK) │
│ └─ OpenAI GPT (API) │
└──────────────────────────┘
Project Structure
.
├── Cena/ # Native macOS app (SwiftUI)
│ └── Cena/
│ ├── App/ # CenaApp, AppState, MenuBarController
│ ├── UI/ # AgentChatView, OverlayWindow, EncryptionProgressView,
│ │ # ApprovalDialog, SettingsView
│ ├── Services/ # AgentWebSocket, BackendService, EncryptionQueue,
│ │ # MaskGenerator, PasteboardMonitor
│ └── Models/ # ChatMessage, EncryptionJob, Settings, BackendConfig
├── agents/
│ ├── local_guardian/ # Nemotron agent: redact, encrypt, re-reference
│ └── cloud_relay/ # Routes sanitized requests to Claude / GPT
├── server/
│ ├── app.py # Flask GPU server (encryption + Fawkes)
│ ├── fawkes_modern.py # Fawkes facial recognition cloaking
│ ├── main.py # FastAPI server (agent WebSocket API)
│ └── routes.py # WebSocket + REST endpoints
├── client/
│ ├── encrypt.py # CLI image encryption
│ ├── agent_loop.py # Adversarial encrypt → generate → judge loop
│ ├── rater_agent.py # Claude vision deepfake rater
│ └── backends.py # Backend resolver
├── config/settings.py # All configuration
├── backends.json # GPU backend definitions
├── deploy.sh # Deploy to GX10 / RunPod / SSH
├── .env.example # Environment variable template
└── requirements.txt # Backend Python dependencies
Quick Start
1. Deploy Encryption Server (on DGX Spark)
./deploy.sh gx10 nikhil@spark-abcd.local
ssh nikhil@spark-abcd.local
docker exec -it cena bash -c 'cd /workspace/project/server && python app.py'
2. Start Agent Backend
# On DGX Spark: start local Nemotron
vllm serve nvidia/NVIDIA-Nemotron-Nano-9B-v2 --port 8001 --trust-remote-code
# On your machine:
cp .env.example .env # add your API keys
pip install -r requirements.txt
python -m server.main
3. Build & Run Cena
cd Cena && swift build -c release
.build/release/Cena
The shield icon appears in your menu bar with two main actions:
- Automatic Likeness Encryption: Copy an image → translucent bubble → encrypted → paste
- Open Agent Chat (Cmd+A): Native chat window connected to the privacy agent
Configuration
Copy .env.example to .env and set:
| Variable | Purpose |
|---|---|
NEMOTRON_ENDPOINT | vLLM server URL (default: http://spark-abcd.local:8001/v1) |
ENCRYPTION_SERVER_URL | Encryption server (default: http://spark-abcd.local:5000) |
ANTHROPIC_API_KEY | Cloud Claude access |
OPENAI_API_KEY | Cloud GPT access |
ENCRYPTION_BACKEND | Default backend name from backends.json |
References
- Adversarial Image Encryption (ICLR 2025) — adversarial image protection
- NVIDIA Nemotron — local LLM
- Claude Agent SDK — agentic cloud relay
Analysis
View
Metric
- 23
- 21
- 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
- AnthropicIn code
- CSSIn code
- FastAPIIn code
- FlaskIn code
- HTMLIn code
- Hugging FaceIn code
- OpenAIIn code
- PythonIn code
- SwiftIn code
- PyTorchClaimed
9 of 10 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
- CursorCommits
Detected from committed agent config files and commit authorship. Absence of a signal is not proof an agent was unused.
Codebase size
Source size
501 KB
Source files
78
Counts recognized source files only; vendored directories, binaries and lockfiles are excluded, so this is smaller than the repository on disk.
Repository
nvemuri4649/treehacks-26
89 files · 511 KB · @ 02d60b6
Structure
Interface
17 files · 19%Screens, components and styles rendered to the user.
API & routing
5 files · 6%Request entry points: routes, handlers and controllers.
Application logic
45 files · 51%Domain rules, services and shared utilities.
+4 moreData & schema
4 files · 4%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
- Python54%
- Swift37%
- HTML6%
- Markdown2%
- Shell1%
- CSS0%
Share of indexed source by file size. Binary and vendored files are excluded.
Dependencies
requirements.txt
pypi · 20- aiofiles
- anthropic
- claude-agent-sdk
- fastapi
- httpx
- insightface
- jinja2
- numpy
- onnxruntime
- openai
- opencv-python
- Pillow
- playwright
- python-dotenv
- python-multipart
- scipy
- spacy
- sse-starlette
- +2 more
server/requirements.txt
pypi · 12- datasets
- diffusers
- flask
- huggingface-hub
- hydra-core
- numpy
- omegaconf
- opencv-contrib-python
- pillow
- scikit-learn
- tqdm
- transformers
client/requirements.txt
pypi · 3- anthropic
- pillow
- requests
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.