Guardian nexus

• 

Inspiration

Guardian Nexus started from a simple question: What if an AI system could help someone recognize a scam while the suspicious conversation is still happening, instead of after the damage has already been done?

Scams are becoming increasingly convincing, especially through phone calls, impersonation, social engineering, phishing, and AI-generated content. We wanted to explore how real-time AI could act as a digital safety layer that not only detects a potential threat, but also explains why something appears suspicious in a way a normal user can understand.

What it does

Guardian Nexus is an AI-powered digital guardian that analyzes conversations in real time and identifies potential scams and digital threats.

The system receives live audio and uses the AssemblyAI Realtime API to convert speech into text. The transcript is then processed through a LangGraph-based multi-agent architecture.

Different components focus on different parts of the problem, including scam detection, threat intelligence, supervision, and explanation. A deterministic 0–100 risk engine combines security signals to produce a consistent risk assessment.

An LLM is then used as a reasoning and explanation layer to help interpret the analysis and convert technical security findings into clear, human-readable explanations.

The overall flow is:

Live Audio → AssemblyAI Realtime API → LangGraph → Security Agents → Risk Engine → LLM Explanation → Real-Time Dashboard

The goal is not simply to tell the user that something is dangerous, but to help them understand what was detected, why it matters, and what they should be careful about.

How we built it

Guardian Nexus was built as a full-stack, asynchronous application.

The backend uses Python, FastAPI, WebSockets, and LangGraph. AssemblyAI's Realtime API provides live speech-to-text, while LangGraph manages the flow between specialized AI components.

The system includes:

• Scam Detection Agent
• Threat Intelligence Agent
• Supervisor Agent
• Explanation Agent
• Deterministic 0–100 Risk Engine
• LLM reasoning and explanation layer
• Real-time WebSocket communication
• AssemblyAI mock and realtime provider abstractions
• Persistent threat-memory architecture
• Structured events and error handling

The frontend was built using Next.js, React, TypeScript, and Tailwind CSS, providing a real-time dashboard for transcripts, risk information, and security explanations.

A major focus was reliability. Rather than depending entirely on live external APIs, we created provider abstractions that allow components such as AssemblyAI to be tested independently.

The project currently has 398+ passing tests covering backend services, agent workflows, risk-engine logic, AssemblyAI providers, real-time functionality, integrations, and error handling.

Challenges we ran into

One of the biggest challenges was making multiple asynchronous components work together reliably in real time.

Streaming audio, transcription events, agent processing, risk calculation, and frontend updates all happen at different speeds. A failure or delay in one part should not bring down the entire system.

Another challenge was deciding where AI should and should not make decisions. We did not want the LLM to be responsible for every security decision, so we separated deterministic risk scoring from AI-based reasoning and explanation.

Testing realtime functionality was another challenge. External APIs are not ideal dependencies for hundreds of automated tests, which is why we introduced mock and realtime provider implementations for AssemblyAI.

Accomplishments that we're proud of

One of our biggest accomplishments is turning the original concept into a working, deployed system rather than stopping at an AI prototype.

We are particularly proud of:

• 398+ tests successfully passing
• Real-time AssemblyAI speech-to-text integration
• LangGraph-based multi-agent orchestration
• Deterministic 0–100 risk scoring
• LLM-powered threat explanations
• Real-time WebSocket communication
• Separate mock and realtime AssemblyAI providers
• Modular backend architecture
• Full frontend and backend integration
• A live deployed application

The project also pushed us to think beyond simply getting an AI model to produce an answer. A large part of the work became about architecture, reliability, testing, asynchronous processing, and making AI behavior understandable to users.

What we learned

We learned that building an AI application is much more than connecting an LLM to an API.

The most important lessons came from designing the system around clear responsibilities between components. LangGraph helped us structure the agent workflow, while deterministic logic provided consistency where an AI-generated decision alone would not be appropriate.

We also learned how important testing becomes when working with realtime systems. Mock providers, structured events, error handling, and modular services made it possible to test individual parts without constantly depending on external services.

Most importantly, we learned that for security-focused AI applications, explainability and reliability matter just as much as intelligence.

What's next for Guardian Nexus

The current system is only the foundation.

The next direction for Guardian Nexus is to expand it into a broader digital safety platform with:

• Mobile application support
• Optional family protection
• Trusted-contact alerts
• Stronger deepfake detection
• Persistent threat memory
• Cross-device protection
• Community-driven threat intelligence
• More advanced multimodal threat analysis

The long-term vision is for Guardian Nexus to become a personal digital safety layer that can protect users across different devices and communication channels while keeping the human in control of the final decision.

Built With

• agents
• artificial
• assemblyai
• cybersecurity
• detection
• fastapi
• generative
• intelligence
• langgraph
• learning
• llm
• machine
• multi-agent
• next.js
• react
• real-time
• speech-to-text
• systems
• threat
• websockets