Architecture

Tauri 2 + React 19 + Rust — a modern, multi-process desktop platform.

Aura Work is built on a multi-process architecture where the Tauri 2 shell hosts a React 19 frontend and manages 8 independent sidecar processes, each sandboxed and authenticated. This design ensures security, isolation, and extensibility.

System Architecture

The architecture follows a layered approach:

┌─────────────────────────────────────────────────────────┐
│                    Desktop Shell (Tauri 2 + Rust)        │
│  ┌─────────────────────────────────────────────────────┐ │
│  │              Frontend (React 19 + Vite)             │ │
│  │  ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐     │ │
│  │  │Tasks │ │Files │ │ Git  │ │Browse│ │Plugins│     │ │
│  │  └──────┘ └──────┘ └──────┘ └──────┘ └──────┘     │ │
│  └─────────────────────────────────────────────────────┘ │
│                           │ IPC                          │
│  ┌─────────────────────────────────────────────────────┐ │
│  │              Rust Backend (Commands)                │ │
│  │  ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐     │ │
│  │  │Vault │ │SQLite│ │Shell │ │ FS   │ │Process│     │ │
│  │  └──────┘ └──────┘ └──────┘ └──────┘ └──────┘     │ │
│  └─────────────────────────────────────────────────────┘ │
│                           │ HTTP/IPC                    │
│  ┌─────────────────────────────────────────────────────┐ │
│  │              Sidecar Services (Node.js)             │ │
│  │  ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐     │ │
│  │  │Agent │ │  VM  │ │Browse│ │Plugin│ │Cloud │     │ │
│  │  │:47821│ │:47822│ │:47823│ │:47824│ │:47825│     │ │
│  │  └──────┘ └──────┘ └──────┘ └──────┘ └──────┘     │ │
│  │  ┌──────┐ ┌──────┐ ┌──────┐                        │ │
│  │  │Bridge│ │CompU │ │CloudS│                        │ │
│  │  │:47826│ │:47828│ │:47830│                        │ │
│  │  └──────┘ └──────┘ └──────┘                        │ │
│  └─────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────┘

🖥️ Desktop Shell (Tauri 2 + Rust)

The outer shell built with Tauri 2 and Rust. It handles:

Window management — native windows, system tray, menus
IPC bridge — communication between frontend and sidecars
Filesystem access — secure file operations with permission checks
Process lifecycle — starting, stopping, and monitoring sidecars
Vault management — encrypted storage for API keys and secrets
SQLite database — local persistence for projects, tasks, settings

The Rust backend is performance-critical and security-sensitive. It handles operations that require system-level access.

🎨 Frontend (React 19 + TypeScript)

The UI layer built with React 19 and Vite. It provides:

14 main pages — Dashboard, Tasks, Files, Git, Terminal, Providers, Plugins, Browser, Computer Use, Scheduled Tasks, Memory, Audit Log, Cloud, Extensions
10 settings tabs — General, Vault, VM, Cloud, Extension, Pet, Readiness, Diagnostics, Local Model, Approvals
Chat interface — the main interaction point with the agent
Monaco editor — code editing with syntax highlighting
Design system — 35+ themes, RTL support, responsive layout

The frontend communicates with the Rust backend via Tauri's IPC system. All commands are typed and validated.

⚙️ Agent Engine (TypeScript)

The brain of Aura Work — a multi-agent orchestration system:

Planner — decomposes tasks into step-by-step plans
Executor — runs each step, calling tools as needed
Reviewer — validates output for correctness and safety
Safety — enforces boundaries and permission checks

The agent supports custom tools, MCP servers, and plugins. It can use any combination of capabilities to complete tasks.

🔗 Bridge Server (TypeScript)

HTTP API for pairing external clients:

CLI — terminal-based control via aura command
Chrome extension — browser integration for page reading
Office add-in — document delegation from Word/Excel

The Bridge runs on port 47826 and requires session-based authentication. It only listens on localhost for security.

Data Flow

How data moves

When you type a prompt, here's the complete data flow:

1. User Input — You type in the React chat interface
2. IPC Call — Frontend sends the prompt to Rust backend via Tauri IPC
3. Task Creation — Rust creates a task in SQLite with status "planning"
4. Agent Orchestration — Rust calls the Agent sidecar (port 47821)
5. Planning — Planner agent creates a step-by-step plan
6. Routing — Routing engine selects the best provider/model
7. Permission Check — Each step is checked against permission profile
8. Execution — Executor agent runs each step, calling tools
9. Tool Calls — Tools may call other sidecars (VM, Browser, etc.)
10. Review — Reviewer agent validates the output
11. Response — Results are sent back to frontend via IPC
12. Display — Frontend renders the results in the chat

All interactions are logged to the audit trail. File operations go through the permission gate before reaching the filesystem.

Tech Stack

Technologies used

Layer	Technology	Purpose
Desktop Shell	Tauri 2	Native window, menus, system tray, IPC
Core Backend	Rust	Performance-critical operations, security
Frontend	React 19 + Vite 8	UI rendering, hot reload, TypeScript
Sidecars	Node.js / TypeScript	Background daemon services
Agent Engine	TypeScript	Multi-agent orchestration
Persistence	SQLite (rusqlite)	Local data storage
Encryption	ChaCha20-Poly1305 + Argon2	Credential security
Build System	npm workspaces + esbuild	Monorepo tooling
Package Format	Tauri bundler	.msi, .dmg, .deb, .AppImage

Project Structure

Codebase organization

aura-work/
├── apps/desktop/           # Tauri desktop app
│   ├── src/                # React components and pages
│   └── src-tauri/src/      # Rust commands and business logic
├── packages/
│   ├── ui/src/             # Design system (tokens, components)
│   ├── shared/             # TypeScript types and constants
│   ├── i18n/               # i18n localization (20 languages)
│   └── aura-plugin/        # Plugin SDK
├── sidecar/
│   ├── aura-agent/         # Task engine + providers
│   ├── aura-vm-helper/     # VM/shell execution
│   ├── aura-browser-helper/# Browser automation
│   ├── aura-plugins-helper/# Plugin/MCP management
│   ├── aura-cloud-sync/    # E2EE sync client
│   ├── aura-bridge/        # Extension bridge
│   ├── aura-computer-use/  # Computer Use helper
│   └── aura-cloud/         # Self-hostable cloud server
├── cli/aura-cli/           # CLI companion
├── registry/               # Marketplace registry
├── docs/                   # Feature documentation
├── examples/               # Sample plugins and MCP servers
├── qa/                     # Acceptance test suite
└── scripts/                # Build, bundle, release scripts