Veda：原生面向 Agent 的操作系统

Veda 是一款内置 AI Agent 的操作系统——它不是后来加到桌面上的助手，而是系统的一部分，所有应用都为与它协作而设计。你可以像和房间里的人说话一样对它说：“嘿 Veda，把我的壁纸换成沙丘”，它就会通过与你的键盘和鼠标相同的操作方式，在任意应用中完成工作；对于难以撤销的操作，它会先征求你的同意。

系统的一切均从零开始以 Rust 编写，并位于此仓库中：UEFI 引导加载程序、基于能力的微内核、驱动程序、系统服务、窗口系统、工具包和应用程序。少量成熟的 crate 提供 TCP/IP 引擎、TLS 和密码学能力（smoltcp、rustls、RustCrypto）。Veda 可运行在 x86-64 PC、QEMU 和 VirtualBox 上。

操作系统原本是为坐在键盘前的人设计的。后来添加到系统中的助手通常只能读取屏幕、模仿点击，或局限于少数提供 API 的应用；系统本身也无法约束它的行为。Veda 反其道而行：Agent 是系统的一等用户，系统从设计上确保其工作可靠、可见且安全。

• Agent 是系统的一部分。 它是一项系统服务，在启动时运行，发生故障时会重启；它以任务栏上的小圆环形式存在，在被唤醒前保持休眠——你可以通过名称、点击圆环或按下 Super+Space 唤醒它。

• 每个应用都以原生方式与它通信。 Agent 支持是应用平台的一部分：应用会描述其操作，包括带类型的参数与风险等级；将自身显示内容作为结构化状态报告；并通过与键盘和鼠标相同的代码执行操作——因此窗口会完全如同由你亲自操作那样显示结果。无需屏幕抓取，也无需模拟点击。内置应用合计提供超过 70 项操作，从在文档中写作到启动一场赛车比赛。

• 系统确保 Agent 遵循你的同意。 每项操作都分为 常规、敏感 或 破坏性。常规操作会直接执行；其余操作会等待你的确认。这由 Agent 服务而非语言模型强制执行：调用会一直被保留至你作出答复，且只有桌面 Shell 能够答复（系统通过 init 附加到连接上的身份识别每个程序），Agent 从文档或应用中读取的任何内容都无法批准任何操作。

• 它基于真实上下文工作。 每段对话都从 Agent 协助你所需的信息开始：时间、屏幕上的窗口、各应用提供的操作、你告诉过它的个人信息，以及上一段对话的结束方式。工作期间，它会读取应用状态，因此始终依据真实存在的内容行动。

• 你的记忆仍属于你。 它只会记住你明确告诉它的信息——你的姓名、生活中的人、你偏好的做事方式——绝不保存自己的猜测。这些记忆存储在你的电脑上，且“设置”会展示全部内容，并允许你遗忘其中任何部分。

• 语音优先。 对话实时进行：你打断 Agent 时，它会停止说话并开始倾听。音频系统为此专门设计——包括回声消除和回声门控，确保 Agent 永远不会听到自己的声音；它与你交谈时，其他声音会被压低。在它休眠时，电脑上的语音检测器会监听语音，因此在无人说话时，没有任何内容会离开电脑。

• 智能能力是一项设置。 语音识别、语言模型和语音均来自 Deepgram 的 Voice Agent 平台，音频不会用于 Deepgram 的模型改进；模型、语音，甚至 Agent 的名称都可在“设置”中选择。

  ┌───────────────────────────────────────────────────────────────────────┐ │ 你：语音、键盘、鼠标 │ ├───────────────────────────────────┬───────────────────────────────────┤ │ Agent 服务 │ 桌面 Shell │ │ 对话（Deepgram Voice Agent） │ 圆环与 Agent 窗口 │ │ · 名称监听器 · 记忆 │ 同意请求 · 通知 │ │ 工作器：函数与同意 │ │ ├───────────────────────────────────┴───────────────────────────────────┤ │ 应用：操作 · 状态 · 调用（agentapp 协议） │ ├───────────────────────────────────────────────────────────────────────┤ │ 服务：窗口 · 文件 · 音频 · 网络 · Wi-Fi · 启动器 │ ├───────────────────────────────────────────────────────────────────────┤ │ vkernel：能力 · IPC · 隔离 · 调度 │ └───────────────────────────────────────────────────────────────────────┘

