Veda

The Agentic-Native Operating System

An operating system written in Rust, with a voice agent built into the system.

Screenshots · Quick start · Make an app agentic · Architecture · Documentation

Say "Hey Veda, switch my wallpaper to the dunes" and it is done. The agent works in every application through the same code as your keyboard and mouse, and asks you before anything that is hard to undo. Everything here is Rust, from the UEFI bootloader and the microkernel to the window system and the applications.

Screenshots

Quick start

Veda builds on an x86-64 Linux machine with KVM. Install Rust and the build tools:

sudo apt install qemu-system-x86 qemu-system-gui qemu-system-modules-opengl ovmf \
  build-essential bc curl rsync m4 flex bison meson ninja-build cmake nasm \
  libgmp-dev libmpfr-dev libmpc-dev python3 python3-mako python3-packaging python3-yaml

The driver VM also needs KVM's nested virtualization (kvm_intel nested=1).

Then build Veda and boot it:

cargo automation doctor      # check the tools
cargo automation toolchain   # once, about half an hour: GCC, musl and Rust for Veda
cargo automation linux       # once: the driver VM's Linux and Mesa
cargo automation web         # once, an hour or more (optional): WebKit, for the browser
cargo automation python      # once, a few minutes (optional): Python, its standard library
cargo automation run         # build Veda and boot it in QEMU

Add a Deepgram API key in Settings → Agent, then say "Hey Veda", click the ring on the taskbar or press Super+Space. Try "Play Neon Horizon", "Show me the lighthouse photo, full screen" or "Delete the City Lights photo" (it asks you first).

On a PC: cargo automation iso writes a live system for a USB stick. Start it in UEFI mode, with VT-x and VT-d on and Secure Boot off. It runs from memory and leaves the PC's disks alone; see what it supports.

Make an app agentic

Agent support is part of the ui toolkit. An application describes its actions, reports its state and performs actions; ui::run registers it with the agent service and answers the agent between frames:

use ui::agent::{self, Action, AppAgentInfo, Risk, Value, arg_path, arg_str, json, show_path};

impl ui::App for Notes {
    fn update(&mut self, ui: &mut ui::Ui) { /* ... */ }

    fn agent_info(&self) -> Option<AppAgentInfo> {
        Some(agent::info(
            "A notes app: one note per file in ~/Notes.",
            vec![
                Action::new("add_line", "Adds a line at the end of the note shown")
                    .param("text", "string", "The line", true)
                    .build(),
                Action::new("delete_note", "Deletes a note for good")
                    .param("path", "string", "The note's file, such as ~/Notes/Ideas.txt", true)
                    .risk(Risk::Destructive)
                    .build(),
            ],
        ))
    }

    fn agent_state(&self) -> Value {
        json!({ "note": self.title.as_str(), "lines": self.lines.len() })
    }

    fn agent_invoke(&mut self, action: &str, args: &Value) -> Result<Value, String> {
        match action {
            "add_line" => { self.append(arg_str(args, "text")?); Ok(json!({ "lines": self.lines.len() })) }
            "delete_note" => {
                let path = arg_path(args, "path")?;
                self.delete(&path).map_err(|e| format!("{} could not be deleted: {e}", show_path(&path)))?;
                Ok(json!({ "deleted": show_path(&path) }))
            }
            other => Err(format!("Notes has no action called {other}")),
        }
    }
}

Declare each action's risk and run it through the same code as the keyboard and mouse: consent, memory and the conversation are the system's job. The full guide covers the rest.

Architecture

Where a proven library exists, Veda uses it: smoltcp, rustls, RustCrypto, FFmpeg, dav1d, glam, WPE WebKit and more.

Testing

cargo automation test        # unit tests on the host, then integration tests inside Veda
cargo automation test --ui   # plus the GUI and agent scripts

The scripts click through the desktop and the applications, and break things on purpose (Linux's drivers crash, a cable is pulled, services are killed) to check that Veda recovers by itself. The agent's scripts talk to a stand-in for Deepgram, so they are offline, deterministic and free.