Overview
What is Aura Work and why it exists.
Aura Work is a multi-provider desktop AI agent platform built for developers who want local-first, permission-gated, self-hostable AI assistance. It supports 10 AI providers out of the box, with an intelligent routing engine that picks the right model for each task.
Unlike cloud-only tools, Aura Work keeps your data on your machine. It uses a plugin architecture with sandboxed execution, encrypted credential storage, and granular permission controls. The platform is designed for developers who want full control over their AI tools — no data leaves your device unless you explicitly choose to sync.
Why Aura Work?
Most AI coding tools are either cloud-only (sending your code to external servers) or limited to a single provider. Aura Work solves both problems:
- Multi-provider — use OpenAI, Anthropic, Gemini, DeepSeek, Ollama, and more from one interface
- Local-first — your data stays on your machine, encrypted with device-bound keys
- Permission-gated — every action requires explicit approval (or pre-configured profiles)
- Self-hostable — run your own cloud sync server, no dependency on our infrastructure
- Extensible — add capabilities via skills, MCP servers, and plugins
🎯 Core Capabilities
Aura Work is more than just a chat interface. It's a full development environment with:
- Task Engine — multi-step task execution with planning, execution, and review phases
- File Operations — read, write, search, and manage files with permission controls
- Git Integration — status, diff, commit, branch management directly from the agent
- Browser Automation — browse websites, extract data, fill forms with Puppeteer
- Computer Use — control desktop applications via screenshots and mouse/keyboard
- VM Sandbox — execute shell commands in isolated WSL2 or container environments
- Cloud Sync — E2EE sync across devices with self-hostable server
- Scheduled Tasks — automate recurring tasks with cron-like scheduling
- 18 Built-in Skills — documents, spreadsheets, PDFs, research, design, and more
- MCP Support — connect to any MCP server for unlimited extensibility
Architecture at a glance
🖥️ Desktop App
Tauri 2 shell hosting the React 19 frontend. Manages windows, system tray, native menus, and IPC with sidecar processes. The Rust backend handles performance-critical operations and system integration.
The desktop app provides 14 main pages: Dashboard, Tasks, Files, Git, Terminal, Providers, Plugins, Browser, Computer Use, Scheduled Tasks, Memory, Audit Log, Cloud, and Extensions.
⚙️ Sidecar Services
8 independent Node.js daemons for agent execution, browser automation, VM sandboxing, cloud sync, computer-use, and more. Each sidecar runs in its own process space with its own lifecycle, communicating via IPC or HTTP.
Sidecars: Agent (47821), VM Helper (47822), Browser Helper (47823), Plugins Helper (47824), Cloud Sync (47825), Bridge (47826), Computer Use (47828), Cloud Server (47830).
🤖 Agent Engine
Multi-agent orchestration with specialized roles: Planner decomposes tasks into steps, Executor runs each step, Reviewer validates output, and Safety enforces boundaries. Supports custom tools and MCP servers.
The agent can use any combination of built-in tools, skills, MCP servers, and plugins to complete tasks. It automatically selects the best tool for each step based on the task requirements.
🔀 Routing Engine
Smart model router across 10 providers with 5 routing policies: quality-first (best model for the task), cost-first (cheapest option), privacy-first (local-only), local-only (Ollama/LM Studio), or manual (you choose).
The routing engine analyzes each task's type, sensitivity, and required capabilities to select the optimal provider and model. It can also fall back to alternative providers if the primary one fails.
Workflow
When you type a prompt in Aura Work, here's what happens:
- 1. Task Creation — Your prompt becomes a task in the SQLite database
- 2. Planning — The Planner agent analyzes the task and creates a step-by-step plan
- 3. Routing — The routing engine selects the best provider/model based on your policy
- 4. Permission Check — Each step is checked against your permission profile
- 5. Execution — The Executor agent runs each step, calling tools as needed
- 6. Review — The Reviewer agent validates the output for correctness and safety
- 7. Completion — Results are displayed and logged to the audit trail
High-impact actions (file writes, shell commands, browser automation) require explicit approval in ask-first mode. You can configure auto-approval for trusted operations in Settings → Permissions.
Your data stays yours
Aura Work is built with security as a first-class concern:
- API keys never leave your device — stored in an encrypted vault using device-bound keys (DPAPI on Windows, Keychain on macOS, Secret Service on Linux)
- No telemetry by default — no usage data is collected unless you opt in
- E2EE cloud sync — if you use Aura Cloud, data is encrypted with XChaCha20-Poly1305 before leaving your device
- Audit logging — every action is recorded with actor, category, action, target, risk level, and result
- Permission system — granular control over what the agent can access (files, shell, browser, network)
Who is Aura Work built for?
👨💻 For Developers
Start a new feature with a single sentence: "Add JWT authentication to the API interface". Aura will analyze the codebase, build a plan, write the code, run the tests, and open a pull request — all while you review every sensitive step.
✍️ For Writers & Analysts
Analyze a document: "Analyze the annual report and extract the key points", then "Create a presentation from these findings". Document, spreadsheet, and PDF skills are built in and ready to go.
🛠️ For System Administrators
Monitor a server: "Check disk usage and generate a report". Integrate with your monitoring tools via MCP servers, and automatically schedule recurring tasks.
🔬 For Researchers
Gather information from multiple sources: "Compare PostgreSQL and MongoDB for our use case". The research skill browses the web, summarizes, and cites its sources.
System Diagram
┌─────────────────────────────────────────────┐
│ Aura Work App (Tauri 2) │
│ React 19 + Rust shell + IPC + system tray │
└───────────────────────┬───────────────────────┘
│ local IPC / HTTP
┌──────────────────┼──────────────────┐
│ │ │
┌─────▼─────┐ ┌──────▼──────┐ ┌──────▼──────┐
│ Agent │ │ Browser │ │ VM Helper │
│ :47821 │ │ Helper │ │ :47822 │
│ (Planner, │ │ :47823 │ │ (isolated │
│ Executor, │ │ (browser │ │ sandbox) │
│ Reviewer) │ │ automation)│ └─────────────┘
└─────┬─────┘ └─────────────┘
│ Routing engine (5 policies)
┌─────▼─────────────────────────────────────────┐
│ 10 AI providers (cloud + local) │
│ OpenAI · Anthropic · Gemini · Ollama · ... │
└─────────────────────────────────────────────────┘