1. 监听。 在休眠状态下，Agent 会在电脑本地运行语音检测器。有人说话时，语音会被发送至能够识别 Agent 名称的识别器；一句呼叫它的话（“嘿 Veda，……”或“……，Veda？”）会唤醒它，名称前后说出的内容将成为它首先听到的话。
2. 对话。 被唤醒后，系统会启动一个 Deepgram Voice Agent 会话，其中包含 Agent 的指令、上述上下文及其函数。Deepgram 负责轮次管理、语言模型和语音；Veda 的音频服务则双向传输声音。
3. 行动。 模型会调用 Agent 自身的函数——窗口、文件、音量、Wi-Fi、壁纸、通知、计时器和提醒、记忆、系统及其正在运行的程序——并通过 use_app 和 read_app 调用每个应用的操作与状态。Agent 服务执行每次调用，并返回结构化结果。
4. 同意。 需要你确认的调用会被保留，并显示在 Agent 窗口中（窗口关闭时则以通知形式显示），明确说明将发生什么以及作用于什么对象。允许后便会执行；拒绝或等待其过期，则不会执行。敏感操作可以被永久允许；破坏性操作则每次都会询问。

Agent 文档完整说明了其设计：协议、语音管线、同意机制、记忆以及 Agent 的测试方式。

• 微内核。 vkernel 只负责隔离、调度、内存和 IPC：包括带权限的能力句柄、可携带句柄的通道、VMO、事件、futex 和中断对象。支持采用 x2APIC 的 SMP、无滴答定时器和 XSAVE。驱动程序、文件系统、窗口系统和 Agent 都是用户空间进程，并由 init 监管：如果窗口系统崩溃，它会被重启，桌面会自行恢复。
• 桌面。 启动流程会无缝延续引导画面（圆环周围呼吸灯、名称和标语渐显、启动音效），并在桌面准备就绪后将其淡化为桌面；采用合成式窗口管理器，提供服务端窗口装饰、阴影、动画、窗口贴靠，以及带实时缩略图的 Alt+Tab 切换器。在配备 Intel 显卡的 PC 上，它使用 OpenGL ES 在 GPU 上合成，每一帧都会在垂直消隐期间整体翻转；其他设备则在处理器上合成。Shell 提供壁纸、桌面图标（回收站排在第一位）、任务栏、可搜索的开始菜单、日历和通知；vui 工具包提供控件、菜单、对话框、矢量图标，以及采用 Inter 和 JetBrains Mono 字体的抗锯齿文本，其应用均兼容 Agent。
• 网络和 Wi-Fi。 用户空间网络服务支持 IPv4、IPv6、DHCP、DNS、路由、TCP、UDP 和 ICMP；Wi-Fi 服务能够扫描并加入启用管理帧保护的 WPA2、WPA3 和开放网络，记住网络，并自动重新连接与漫游。驱动程序只负责传输帧。包括 Agent 在内的应用可通过 vtls 获得 TLS 1.3 和 1.2 支持（HTTPS、安全 WebSocket），证书会依据 Mozilla 根证书进行检查。在 QEMU 下，模拟 Wi-Fi 环境可提供连接至互联网的接入点。参见 Networking。
• 音频。 混音音频服务提供经回声消除的采集和音量压低功能，既为音乐设计，也同样服务于 Agent 的对话。
• 存储。 提供 virtio-blk 和 AHCI（SATA）驱动，以及文件系统服务；该服务将主目录保存于独立磁盘，并提供崩溃安全的快照，因此文件可在重启后保留。Agent 的记忆和密钥存储在仅 Agent 可打开的私有目录中。
• 应用。 包括文本编辑器、照片、音乐、文件、终端、任务管理器、设置和关于，以及两款 3D 游戏：赛车游戏 Velocity 和太空射击游戏 Starfall，均由 v3d 软件 3D 引擎渲染。
• 3D 图形。 支持采用 GLSL ES 1.00 和 3.00 的 OpenGL ES 3.0（vgl、vglsl），每次调用均按照规范要求进行检查。它可通过 QEMU 的 3D virtio-gpu 在宿主机 GPU 上渲染；通过 Mesa 的 iris 驱动在 Intel Iris Xe 上渲染（Tiger Lake 至 Raptor Lake）；或在两者均不可用时使用多线程软件渲染器。Prism 展示了这套能力：反光结、采用实例化绘制的阴影映射水晶，以及通过变换反馈模拟的火花喷泉，在 QEMU 下达到每秒 55 帧。
• Veda 内的 C 与 GCC。 你可以在终端或文本编辑器中编写 C 程序，使用 GCC 16 编译并运行，无论是在模拟器还是 PC 上皆可。C 程序是基于 musl C 库的静态 ELF 可执行文件，其系统调用会进入以 Rust 编写的 POSIX 层 vposix：提供文件、目录、管道、带行编辑和 termios 的终端、线程、mmap、posix_spawn、时钟以及由其自行触发的信号。工具链基于上游版本并加入少量补丁构建（ports/）；交叉编译器可在开发机器上为 Veda 构建 C 和 C++ 程序。参见 C on Veda。
• 工具链。 一条命令即可构建可启动磁盘镜像，并在 QEMU 或 VirtualBox 中运行；脚本化的无头运行可驱动 GUI 和 Agent，并检查截图与日志。

