ALINAos
The Declarative OS for Autonomous Agents

The Operating System Built for Agent Symbiosis

Trapped in browser tabs and fragile chat windows, AI agents lack true agency. ALINAos re-architects computing from the metal up: voice-driven, declarative, and natively sandboxed.

github.com/alinaos-orgNixOS NativeStreaming Voice Ingress
● VOICE_COCKPIT: STREAMING● SANDBOX: ENFORCED
ALINAos Ambient Desktop & Voice Cockpit Preview
01 // PRIMARY INGRESS

Voice as the Native Interface.
Typing into a chat box is legacy.

Human speech is 3–4× faster than typing and allows effortless continuous steering. ALINAos turns your machine into a real-time voice cockpit: connect directly to low-latency WebRTC audio channels to address specific agents, hand off complex tasks, and steer live execution streams hands-free.

🎙️
Real-Time Conversational Steering
Interrupt, redirect, or clarify requirements mid-execution with sub-second voice turnaround.
Direct Agent Dispatch
Address specialized agents by name (FORGE for code, SENTRY for deploys, RECON for research).
🔄
Spoken Intent ➔ Visual Surface
Speak high-level intent while the OS opens workspaces, tiles terminal buffers, and streams artifacts.
VOICE_SESSION // LIVE
LATENCY: 14ms (WebRTC)
YOU (Voice Input)
"FORGE, refactor the user namespace isolation module and run the test suite."
ALINA (Voice Synthesizer + Dispatcher)
"Spawning FORGE in sandboxed workspace. Opening ClawTerm pane 3 for live diff stream."
/etc/nixos/flake.nixHERMETIC // REPRODUCIBLE
{
  description = "ALINAos — Declarative Agent Platform";
  inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";

  outputs = { self, nixpkgs, ... }: {
    nixosConfigurations.alina = nixpkgs.lib.nixosSystem {
      modules = [
        ./modules/core-substrate.nix
        ./modules/agent-sandboxing.nix
        ./modules/voice-cockpit.nix
        ./modules/wayland-hyprland.nix
      ];
    };
  };
}
✓ Atomic generation 142 liveRollback available: gen 141 (0 downtime)
02 // DETERMINISTIC SUBSTRATE

NixOS at the Core.
Mutable operating systems break agents.

When autonomous agents install tools, compile code, and mutate system libraries on traditional OSes, configuration drift and broken dependencies are inevitable. ALINAos is built on NixOS: the entire operating system is pure, declarative code.

Instant Atomic Rollbacks

If an autonomous refactor or tool install fails, the OS automatically reverts to the last known-good generation in milliseconds.

Hermetic & Ephemeral Toolchains

Agents spin up exact compiler versions, libraries, and runtimes without polluting global system paths.

Multi-Machine Cluster Portability

Declare agent capabilities once and deploy the identical environment to compute offload nodes, home servers, or laptops.

03 // SPATIAL & AMBIENT PRESENCE

Living Inside Your Compositor.

Agents shouldn't hide in background daemons or messy browser tabs. On ALINAos, agents exist natively within the Wayland compositor via Hyprland layer-shell HUDs.

💎

Center-Island HUD

A dynamic status island anchored to your top bar displaying live agent heartbeats, token burn velocity, voice ingress indicators, and pending user approvals.

Layer-shell protocol • Zero flicker • Quickshell rendering
📟

ClawTerm Integration

A purpose-built terminal canvas where agents spawn their own tiled workspaces, stream live test diffs, and return focus to you the instant verification is needed.

Split-pane telemetry • Interactive review hooks

Keyboard-First Control

Invoke the voice listener, inspect active subagent trees, cycle diff streams, and grant runtime approvals without your hands ever leaving the home row.

Global IPC keybinds • Instant window placement
04 // SANDBOXED MULTI-AGENT FLEET

A Coordinated Fleet. Not a Monolithic Chatbot.

Single-agent chatbots get overwhelmed by complex tasks. ALINAos coordinates specialized autonomous personas executing in parallel inside kernel-confined user namespaces.

ORCHESTRATOR

ALINA

