AURA — Cognitive Guardrail for High-Stakes Decisions

AURA inserts a deliberate pause before irreversible actions. Using Gemini for risk analysis and ElevenLabs for voice interruption, it prevents costly human errors without blocking execution.

Comment

Inspiration

In 2017, a single mistyped command at Amazon S3 took down half the internet for four hours. In 2012, Knight Capital lost $440 million in 45 minutes due to an untested deployment script. These weren't malicious attacks—they were human errors made by experienced engineers operating on autopilot.

The problem isn't incompetence. It's that critical systems don't interrupt us before we make irreversible mistakes. We've trained ourselves to click through "Are you sure?" dialogs without reading them. Text warnings have become invisible.

We asked: what if there was a system that didn't just warn you, but actually made you stop and think? Not a chatbot. Not an assistant. A cognitive guardrail that speaks once, then waits.

What it does

AURA is a Decision Interruption System. It sits at the boundary between decision and execution for high-risk actions.

When a dangerous action is initiated—like deploying to production without testing, or deleting a database—AURA:

  1. Intercepts the action before execution
  2. Analyzes the risk using Google Cloud's Gemini 2.0 Flash
  3. Speaks a single, authoritative voice warning through ElevenLabs
  4. Waits for explicit confirmation (typing "CONFIRM")
  5. Executes or cancels based on the user's deliberate choice

AURA is NOT a chatbot. It does not have conversations. It speaks once—a short, firm warning—then goes silent. The decision remains with the human.

The system works across two interfaces:

  • Web Application: Describe any action, get risk analysis and voice intervention
  • VS Code Extension: Integrated directly into the developer's IDE for commands like "Deploy to Production"

Three intervention personas adapt the tone:

  • Skeptic: Questions assumptions and evidence gaps
  • Auditor: Checks compliance and authorization
  • Chaos: Stress-tests failure modes and rollback plans

How we built it

Architecture:

  • Frontend: Vanilla HTML/CSS/JavaScript with a control-system aesthetic
  • Backend: Node.js/Express running on Google Cloud
  • AI Brain: Gemini 2.0 Flash via Vertex AI for risk analysis
  • Voice: ElevenLabs Text-to-Speech API with streaming for low-latency playback
  • IDE Integration: TypeScript VS Code extension

The Gemini Integration: We crafted a specialized system prompt that makes Gemini behave like a safety officer, not a helpful assistant. It evaluates inputs as decisions (not questions), determines risk level, and generates concise intervention messages that match the selected persona's tone.

The Voice Layer: ElevenLabs provides the authoritative voice. We tuned the voice settings for calm, firm delivery—not friendly, not conversational. The voice interruption is designed to break the pattern of clicking through warnings without thinking.

VS Code Extension: The extension registers high-risk commands (Deploy to Production, Delete Database, Force Reset Main Branch). When triggered, it queues the action, calls Gemini for analysis, plays the voice warning, and requires explicit CONFIRM input before proceeding.

Challenges we ran into

Making AI NOT be helpful: LLMs are trained to be agreeable and conversational. Getting Gemini to be firm, non-negotiating, and silent after one statement required careful prompt engineering. We had to explicitly forbid friendly language, emojis, and follow-up questions.

Voice playback in VS Code on Windows: Playing audio from a VS Code extension without opening external media players was tricky. We solved it using PowerShell with .NET's MediaPlayer class running in a hidden window.

Persona differentiation: Initially all three personas gave similar responses. We increased the temperature and added explicit persona modulation instructions with example phrases for each tone.

Avoiding the "chatbot trap": Every design decision had to reinforce that AURA is a guardrail, not an assistant. One voice output, then silence. No back-and-forth. No negotiation.

Accomplishments that we're proud of

  • Created a genuinely new interaction pattern: AI-driven voice interruption at execution boundaries
  • Built a working system across two platforms (web + VS Code) in hackathon timeframe
  • Successfully made an LLM behave like a safety system instead of a chatbot
  • Achieved low-latency voice playback using ElevenLabs streaming
  • Designed a UI that looks like a control system, not a chat interface

What we learned

  • Voice interruptions are psychologically different from text warnings—they demand attention
  • The hardest part of building AI safety tools is fighting the AI's instinct to be helpful
  • Constraint is a feature: AURA's power comes from what it doesn't do (no conversations, no debates)
  • Multi-platform deployment (web + IDE) dramatically increases real-world applicability

What's next for AURA

  • These are conceptual next steps and not part of the current submission.
  • Git hooks integration: Intercept dangerous git commands (force push, branch deletion)
  • CI/CD pipeline integration: Add AURA as a deployment gate in GitHub Actions/Jenkins
  • Team escalation: Route high-risk decisions to senior engineers for approval
  • Custom risk rules: Let teams define their own risk patterns and thresholds
  • Slack/Teams integration: Voice warnings in team communication channels
  • Audit logging: Track all interventions and confirmations for compliance

Built With

Share this project:

Updates