文本编辑器	照片
音乐	文件
Velocity	Starfall
终端中的 GCC	Prism（OpenGL ES 3.0）

所有截图均通过 cargo xtask script docs/screenshots.vts 在 QEMU 中拍摄（Agent 与 Deepgram 的替身服务进行对话）。Veda 也可在 VirtualBox 中运行（见下文）。

Veda 可在安装 Windows 10 或 11 的 x64 PC，以及 Linux 系统上构建。

• Rust（稳定版）。rust-toolchain.toml 会让 rustup 在首次使用时安装额外目标。
• 用户空间程序所需的链接器，这些程序是 PE 可执行文件。在 Windows 上，使用 Microsoft 链接器：Visual Studio 2022，或安装了 MSVC 构建工具（link.exe）的 Visual Studio Build Tools；Rust 安装程序会提供安装选项。在 Linux 上，使用 Rust 自带的 LLVM 链接器（rust-lld）。
• QEMU 和 OVMF UEFI 固件，Windows 版 QEMU 已包含后者。在 Linux 上，使用发行版的软件包（Debian 和 Ubuntu 中为 qemu-system-x86、qemu-system-gui、qemu-system-modules-opengl 和 ovmf），并需要访问 /dev/kvm（kvm 组成员具有该权限）；借助它，QEMU 可通过处理器的硬件虚拟化运行 Veda。以及/或者使用 VirtualBox 7.1 或更高版本（无需 Extension Pack）。
• 对于 Agent：一个在 Veda“设置”中输入的 Deepgram API 密钥。
• 对于镜像中的 C 和 GCC（可选）：由 cargo xtask toolchain 一次性构建工具链所需的构建工具；Windows 上需使用 MSYS2 及少量软件包，Linux 上则使用发行版提供的工具（参见 C on Veda）。

检查环境：

这会构建所有组件，写入磁盘镜像 target/veda/veda.img，并在 QEMU 窗口中启动它。在较新的 PC 上，首次构建需一到两分钟（还会渲染示例图片和音乐）；后续构建均为增量构建。实用选项如下：

cargo xtask run --resolution 1920x1080 --smp 4 --memory 2048
cargo xtask run --cmdline "run=editor"

--cmdline "run=NAME" 会在启动后运行 /system/bin/NAME.exe。默认情况下，系统通过有线网卡连接 QEMU 的 NAT 网络；如需 Wi-Fi：

cargo xtask run --net wifi

这还会启动 airsim，一个模拟 Wi-Fi 环境；其中的网络（“Veda Home”“Veda WPA3”等，密码为 veda-wifi）可连接互联网。--net both 会添加有线网卡。所有命令和选项请参见 cargo xtask help。

每条命令都可通过 --vm virtualbox 使用 VirtualBox 替代 QEMU，并使用相同的选项：

cargo xtask run --vm virtualbox

xtask 会创建名为“Veda”的 VirtualBox 虚拟机，并在每次运行时更新它；其磁盘使用与 QEMU 相同的镜像，因此构建无需转换，且主目录可在两者之间共享。VirtualBox 使用 CPU 的硬件虚拟化（与 Linux 上通过 KVM 运行的 QEMU 一样；原文在此处截断）。

Veda: The Agentic-Native Operating System

Veda is an operating system with an AI agent built into it — not an assistant added to a desktop, but a part of the system that every application is made to work with. You talk to it the way you would talk to someone in the room — "Hey Veda, switch my wallpaper to the dunes" — and it does the work through the same operations as your keyboard and mouse, in any application, and asks you before anything that is hard to undo.

Everything is written from scratch in Rust and lives in this repository: the UEFI bootloader, a capability-based microkernel, the drivers, the system services, the window system, the toolkit and the applications. A few mature crates provide the TCP/IP engine, TLS and cryptography (smoltcp, rustls, RustCrypto). Veda runs on x86-64 PCs, in QEMU and VirtualBox.

Operating systems were designed for a person at a keyboard. An assistant added to one later usually has to read the screen, imitate clicks or make do with the few applications that offer an API, and the system has no say in what it does. Veda turns this around: the agent is a first-class user of the system, and the system is built so that its work is reliable, visible and safe.

