2026-07-26 12:35 UTCIn-site rewrite5 min readUpdated: 2026-07-26 12:49 UTC

ARIA – Voice-native 3D spatial AI SoC with governed autonomy (BSL 1.1)

ARIA is a voice-native, 3D spatial security operations cockpit with governed autonomy that runs entirely on your own hardware. It uses a trust ladder mechanism where autonomous capabilities are earned through measured outcomes, and every action is audited. It supports local speech recognition, air-gapped deployment, and integrates with multiple security connectors.

SourceHacker News AIAuthor: saryismail

Notifications You must be signed in to change notification settings

Fork 0

Star 0

BranchesTags

Open more actions menu

Folders and files

NameName

Last commit message

Last commit date

Latest commit

History

1 Commit

.ebextensions

aria-memory

build

docs

electron

infra/trial-form

public

scripts

server

src

test

.env.example

.gitignore

DEPLOY.md

Dockerfile

LICENSE

Procfile

README.md

ROADMAP_AND_LIMITATIONS.md

docker-compose.yml

electron.vite.config.js

eslint.config.js

index.html

package-lock.json

package.json

pnpm-workspace.yaml

vercel.json

vite.config.js

Repository files navigation

Autonomous Resilience Intelligence Architecture

A voice-native, 3D spatial security operations cockpit with governed autonomy — that runs entirely on your own hardware if you want it to.

Source-available for evaluation and research. Not open source — see License.

What this is

Most AI security tools act and then ask you to trust them. ARIA inverts that: every autonomous capability has to earn its authority through measured outcomes, and you can see and bound exactly how far it is allowed to go.

It is a single-operator SOC cockpit you talk to. The entire feature set is a navigable 3D galaxy rather than a sidebar of menus. It ingests telemetry from your cloud, identity, code, and network surfaces, explains what matters in plain language, and proposes bounded actions that are gated by policy and written to an audit trail.

Honest status: ARIA is a working platform under active solo development, not a hardened commercial product. It is genuinely functional — real connectors, real local network and BLE discovery, real audit trails, a real local-model path — but parts of it are demo-grade and labelled as such throughout this README and in the product itself. Nothing here is presented as more finished than it is.

→ ROADMAP_AND_LIMITATIONS.md is the full engineering audit, published unedited: module-by-module status with file paths and line numbers, naming exactly which subsystems are production-grade and which are simulated. If it disagrees with this README, believe it instead. A shorter summary is in Maturity & what is not done below.

✨ Core features

🌌 Spatial Galaxy Command Interface

The whole platform is a Three.js/WebGL galaxy. Sectors are capability domains; nodes are individual panels. A three-tier colour system (blue nominal → amber threat → red critical) propagates live from scan and telemetry state, so posture is legible from across the room.

Four interchangeable ways to navigate: click a node, speak a destination, type a command, or let ARIA route you automatically when a critical event fires.

⚖️ Governed Autonomy & the Trust Ladder

The core idea, and the reason the rest exists. Autonomy is not a global on/off switch — it is per-capability and earned.

Four capabilities (threat_analysis, remediation, containment, identity_actions) each sit independently on a four-rung ladder:

Rung Mode Behaviour

1 approval ARIA proposes; a human approves every action

2 assisted ARIA acts on low-risk items, escalates the rest

3 auto ARIA acts autonomously except on critical-risk actions

4 full_auto ARIA acts, and reports

Promotion requires a track record of measured outcomes. Crucially, the model cannot promote itself — a capability only climbs when an operator promotes it, and demotion on a bad outcome is immediate. Every promotion, demotion, approval and action is written to an append-only audit log with a retention envelope.

🎙️ Voice-Native & Interruptible

Two-way spoken conversation over live data, not a chatbot bolted to a dashboard. Speech-to-text is always local (Whisper via @xenova/transformers) — your voice never leaves the machine. Text-to-speech is an optional cloud call you can leave unconfigured.

🛡️ Air-Gapped & Sovereign-Ready

ARIA is built for regulated environments where sending telemetry to a third-party SaaS is not merely undesirable but illegal. In LOCAL mode reasoning runs against your own model over an OpenAI-compatible endpoint (Ollama, vLLM, LM Studio, llama.cpp) and the sovereignty boundary is enforced in code, not promised in docs:

server/localLlm.mjs refuses to send a prompt to any host outside loopback or a private range. A public address is rejected unless you explicitly set ARIA_LOCAL_LLM_ALLOW_REMOTE=true.

LOCAL mode never silently falls back to a cloud provider, even when a cloud API key is sitting right there in your environment. If your local engine is down you get a clearly-labelled degraded summary and the reason — not a quiet egress.

The server binds to loopback by default and is not designed to face the internet.

🔌 Connectors & AI-SPM

AI Security Posture Management across GitHub, AWS, Okta, Snyk, Azure AD, VirusTotal, and Elastic Security — inventorying AI assets, secrets, model infrastructure, endpoints, and identity links, then mapping attack paths and blast radius across them. Connector credentials are encrypted at rest with AES-256-GCM.

📡 Local Network & Bluetooth Intelligence

Real ARP-table and BLE discovery with IEEE OUI vendor attribution and Bluetooth assigned-number decoding, device identity claims, and proximity estimation. Broadcast and multicast MACs are filtered at parse time rather than reported as devices. Active discovery is authorization-gated; passive visibility is not.

🚀 Quickstart

Under five minutes, no API keys required — ARIA starts with local-only features and every AI provider disabled but visibly labelled as such.

Prerequisites

Node.js ≥ 22 (uses node: builtins and native fetch)

npm (or pnpm)

Optional: Ollama for sovereign local reasoning

Optional: Docker, for the containerised server

Clone and install

