Project Umbra

Project Umbra deploys your personal privacy agent to protect your identity in a digital world built to collect it.

Comment

Inspiration

A digital identity rarely lives in one place. A phone number connects to an old address. An old address connects to a relative. A data broker turns those fragments into a searchable profile. Yet protecting that identity still means opening dozens of tabs, separating genuine matches from namesakes, finding the right privacy process, and keeping enough evidence to follow up.

That imbalance inspired Project Umbra. I wanted to give an individual the kind of coordinated investigative capability usually reserved for organizations, while keeping every consequential decision in the individual's hands.

Project Umbra deploys your personal privacy agent to protect your identity in a digital world built to collect it.

What it does

Umbra takes an identity the user has authorized and turns scattered public traces into one clear, evidence-backed plan.

The agent builds targeted searches from names, aliases, contact points, handles, and locations. It gathers supported findings, connects related identity signals, and shows how each source contributes to the larger picture. The Entity Tree makes those relationships visible. The Risk Report explains the user's current exposure, highlights the most important findings, and maps each material result to an official broker action.

When Umbra finishes, the user receives source-linked evidence, clear priorities, and a broker-by-broker plan ready for review. Umbra handles the investigative work; the user decides whether and when to act.

How we built it

We built Umbra as a bounded Taskmaster workflow rather than an open-ended chatbot. A finite-state controller coordinates profile authorization, targeted acquisition, evidence extraction, identity correlation, risk analysis, and action planning. Step limits, timeouts, cancellation, and live progress updates keep every mission controlled and inspectable.

Gemini 3.7 Flash, accessed through the Google GenAI SDK, turns supported source material into structured evidence under strict schemas. Cloud Run hosts the FastAPI application and mission runtime. Firestore stores mission state, telemetry, findings, and prepared actions. The interface uses semantic HTML, vanilla JavaScript, Server-Sent Events, and progressive SVG visualization to turn the investigation into a product people can understand.

We also built and tested an optional Gemma 2 9B IT path for neural PII classification. The current production configuration uses deterministic classification for a predictable privacy boundary.

The creation process drew on the wider Google AI ecosystem. Gemini helped shape the initial idea and end-to-end concept. Google Antigravity's early subagent teamwork preview coordinated a parallel prototype sprint across product strategy, architecture, interface design, implementation, testing, and documentation. At its peak, I observed approximately twelve agents working in parallel, and I estimate that this sprint produced roughly 70% of the foundation that evolved into the finished product.

Google Flow, Gemini Omni Flash, Veo, and Google's Chirp HD voice technology supported the visual and audio production of the demonstration. OpenAI Codex assisted with later implementation, testing, critique, security review, documentation, and local video production. I directed the work and created the submitted result.

Challenges we ran into

Public-source investigation is inherently inconsistent. Sites change, block cloud traffic, or return different results at different times. We solved this by recording provenance at the source level and clearly separating live acquisition from controlled fixtures used for reproducible testing.

Identity correlation created a second challenge. A shared name or location does not automatically prove a match. Umbra needed to connect useful signals without turning uncertainty into false confidence, so the system preserves supporting evidence and exposes confidence instead of hiding it behind a single answer.

Privacy also shaped how we demonstrated the product. We needed to prove that the cloud service, model, persistence layer, and report worked together without exposing credentials, private mission access, or real personal data. The final demonstration therefore separates a clearly labeled synthetic product replay from concise production proof.

Finally, we had to make a dense investigation understandable. We refined the Entity Tree and Risk Report until a viewer could see the outcome, understand the supporting evidence, and recognize the next decision without learning the underlying architecture first.

Accomplishments that we're proud of

We built a working personal privacy agent that completes an investigation-to-plan workflow and returns a usable deliverable, not another conversation. Umbra connects identity signals, preserves source context, explains current exposure, and prepares official next steps in one continuous mission.

We are especially proud of the boundary between autonomous work and human authority. Umbra takes on the repetitive investigation, organization, and planning while the user retains control over actions involving identity rights or external services.

We also proved the complete Google Cloud path: Gemini 3.7 Flash structures the evidence, Cloud Run executes the service, Firestore preserves the mission, and the product turns the result into an understandable Risk Report. The public repository includes the architecture, reproducible setup instructions, and nearly 500 automated tests.

Most importantly, the finished product makes a complicated privacy problem feel actionable. It gives the user one view of the evidence, one prioritized plan, and a clear place to make the final decision.

What we learned

The hardest part of privacy work is not drafting an opt-out message. The real value comes from finding the right records, connecting the evidence, identifying the correct process, and preserving enough context to act confidently.

We also learned that strong autonomy depends on visible boundaries. Current exposure, prepared action, submitted request, broker response, and verified outcome are different states. A trustworthy agent shows those differences clearly.

This project revealed another strength of Google's AI ecosystem. Gemini, agent teamwork, Cloud Run, Firestore, Flow, Veo, Omni, and Chirp each specialize in a different part of the workflow. Connecting those capabilities created an unusually complete path from idea to working product to finished demonstration. The opportunity now is to make that integrated path feel as seamless to developers as the resulting product feels to users.

Finally, technical sophistication only matters when people can understand the outcome. Clear language, visible provenance, and thoughtful interaction design did as much for trust as the underlying models and infrastructure.

What's next for Project Umbra

Next, Umbra will expand its broker and jurisdiction coverage, support recurring exposure checks, and compare future scans against a user-controlled baseline. A private evidence vault will let each user preserve their own history, decisions, and follow-up records without placing personal material in a public repository.

We also plan to extend the approval boundary into consent-driven execution. Umbra will prepare each external action, ask the user for explicit approval, record what the user authorized, and verify the result through a later re-scan. The goal is not autonomy at any cost; it is meaningful privacy protection without surrendering control.

Project Umbra will keep moving toward one promise: deploy your personal privacy agent to protect your identity in a digital world built to collect it.

Built With

  • artifact-registry
  • chirp
  • cloud-build
  • cloud-logging
  • cloud-run
  • docker
  • fastapi
  • firestore
  • gemini-3.7-flash
  • gemini-omni-flash
  • gemma-2
  • google-antigravity
  • google-cloud
  • google-flow
  • google-genai-sdk
  • javascript
  • playwright
  • pydantic
  • python
  • secret-manager
  • server-sent-events
  • sqlite
  • svg
  • veo
Share this project:

Updates