Guardian + Kern-3

protection active
listening
chekcing
intervention
critical -kern-3
reserverd state

Inspiration

Phone scams increasingly rely on social engineering rather than technical exploits. Attackers impersonate banks, support agents, relatives, or trusted organizations and create urgency to persuade people to reveal one-time passwords, transfer money, install software, or take other dangerous actions.

Guardian was built around a simple question: what if AI could understand what is happening during a conversation, while a deterministic safety layer — not the language model — remained responsible for deciding when intervention is justified?

This led to Guardian + KERN-3: an AI-assisted scam detection system designed to identify manipulation signals, assess risk, and warn the user before a suspicious request becomes a financial loss.

What it does

Guardian analyzes conversation content and extracts structured semantic evidence such as identity claims, financial context, requests for one-time passwords, requested actions, and urgency.

Gemini is deliberately non-authoritative: it interprets the conversation and produces structured evidence, but it does not decide whether the user should be warned.

That evidence is evaluated by a deterministic risk engine and then passed to KERN-3, Guardian's policy authority layer.

This architecture follows three core safety principles:

Knowledge is not authentication.
Trust does not cancel dangerous behavior.
Sensitive requests outweigh apparent legitimacy.

A normal conversation can therefore remain at NORMAL risk with no intervention, while a caller claiming to represent a bank and requesting an OTP can produce a CRITICAL assessment and an immediate warning.

Guardian also includes a technical visualizer that exposes the extracted evidence, risk assessment, and policy decision so the system's behavior can be inspected rather than treated as an opaque AI verdict.

How we built it

Guardian is implemented as a layered pipeline:

Conversation → Gemini semantic extraction → deterministic RiskEngine → KERN-3 policy authority → user-facing action

We use the Google GenAI SDK with Gemini 3.6 Flash for structured semantic extraction.

The backend is built in Python and FastAPI. The Guardian interface and engineering visualizer are served alongside the API, and the complete application is deployed on Google Cloud Run.

KERN-3 remains separate from the generative model. Gemini provides evidence; deterministic code retains authority over the safety decision.

The project currently supports text analysis and an experimental speech-to-text path, with the primary Guardian experience intentionally scoped around reliable single-turn analysis.

Challenges we ran into

The hardest problem was not detecting suspicious words. It was defining the boundary between probabilistic AI interpretation and deterministic safety authority.

A system protecting vulnerable users cannot simply assume that a confident language-model response is correct.

We therefore had to design strict structured-output contracts, preserve deterministic risk and policy behavior, handle unsupported or ambiguous evidence safely, and make the internal decision process observable.

We also had to distinguish legitimate sensitive activity from manipulation. A user entering their own verification code on an official website should not be treated the same way as an unverified caller asking the user to reveal that code.

Finally, we focused heavily on deployment discipline and regression testing so that changes to the interface or Gemini integration could not silently alter the deterministic safety semantics.

Accomplishments that we're proud of

We built a working end-to-end system in which generative AI assists interpretation without becoming the final safety authority.

The current release includes:

Structured semantic extraction using Gemini 3.6 Flash
Deterministic risk assessment
The KERN-3 policy authority layer
User-facing scam warnings
A technical decision visualizer
Experimental speech-to-text support
Deployment on Google Cloud Run
331 automated regression tests

Most importantly, the architecture makes the boundary between AI interpretation and safety authority explicit and inspectable.

What we learned

We learned that building safety-oriented AI systems is as much about defining what the model must not control as it is about choosing the model itself.

Generative models are extremely useful for interpreting messy human language. But sensitive decisions benefit from explicit contracts, deterministic policy boundaries, observable evidence, and regression-tested behavior.

Explainability also became an engineering requirement rather than simply a UI feature. Being able to see why Guardian reached CRITICAL risk was invaluable while developing and testing the system.

What's next for Guardian

Guardian is currently a hackathon prototype, not a production telephony interception system.

Future work would focus on robust multi-turn conversation analysis, production-grade telephony integration, stronger identity and provenance signals, trusted-circle notification workflows, broader multilingual evaluation, accessibility testing with vulnerable users, and additional privacy-preserving deployment options.

The long-term goal remains the same: use AI to understand the situation while keeping sensitive safety decisions constrained, deterministic, and auditable.