git clone https://github.com//aria-guardian.git cd aria-guardian npm install

Configure

cp .env.example .env.local node scripts/generate-encryption-key.mjs --write # AES-256-GCM key for the credential vault

.env.example documents every variable. All AI keys are optional — fill in only what you want. See Bring Your Own Key.

npm run start:local # API on :5000 + web UI on :5173

Then open http://127.0.0.1:5173 and log in with the development operator:

username: operator password: aria

This built-in account exists only when NODE_ENV is development/test, or when ARIA_ENABLE_DEMO_LOGIN=true outside production. Production is fail-closed: it refuses to boot without real operator credentials and a credential encryption key. Set ARIA_LOGIN_USERNAME/ARIA_LOGIN_PASSWORD (or ARIA_OPERATORS) for any real deployment.

Other entry points

Command What it does

npm run start:local API + web UI together (recommended first run)

npm run aria Electron desktop app

npm run server API server only, on :5000

npm run dev Vite frontend only

npm run build Production frontend bundle

npm run dist Packaged desktop app (macOS .dmg)

npm run lint ESLint

npm run test:server Server test suite

Docker

export ARIA_CREDENTIAL_ENCRYPTION_KEY=$(node scripts/generate-encryption-key.mjs) docker compose up

Compose fails fast with an explanatory message if that key is unset — the image runs with NODE_ENV=production, which will not silently store credentials in plaintext. To reach a model server running on your host rather than in a container, set ARIA_LOCAL_LLM_URL=http://host.docker.internal:11434/v1.

🔑 Bring Your Own Key

ARIA ships with no keys, has no telemetry, and never proxies your traffic through anyone else's infrastructure. There is no analytics SDK in this repo — verify it yourself:

Every outbound host in the codebase is one you configured: your chosen LLM provider, your connectors' own APIs, and ElevenLabs if you enable speech.

Keys live in .env.local (gitignored) or your process environment. Connector credentials entered through the UI are encrypted at rest with AES-256-GCM, or can be delegated to AWS Secrets Manager.

Four Intelligence Modes, switchable live from the cockpit:

Mode Provider Requires Data leaves your network?

CLOUD Anthropic Claude ANTHROPIC_API_KEY Yes

GEMINI Google Gemini GEMINI_API_KEY_V2 Yes

LOCAL Any OpenAI-compatible local server a running engine No — enforced in code

HYBRID Cloud first, local failover either Only while cloud is reachable

The selector reflects reality, not aspiration: each mode is greyed out with a hover explanation when it cannot actually answer, and LOCAL displays the name of the model you actually have loaded. Query it directly at GET /api/model/status.

Sovereign setup

ollama serve ollama pull qwen3:8b

That is the entire configuration. ARIA defaults to Ollama on loopback and, if you have not named a model, uses the first one the server reports — so it works with whatever you have already pulled. To be explicit:

ARIA_LOCAL_LLM_URL=http://127.0.0.1:11434/v1 ARIA_LOCAL_LLM_MODEL=qwen3:8b

vLLM, LM Studio, llama.cpp's server and text-generation-webui all work through the same path — anything that speaks /v1/chat/completions.

🏗 Architecture

┌──────────────────────────────────────────────────────────────────┐ │ Renderer — React 19 + Three.js (Electron window or browser) │ │ Galaxy scene · panels · voice loop · Intelligence Mode selector │ └───────────────────────────────┬──────────────────────────────────┘ │ HTTP + WebSocket (loopback) ┌───────────────────────────────┴──────────────────────────────────┐ │ Node.js server — server/index.mjs │ │ │ │ authz · quotaGuard · rateLimiter · auditLog · securityHeaders │ │ ariaTrust (Trust Ladder) · actionRunner · policyStore │ │ reasoningEngine · autonomousResponse · ariaMemory │ │ aiSpmInventory · aiRiskEngine · aiSpmBlastRadius │ │ NetworkIntelligence/ · Bluetooth/ · connectors/ │ └───┬──────────────────────┬───────────────────────┬───────────────┘ │ │ │ ┌───┴────────┐ ┌─────────┴──────────┐ ┌────────┴─────────────┐ │ Reasoning │ │ Connectors │ │ Persistence │ │ │ │ │ │ │ │ Anthropic │ │ GitHub · AWS │ │ JSON under │ │ Gemini │ │ Okta · Snyk │ │ aria-memory/ │ │ Local │ │ Azure AD │ │ + optional KV mirror │ │ (sovereign)│ │ VirusTotal·Elastic │ │ AES-256-GCM vault │ └────────────┘ └────────────────────┘ └──────────────────────┘

Frontend — React 19 with Three.js via @react-three/fiber, drei, and postprocessing. Panels are lazily code-split. Vite for dev and build; electron-vite for the desktop target.

Server — a single Node.js HTTP + WebSocket server, no framework, ~4,500 lines of routing in server/index.mjs delegating to 74 focused modules. Loopback-bound by default. Role-based authz (owner/admin/analyst/viewer) with opaque in-memory session tokens.

Reasoning — one dispatcher (callAI) fans out to Anthropic, Gemini, or your local engine, with per-mode fallback policy that respects the sovereignty guarantee.

Persistence — file-based JSON under aria-memory/, with an optional Upstash KV mirror for durability across restarts. Deliberately boring: it is inspectable with cat, which matters for an audit trail.

Voice — local Whisper STT (@xenova/transformers, runs on-device); ElevenLabs TTS as an optional cloud call.

🧭 Maturity & what is not done

Publishing an honest list is more useful than a feature grid. Known gaps, current as of this commit — the full module-by-module account with file paths is in ROADMAP_AND_LIMITATIONS.md:

Area Status

Network scan depth ARP-tab

[truncated for AI cost control]