• The agent is part of the system. It is a system service, started at boot and restarted if it fails, present as a small ring on the taskbar and asleep until you call it — by its name, with a click on the ring or with Super+Space.

• Every application speaks to it natively. Agent support is part of the application platform: an application describes its actions, with typed parameters and a risk level, reports what it shows as structured state, and carries out actions through the same code as the keyboard and mouse — so the window shows the result exactly as if you had done it. No screen scraping, no simulated clicks. The built-in applications offer more than 70 actions between them, from writing in a document to starting a race.

• The system holds the agent to your consent. Every action is routine , sensitive or destructive. Routine actions just happen; the others wait for your OK. The agent service enforces this, not the language model: the call is held until you answer, only the desktop shell can answer (the system knows each program by the identity init attaches to its connections), and nothing the agent reads in a document or an application can approve anything.

• It works from real context. Every conversation starts with what the agent needs to help: the time, the windows on the screen, every application's actions, what you have told it about yourself and how your last conversation ended. While it works it reads the applications' state, so it acts on what is really there.

• Your memory stays yours. It remembers what you tell it plainly — your name, the people in your life, how you like things done — never its own guesses. That memory is kept on your computer, and Settings shows all of it and forgets any of it.

• Voice comes first. Conversations happen in real time: interrupt the agent and it stops and listens. The audio system is built for it — echo cancellation and an echo gate so that the agent never hears itself, and other sound turned down while it talks with you. While it sleeps, a voice detector on the computer listens for speech, so that nothing leaves the computer while nobody speaks.