Front door, voice synthesizer, and primary workflow director. Translates spoken human intent into delegated subagent task trees.

Scope: Voice ingress • Task routing • Memory
🔨
ENGINEERING

FORGE

Autonomous software engineering lane. Implements complex features, manages git worktrees, fixes test regressions, and drafts PRs.

Scope: Compilers • LSP • Sandboxed worktrees
🛡️
INFRA & OPS

SENTRY

System health, monitoring, telemetry, and automated deployment management across cluster nodes and tailnet endpoints.

Scope: NixOS activations • Observability • CI/CD
🔍
RESEARCH

RECON

Deep technical and domain research sweeps, multi-source literature synthesis, and documentation indexing.

Scope: Deep search • Synthesis • Scraping
🎯
SECURITY AUDIT

SPECTER

Offensive security validation, static code audits, vulnerability scanning, and permission boundary verification.

Scope: Sandbox audits • Vuln probes • Policy
🧭
LIFE EXECUTIVE

MUSE & MEMORY

Persistent context for whole-life management: communications triage, morning briefs, schedule intelligence, and lifelong diarized memory.

Scope: Episodic memory • Inbox triage • Logistics

🔒 Kernel-Confined User Namespaces

Agents execute in strictly unprivileged user namespaces with dropped capabilities. Zero root risk, zero secret leakage.

UID_MAP: 1000 1000 1 [ISOLATED]
05 // THE SYSTEM STACK

Layered for Total Determinism & Agency

From bare metal to high-level voice streams, every layer of ALINAos is built to ensure autonomy without chaos.

05
SURFACE LAYER // Wayland Compositor & Voice Ingress
Hyprland center-island HUD • Real-time WebRTC audio cockpit • ClawTerm split canvas
User Interaction
04
ORCHESTRATION LAYER // Subagent Mesh & Event Bus
ALINA router • Parallel agent spawning • Shared memory index (220k+ records)
Agent Collaboration
03
ISOLATION LAYER // User Namespaces & Capability Drops
Unprivileged UID maps (1000 1000 1) • Sealed secrets vault • Ephemeral worktree isolation
Security Sandbox
02
SUBSTRATE LAYER // Declarative NixOS Core
Flake-managed generations • Atomic instant rollbacks • Zero configuration drift
Reproducibility
01
HARDWARE LAYER // Metal, Workstations & Offload Nodes
Primary host • Tailnet compute clusters • Local GPU / inference accelerators
Infrastructure
06 // THE MANIFESTO

Frequently Answered Questions

Why we are building an operating system instead of another AI app.

Why build an entire operating system instead of a desktop app or CLI?

Autonomous agents require deterministic system state, unprivileged sandbox boundaries, spatial desktop presence, and persistent memory across tool runs. An application running on a traditional mutable OS cannot safely give agents full agency without risking configuration drift, broken dependencies, or accidental system corruption. By building on NixOS and Wayland, ALINAos provides a rock-solid declarative foundation where agents are first-class citizens.

Why is voice the primary communication fabric?

Chat boxes force humans into an unnatural turn-based bottleneck. Voice is high-bandwidth, ambient, and allows continuous conversational steering while your eyes and hands remain on your work. ALINAos pairs real-time, low-latency WebRTC voice ingress with spatial desktop feedback.

How does the sandboxing model protect my machine?

Agents execute inside unprivileged Linux user namespaces (uid 1000) with capability drops. They cannot escalate to root, overwrite system binaries, or access unmounted secrets. If an agent performs a breaking build or refactor, NixOS atomic rollbacks restore the system in milliseconds.

When will ALINAos be available for public download?

ALINAos is currently our internal daily driver. We are packaging the declarative NixOS Flake modules, Wayland layer-shell HUD, and agent gateway harness for private alpha testers. Join the waitlist above to receive architecture dispatches and alpha build invitations.

PRIVATE ALPHA ACCESS

Own Your Intelligence.
Run Native.

The future of computing is not a rented subscription in a browser tab. It is an agent-first operating system running deterministically on your own machine.

Early access slots distributed in rolling cohorts.