• The intelligence is a setting. Speech recognition, the language model and the voice come from Deepgram's Voice Agent platform, with the audio opted out of Deepgram's model improvement; the model, the voice and even the agent's name are chosen in Settings.

  ┌───────────────────────────────────────────────────────────────────────┐ │ You: voice, keyboard, mouse │ ├───────────────────────────────────┬───────────────────────────────────┤ │ Agent service │ Desktop shell │ │ conversation (Deepgram Voice │ the ring and the agent's window │ │ Agent) · name listener · memory │ consent requests · notifications │ │ worker: functions and consent │ │ ├───────────────────────────────────┴───────────────────────────────────┤ │ Applications: actions · state · invoke (the agentapp protocol) │ ├───────────────────────────────────────────────────────────────────────┤ │ Services: windows · files · audio · network · Wi-Fi · launcher │ ├───────────────────────────────────────────────────────────────────────┤ │ vkernel: capabilities · IPC · isolation · scheduling │ └───────────────────────────────────────────────────────────────────────┘

1. Listening. Asleep, the agent runs a voice detector on the computer. When someone speaks, the speech goes to a recogniser that knows the agent's name; a sentence that calls it ("Hey Veda, …", "…, Veda?") wakes it, and what was said with the name is the first thing it hears.
2. Conversation. Waking opens a Deepgram Voice Agent session with the agent's instructions, the context above and its functions. Deepgram takes care of turn-taking, the language model and the voice; Veda's audio service carries the sound both ways.
3. Action. The model calls the agent's own functions — windows, files, volume, Wi-Fi, wallpaper, notifications, timers and reminders, memory, the system and its running programs — and, through use_app and read_app, every application's actions and state. The agent service runs each call and answers with a structured result.
4. Consent. A call that needs your OK is held and shown in the agent's window (or as a notification while the window is closed), saying exactly what will happen and to what. Allow it and it runs; decline it, or let it expire, and it does not. Sensitive actions can be allowed for good; destructive ones are asked about every time.

The agent describes the design in full: the protocols, the voice pipeline, consent, memory and how the agent is tested.

• Microkernel. vkernel only does isolation, scheduling, memory and IPC: capability handles with rights, channels that carry handles, VMOs, events, futexes, interrupt objects. SMP with x2APIC, tickless timers and XSAVE. Drivers, the file system, the window system and the agent are user-space processes, supervised by init: if the window system crashes, it is restarted and the desktop comes back on its own.
• Desktop. A startup sequence that carries the boot splash on without a seam (a breathing light around the ring, the name and tagline rising in, a startup sound) and dissolves it into the desktop once that is ready; a compositing window manager with server-side decorations, shadows, animations, window snapping and an Alt+Tab switcher with live thumbnails, which composes on the GPU with OpenGL ES on PCs with Intel graphics, every frame flipped whole at the vertical blank, and on the processor elsewhere; a shell with wallpaper, desktop icons (the Trash first), a taskbar, a searchable start menu, a calendar and notifications; the vui toolkit (widgets, menus, dialogs, vector icons, anti-aliased text with the Inter and JetBrains Mono fonts), whose applications are agent-compatible.
• Networking and Wi-Fi. A user-space network service (IPv4 and IPv6, DHCP, DNS, routing, TCP, UDP, ICMP) and a Wi-Fi service that scans, joins WPA2, WPA3 and open networks with management frame protection, remembers networks, reconnects and roams on its own. Drivers only move frames. Applications, the agent among them, get TLS 1.3 and 1.2 (HTTPS, secure WebSockets) from vtls, with certificates checked against the Mozilla roots. Under QEMU a simulated Wi-Fi environment provides access points bridged to the Internet. See Networking.
• Audio. A mixing audio service with echo-cancelled capture and ducking, built for the agent's conversations as much as for music.
• Storage. virtio-blk and AHCI (SATA) drivers and a file system service that keeps the home directory on its own disk with crash-safe snapshots, so your files survive restarts. The agent's memory and key live in a private directory that only the agent can open.
• Applications. Text Editor, Photos, Music, Files, Terminal, Task Manager, Settings and About, and two 3D games, Velocity (racing) and Starfall (a space shooter), rendered by the v3d software 3D engine.
• 3D graphics. OpenGL ES 3.0 with GLSL ES 1.00 and 3.00 (vgl, vglsl), every call checked as the specification requires. It renders on the host's GPU through QEMU's 3D virtio-gpu, on Intel's Iris Xe through Mesa's iris driver (Tiger Lake to Raptor Lake), or with a multi-threaded software renderer where there is neither. Prism shows it off: a reflective knot, shadow-mapped crystals drawn with instancing, and a fountain of sparks simulated with transform feedback, at 55 frames a second under QEMU.
• C, and GCC inside Veda. Write a C program in the Terminal or the Text Editor, compile it with GCC 16 and run it, in an emulator or on a PC alike. C programs are static ELF executables on the musl C library, whose system calls go to vposix, a POSIX layer written in Rust: files, directories, pipes, a terminal with line editing and termios, threads, mmap, posix_spawn, clocks and signals they raise themselves. The toolchain is built from the upstream releases with small patches (ports/), and a cross compiler builds C and C++ programs for Veda on the development machine. See C on Veda.
• Tooling. One command builds a bootable disk image and runs it in QEMU or VirtualBox; scripted, headless runs drive the GUI and the agent and check screenshots and logs.

Text Editor	Photos
Music	Files
Velocity	Starfall
GCC in the Terminal	Prism (OpenGL ES 3.0)

All screenshots are taken in QEMU by cargo xtask script docs/screenshots.vts (the agent talking to the stand-in for Deepgram). Veda also runs in VirtualBox (see below).

Veda is built on an x64 PC with Windows 10 or 11, or with Linux.

• Rust (stable). rust-toolchain.toml makes rustup install the extra targets on first use.
• A linker for the user-space programs, which are PE executables. On Windows, the Microsoft linker: Visual Studio 2022 or the Visual Studio Build Tools with the MSVC build tools (link.exe), which the Rust installer offers to set up. On Linux, LLVM's linker, which comes with Rust (rust-lld).
• QEMU and the OVMF UEFI firmware, which QEMU for Windows includes. On Linux, the distribution's packages (on Debian and Ubuntu qemu-system-x86, qemu-system-gui, qemu-system-modules-opengl and ovmf), and access to /dev/kvm (members of the kvm group have it), with which QEMU runs Veda on the processor's hardware virtualization. And/or VirtualBox 7.1 or newer (no Extension Pack needed).
• For the agent: a Deepgram API key, entered in Veda's Settings.
• For C and GCC in the image (optional): build tools for the toolchain, which cargo xtask toolchain builds once: on Windows MSYS2 with a few packages, on Linux the distribution's (see C on Veda).

Check the environment:

This builds every component, writes the disk image target/veda/veda.img and boots it in a QEMU window. The first build takes one to two minutes on a recent PC (it also renders the sample pictures and music); later builds are incremental. Useful options:

cargo xtask run --resolution 1920x1080 --smp 4 --memory 2048
cargo xtask run --cmdline "run=editor"

--cmdline "run=NAME" starts /system/bin/NAME.exe after boot. The machine is on QEMU's NAT through a wired card by default; for Wi-Fi:

cargo xtask run --net wifi

This also starts airsim, a simulated Wi-Fi environment whose networks ("Veda Home", "Veda WPA3", ...; password veda-wifi) lead to the Internet. --net both adds the wired card. See cargo xtask help for all commands and options.

Every command takes --vm virtualbox to use VirtualBox instead of QEMU, with the same options:

cargo xtask run --vm virtualbox

xtask creates (and on every run updates) a VirtualBox machine named "Veda" whose disks are the same images QEMU uses, so builds need no conversion and the home directory is shared between the two. VirtualBox uses the CPU's hardware virtualization (as QEMU does on Linux, with KVM; on Windows QEMU emulates the CPU in software). The machine is closer to a real PC: SATA disks, an Intel PRO/1000 network card, PS/2 keyboard and mouse, AC'97 sound with the host's speakers and microphone (Windows must allow VirtualBox to use the microphone, in Settings → Privacy). Click into the window to use the mouse; the right Ctrl key releases it.

On a high-DPI display under Windows the window enlarges the screen as QEMU's does, by the whole part of the display scaling (2x at 250%), or less if the window would not fit on the screen. --scale sets the factor (--scale 2.5 matches other programs at 250%; whole numbers look sharpest) and --resolution gives Veda a larger desktop:

cargo xtask run --vm virtualbox --resolution 1600x1000 --scale 2

To put Veda on your real network (your router's DHCP and DNS, the real Internet) through the host's network adapter, Wi-Fi included:

cargo xtask run --vm virtualbox --net bridged

shot, script and test work with --vm virtualbox too; scripts that need QEMU (the simulated Wi-Fi, and on Linux the mouse, which xtask moves in VirtualBox on Windows only) are skipped.

A real PC, from a USB stick

writes target/veda/veda.iso, a live system. Write it to a USB stick with Rufus (partition scheme GPT, target system UEFI, ISO mode), or as it is with any image writer, and start the PC from the stick (usually from the firmware's boot menu: F12, F11 or Esc at power-on) in UEFI mode with Secure Boot off, as Veda's loader is not signed. Veda runs from memory and leaves the PC alone: no disk driver starts, so it never reads or writes the PC's disks or the systems installed on them, and its home directory lasts until the PC is turned off. To try the stick in QEMU first:

On real hardware the desktop appears in the screen mode the firmware provides (1920x1080, or the largest below it). On Intel's integrated graphics of the last generations (Tiger Lake to Raptor Lake: Iris Xe and UHD Graphics) a display driver shows every frame whole, flipped at the screen's vertical blank, so animations run as smoothly as in a virtual machine; elsewhere the window system draws into the firmware's framebuffer. USB keyboards, mice and hubs work on the USB 3 (xHCI) controllers that PCs have had since about 2012, as do PS/2 keyboards and mice; other USB devices, the stick included, are left alone. Sound plays on HD Audio, the sound hardware of nearly every PC since 2005: through the speakers, or the headphones when they are plugged in, and the line outputs, with the microphone (built in, or on a jack when one is plugged in) for the agent. Built-in microphones wired to an audio DSP rather than to the codec, as in many recent laptops, stay silent; HDMI and DisplayPort audio need more of a graphics driver than Veda has yet (it keeps the firmware's screen mode); and few PCs have network hardware Veda supports. To try USB input or HD Audio in QEMU:

cargo xtask run --input usb
cargo xtask run --sound hda

1. Open Settings → Agent and add your Deepgram API key. The agent's name, voice, language model, listening and memory are on the same page.
2. Say "Hey Veda" , click the small ring at the right of the taskbar or press Super+Space.
3. Talk naturally, ask follow-up questions, interrupt whenever you like, and say goodbye when you are done. It goes back to sleep and listens for its name.

Veda hears you through your PC's microphone and answers through its speakers, under QEMU and VirtualBox alike.

Things to ask:

• "Switch my wallpaper to the dunes."

• "Play Neon Horizon."

• "Write a shopping list with eggs, milk and coffee."

• "Show me the lighthouse photo, full screen."

• "Remind me to stretch in twenty minutes."

• "What's using the most memory?"

• "Start a race in Velocity."

• "Delete the City Lights photo" — and see it ask you first.

• "What do you know about me?"

• Click the logo (the ring in the middle of the taskbar) or tap the Super key for the start menu; type to search for an application.

• Click a taskbar button to open, focus or minimise an application; middle-click opens another window. Click the clock for the calendar.

• Double-click desktop icons. Right-click the desktop to change the wallpaper.

• What you delete goes to the Trash , the first icon on the desktop: open it to restore items where they were, or to empty it. Drag items of the desktop onto it, or press Delete in Files (Ctrl+Z puts them back; Shift+Delete deletes for good).

• Drag a window to the top of the screen to maximise it, or to a side to fill that half (or use Super+Left/Right/Up/Down). Super+D shows the desktop, Alt+Tab switches windows and Alt+F4 closes the active one.

• The speaker icon on the taskbar opens the volume control (scroll over it to change the volume). The network icon next to it shows the Wi-Fi signal and opens the list of networks to join.

Your files live in /home/user, kept on target/veda/home.img across restarts and rebuilds (--fresh-home starts over).

Every application is agent-compatible: what you can do with the mouse and keyboard, the agent can do too, through the application's own actions.

Application	What it does	What the agent can do
Text Editor	Tabs, syntax highlighting (Rust, C, TOML, Markdown), find and replace, word wrap, line numbers, zoom, unlimited undo, open/save dialogs.	Create, open, read and write documents; find and replace, select, undo, save; save under another name or discard changes (with your OK).
Photos	A thumbnail library of ~/Pictures and a viewer with zoom, pan, rotation, full screen, slideshows, details and "set as wallpaper"; PNG, JPEG (including progressive), BMP and QOI.	Show any picture, zoom, rotate, go full screen, run a slideshow, show details, set a picture as the wallpaper.
Music	A library of ~/Music, now playing with cover art and a live spectrum visualiser, seeking, shuffle and repeat; plays QOA and WAV through the audio service.	Play a song by its name, pause, stop, skip, seek, shuffle, repeat, set the volume.
Files	Places sidebar, breadcrumbs, list and icon views with thumbnails, search, copy/cut/paste, rename, new folders and documents, properties, free space; delete to the Trash (with undo), which lists where each item came from and when, and restores or empties.	Open folders and files, search, show properties, make folders; copy, move, rename and delete to the Trash (with your OK); restore from the Trash; empty it (asked every time).
Terminal	A command shell with about fifty built-in commands for files, processes, the network (wifi, ifconfig, ping, nslookup, curl, ...) and the system, history and tab completion. Runs programs, C programs and GCC included, as a Unix terminal does: line editing, termios, Ctrl+C, pipes and redirections.	Run a command (with your OK), read its output, interrupt it.
Task Manager	Processes with CPU and memory use, "end task", and live performance graphs.	List processes, show and read the performance graphs, end a program (asked every time).
Settings	Wallpaper gallery, the agent (Deepgram key, name, voice, language and speech models, listening, memory, permissions), network and Wi-Fi (connection, networks in range, saved networks, interfaces, diagnostics), display information and system details.	Open a page, change the agent's voice and speaking rate; rename the agent or change its language model (with your OK). Never the key.
Velocity	An arcade 3D racing game against computer opponents on a procedurally generated circuit.	Start, pause, resume or restart a race; change the track, laps or opponents.
Starfall	A 3D space shooter through asteroid fields and enemy waves.	Start, pause, resume or restart a game.

The games are drawn by v3d, a multi-threaded fixed-point software 3D renderer, and Prism by OpenGL ES. Beyond the applications, the agent's own functions cover windows, files, sound, Wi-Fi, the wallpaper, notifications, timers and reminders, its memory and the system.

Building agent-compatible applications

Agent support is part of the vui application platform. An application describes what it can do, reports what it shows and performs actions; vui::run registers it with the agent service and answers the agent between frames:

use vui::agent::{self, Action, AppAgentInfo, Risk, Value, arg_path, arg_str, object, show_path};

impl vui::App for Notes {
    fn update(&mut self, ui: &mut vui::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 {
        object! { "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(object! { "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(object! { "deleted" => show_path(&path) })
            }
            other => Err(format!("Notes has no action called {other}")),
        }
    }
}

Actions are written for a language model (short imperative descriptions, units and defaults spelled out), declare their risk, name their targets explicitly and go through the same code as the keyboard and mouse. The consent, the memory and the conversation are the system's job, not the application's. See Making an application agent-compatible.

runs the host unit tests of the libraries (the agent's protocol, tools, prompt, memory, wake word and echo gate, the kernel ABI, heap, IPC, service protocols, math, rasterizer, fonts, image codecs, 2D graphics, text editing, paths and file types, audio, ELF loading, the POSIX layer, build tool) and then boots Veda headless with the systest integration tests (IPC, sockets, memory, threads, file system, launcher, crash reports, recovery of the window system after it is killed, and C programs that check the C library and the POSIX layer), failing on any panic.

The agent is tested end to end against a stand-in for Deepgram that runs on the host (tests/agent/): conversations, function calls, interruptions, echo, consent in the window and in notifications, waking by name over music, every application's actions and restarts — deterministic, offline and free. tests/real/agent-*.vts talk to the real Deepgram with the key in DEEPGRAM_API_KEY, with a synthetic voice speaking into a virtual microphone.

Networking has its own host tests (the 802.11 protocol and cryptography against published test vectors, station against access point, TCP/IP stacks over a simulated cable, the Wi-Fi simulator, TLS handshakes against a rustls server and real certificate chains), and nettest checks DNS, TCP, HTTP, HTTPS and ping from inside Veda.

GUI automation scripts in tests/ui/ click through the desktop and applications, check the log and save screenshots; two of them run C programs in the Terminal and compile one with GCC inside Veda (they need the toolchain, and are skipped without it). The Wi-Fi scripts join networks through the desktop and break the simulated network in many ways (access point gone, disconnection, outages, the radio or the Wi-Fi service vanishing) to check that Veda recovers by itself. Run them all, the agent's included, with the unit and integration tests, or one at a time:

cargo xtask script tests/agent/wake-name.vts


cargo xtask shot --wait 20

(shot boots headless and saves target/veda/screen.png.)

The serial console (kernel log plus every program's output) is saved to target/veda/serial.log.

Path	Contents
services/agent/	the agent: conversations, the name listener, functions, consent, memory
lib/agent/	the agent's logic: Deepgram protocol, functions, instructions, wake word, echo gate, memory, configuration
boot/	vboot, the UEFI bootloader
kernel/	vkernel, the microkernel
lib/	shared libraries: abi (system call ABI), rt (runtime), posix (the POSIX layer under the C library), elf (ELF executables), ipc (message codec and protocol macros), proto (service protocols, the agent's included), gfx/raster/font/image (2D graphics), ui (toolkit and its agent support), v3d (3D engine), glsl and gl (the GLSL ES compiler and OpenGL ES 3.0), net and tls (networking and TLS for applications), web (HTTP and WebSocket), json, audio (mixing, echo cancellation, voice detection, synthesis), usb (descriptors, HID reports, xHCI structures), hda (HD Audio codecs and their routes), igpu (Intel's display engine), text, math, ...
services/	init (service registry, launcher, process identity), vfs, devmgr (PCI), compositor, audio, agent, netd (network), wlan (Wi-Fi)
drivers/	ps2, virtio-input, xhci (USB 3 controllers: hubs, keyboards, mice), virtio-blk, ahci (SATA), hda (Intel HD Audio), virtio-snd, ac97 (AC'97 sound), virtio-net, e1000 (Intel PRO/1000), vwifi (the virtual Wi-Fi radio), virtio-gpu (3D on the host's GPU), intel-gpu (Intel's integrated graphics: frames flipped at the vertical blank, and the GPU's engines for OpenGL ES), flipsim (a display that flips, for tests), gemsim (an Intel GPU that runs nothing, for tests)
apps/	the desktop shell (the agent's ring, window and consent requests) and the applications, including racer (Velocity) and starfall
ports/	the C toolchain built from source: GCC, binutils, GMP, MPFR, MPC and musl, each an upstream release and Veda's patch
tests/	the agent's scripts (agent/, and real/ for the real services), systest and nettest (in-system tests), C and C++ test programs (c/), GUI automation scripts
tools/	host programs generating wallpapers, sample pictures and music at build time, and airsim (the simulated Wi-Fi environment)
third_party/	vendored crates with Veda patches (smoltcp)
xtask/	the build system: cross-compilation, disk image, QEMU and VirtualBox, automation, the stand-in for Deepgram
assets/	fonts, application manifests, and firmware for laptop speaker amplifiers
docs/	documentation, the README's screenshots, and the icon and social preview (docs/icon/)

• The agent: the voice agent, its functions, consent and memory, and how applications become agent-compatible.
• Architecture: how the system fits together.
• Networking: the network and Wi-Fi services, the simulated Wi-Fi environment, security and tests.
• C on Veda: writing, compiling and running C programs, the POSIX layer, and how the toolchain is built.
• Developing: build commands, the system image, writing applications, performance notes.
• Coding conventions.

Copyright © 2026 Vahid Mohammadi.

Veda is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License, version 3, as published by the Free Software Foundation (see LICENSE). It is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

The bundled fonts (Inter, Lato, JetBrains Mono) are under the SIL Open Font License 1.1; see assets/fonts/. The firmware in assets/firmware/cirrus/ is Cirrus Logic's, from the Linux firmware collection: it runs on the speaker amplifiers' own DSP, not in Veda, and is redistributed unmodified under Cirrus Logic's licence (LICENSE.cirrus there), for use only with their devices. Vendored third-party code keeps its own license; see third_party/. The C toolchain an image may contain keeps its own licences too: GCC and binutils GPL version 3 or later (the GCC runtime library with its Runtime Library Exception, so programs GCC builds keep their own licences), GMP, MPFR and MPC LGPL version 3 or later, musl MIT; their source is the upstream releases ports/*/port.toml names, with the patches beside them.