AURA Hub：AI 原生桌面工程环境，支持 11 家 AI 提供商

An AI-native desktop engineering environment — not a chat app, not a browser tab, not an editor plugin.

Website · Get AURA Hub · Quick Start · Features · Screenshots · Demo · Architecture · Development · Roadmap

What is AURA Hub?

Most developer tools give you an editor with an AI panel bolted onto the side. Ask it something, and it re-derives context from whatever's currently visible in the buffer — it doesn't know your architecture, it doesn't remember yesterday's decisions, and every session starts from zero. The chat window is a guest in someone else's house.

AURA Hub inverts that relationship: the environment is the product. A project opened in AURA gets a persistent, structural understanding of itself — a knowledge graph built from real static analysis, not a best-effort text search — before any model is ever called. Engineering work (multi-step missions, workflow automation, architecture review, governance) runs as first-class, resumable, inspectable processes, not one-shot chat completions. And the AI itself is never locked to one vendor: AURA has no built-in model and no hidden API account — you bring your own key to whichever provider you trust, and the entire platform, every feature, works identically regardless of which one you pick.

Why AURA Hub?

• Grounded, not guessed. Every AI answer is built on a real, incrementally-updated knowledge graph and system model — entities, relations, layers, health scores — computed once and queried, never reconstructed from a raw file dump on every keystroke.
• Deterministic where it can be, probabilistic only where it must be. Questions with one checkable answer (is this actually dead code, did this diff remove a public export) are answered by real parsing and arithmetic. The model's job is narrowed to what only a model can do: explain a cause in prose, draft a plausible patch.
• No vendor lock-in. Eleven AI providers are supported today through one shared adapter interface. Switching providers — or model, mid conversation — is a first-class, validated operation, never a reconfiguration.
• Engineering memory that compounds. Decisions, patterns, and learnings persist across sessions and inform future answers, instead of every conversation starting over.
• Built for scale from day one. A strict, inward-only architecture, a design system with zero raw hex values, and internals explicitly designed to support years of development rather than a demo. See the Development Guide for the technical deep dive.

Core Features

How these fit together (click to expand)

Nothing above is a separate product bolted on. Every AI-backed feature — chat, Ctrl+I inline actions, the Workflow Builder, Mission Control, Diagnosis — funnels through the same shared engine underneath, which means provider validation, error translation, retry/timeout handling, and context assembly are implemented once and apply everywhere, automatically, including to features built after this sentence was written.

Product Screenshots

📸 Real, live captures of the running app against this repository — not mockups. One slot (Mission Execution DAG) is still pending; see docs/assets/screenshots/SCREENSHOT_GUIDE.md for the exact capture spec and an honest note on two substituted shots.

Application Shell & Home The full environment on first launch — navigation, command bar, and the project list.	Window Manager Floating panels — AI Chat, Mission Control — tiled together inside one project workspace.
AI Chat A grounded conversation, showing which knowledge engines and provider were used.	Mission Control A real, live-created mission — checkpoints, execution waves, deterministic health signals.
AI Workflow Builder Natural language turned into a real, validated automation graph.	Automation Studio The workflow library — real templates with real node/date metadata.
Knowledge Intelligence Live verification score, validation score, and repository statistics.	Architecture Blueprint Layered module structure and dependency boundaries.
Engineering Memory 50 real persisted memories — decisions, learnings, agent proposals — filterable by kind and severity.	Engineering Intelligence Module/dependency/API-surface counts derived from the real repository.
Multi-Provider AI Five real BYOAK providers connected, one active, model discovery live.	Command Bar Keyboard-first navigation across the whole environment.
Project Dashboard A single project's real indexed stats — files, chunks, entities, languages.

Demo

There's no hosted demo video yet — a full script and shot list for one is ready to record at docs/DEMO_VIDEO_SCRIPT.md (2:40, scene-by- scene, voice-over included). In the meantime, see docs/QWEN_DEMOS.md for five scripted walkthroughs (AI Chat, Code Generation, Workflow Automation, Engineering Analysis, Knowledge Graph) you can run yourself against the real app in a few minutes, and examples/ for real, importable workflow templates you can run without writing anything.

Product Architecture

One-page executive summary (PDF): docs/assets/AURA_HUB_ARCHITECTURE_OVERVIEW.pdf.

AURA Hub is three layers working as one environment:

• The desktop application — the window manager, Mission Control, Automation Studio, Knowledge Graph, and Settings all live in one native window, never separate tools you switch between.
• The intelligence layer — a local, on-device engine that builds and maintains your project's knowledge graph, plans and executes missions, runs workflows, and remembers engineering decisions across sessions.
• The model layer — whichever AI provider you connect. AURA has no built-in model and never proxies your key through a third party; the intelligence layer talks to your chosen provider directly.

Every AI-backed feature shares the same intelligence layer underneath, so provider validation, error handling, and context assembly are implemented once and apply everywhere. Full technical architecture, dependency direction, and extension points for engineers and contributors: Development Guide.

Every platform, in depth (click to expand)

Get AURA Hub

AURA Hub is a native desktop application for Linux x86_64 (AppImage and .deb), with macOS and Windows support planned. It's in active development — signed, packaged installers aren't published yet, so today there are two real ways to get it:

• Run it from source. This is the current, working path — see Development below for the exact commands. It's not a "clone a script" affair: you get the full native application, running locally, in a few minutes.
• Download the Alpha/Preview release artifacts (Linux x86_64):
  • AppImage: AURA Hub_0.1.19_amd64.AppImage — make executable (chmod +x) and run.
  • Debian package: AURA Hub_0.1.19_amd64.deb — install with sudo dpkg -i or your package manager.

Note: The current release artifacts are unsigned because TAURI_SIGNING_PRIVATE_KEY was not configured in the build environment. They are functional but not cryptographically signed. Verify the checksum if you obtain them from a trusted source.

One thing either path needs: an API key from any one of the 11 supported AI providers (see Core Features). AURA has no built-in model — nothing AI-related works until you connect one, and Groq offers a free tier if you don't have a key handy.

Quick Start

1. Connect a provider. Open Settings → AI Provider, choose any supported provider, and paste your API key. Groq offers a free tier if you don't have a key handy. AURA validates the key, discovers its available models, and activates it — see docs/architecture/PROVIDER_INTEGRATION.md.
2. Add a project. From Home, point AURA at a local folder. It's indexed by the Coding and FullStack knowledge engines automatically — no separate "start indexing" step.
3. Open the workspace. Opening a project drops you into its window manager — float or dock panels for AI Chat, Files, Architecture, and Knowledge as you need them.
4. Chat with AI. Ask a real question about the project in AI Chat. Answers are grounded in the knowledge graph, not just whatever's in the prompt.
5. Create a workflow. Open the AI Workflow Builder and describe an automation in plain language — or instantiate one of the 10 real templates in the Workflow Library (see examples/).
6. Run it. Execute the workflow against your open project and watch real node-by-node progress on the canvas.

Roadmap

See ROADMAP.md for the current Now / Next / Future direction, and docs/ROADMAP.md for execution-level tracking detail. Status legend used throughout this repo: ✅ Implemented · 🚧 In Progress · 📅 Planned.

Development

Everything below is for people building or contributing to AURA Hub itself. If you just want to use the app, see Get AURA Hub and Quick Start above.

Requirements

Platform support: macOS, Windows, and Linux via Tauri v2 (bundle.targets: "all" in apps/desktop/src-tauri/tauri.conf.json). Signed installers are not yet published — see ROADMAP.md.

Clone & install

git clone https://github.com/Aura-hub-ai-native-workspace/aura-hub.git
cd aura-hub
npm install   # npm workspaces — one install for the entire monorepo

Run — development

# native desktop window (requires the Rust toolchain) — this is the real app
npm run tauri dev

# browser-only shell, for fast UI iteration without Rust
npm run dev               # → http://localhost:1420

# the local AI service (provider adapters, pipeline, workflow engine)
npm run ai                 # → http://127.0.0.1:4319

The interface is identical in both modes — Vite serves the React environment, and Tauri hosts that same build in a native window. npm run dev is a development convenience for iterating on the UI without the Rust toolchain, not a second product; npm run tauri dev is how AURA Hub actually runs.

Run — production

npm run build        # type-check + production build
npm run tauri build  # package native installers (needs Rust + platform build tools)

Other scripts:

npm run typecheck   # project-wide TypeScript build, no emit
npm run clean        # remove node_modules and dist across the workspace

Folder Structure

aura-hub/
├─ .github/                    # CODEOWNERS, issue/PR templates, CI workflow
├─ docs/                       # architecture, design, governance, screenshots
│  ├─ architecture/            # deep-dive docs per platform (Mission Control, Providers, Governance, …)
│  └─ assets/                  # brand assets, screenshot gallery spec
├─ examples/                   # real, importable workflow examples (see examples/README.md)
├─ scripts/                    # dev tooling (TS runner, verification scripts, presentation build)
├─ website/                    # the marketing site (website/README.md for deploy instructions)
├─ apps/
│  └─ desktop/                 # the environment app (React + Vite + Tauri)
│     ├─ src/
│     │  ├─ shell/             # AppShell, LeftNav, CommandBar, RightPanel, StatusBar
│     │  ├─ ops/                # window manager, floating panels, agent/memory/notification centers
│     │  ├─ screens/            # Home, project workspace, missions, workflows, governance
│     │  └─ styles/             # global theme layer (CSS variables)
│     └─ src-tauri/             # native desktop wrapper (Rust)
└─ packages/
   ├─ core/                    # tokens · motion · types · global store · navigation model
   ├─ ui/                      # the AURA design system
   ├─ ai-service/               # provider adapters, pipeline, workflow engine, mission control, HTTP+SSE server
   ├─ automation/                # event-driven automation engine (rules, triggers, action chains)
   ├─ governance/                # engineering governance platform (health, drift, debt, release readiness)
   ├─ predictive/                # predictive engineering (deterministic risk/prediction engines)
   ├─ engineering-memory/        # persistent engineering memory platform
   ├─ intelligence/              # intent classification, prompt enhancement pipeline
   ├─ retrieval/                 # chunking, embeddings, ranking, context assembly interfaces
   ├─ knowledge-coding/          # AST-based code indexing and search
   ├─ knowledge-fullstack/       # full-stack entity/relationship extraction, system graph
   └─ runtime/                   # shared provider-neutral runtime contract

Workspace packages are consumed as source (via Vite/TS path aliases) — editing any package hot-reloads instantly, no per-package build step.

Contributing

AURA is a Maintainer-Driven Development project — every change goes through a Pull Request and requires CODEOWNERS approval before merging into main. No direct pushes, no exceptions.

Start here: CONTRIBUTING.md · docs/TEAM_GUIDE.md · CODE_OF_CONDUCT.md · SUPPORT.md

Configuration

AURA Hub requires an AI provider API key to function. Configure it in Settings → AI Provider. Supported providers: OpenAI, Anthropic, Gemini, Groq, Mistral, Cerebras, Kimi, NVIDIA, OpenRouter, Novita, Qwen. Groq offers a free tier.

Workers (autonomous coding agents) are governed by AURA. Configure them in Settings → AI Runtime:

• Claude Code: Install via npm install -g @anthropic-ai/claude-code (or download binary). Ensure claude is in PATH.
• Kilo Code: Install via npm install -g @kilocode/cli. Ensure kilo is in PATH. Configure ~/.config/kilo/kilo.jsonc with a provider (e.g., local Ollama).
• OpenCode: Install via npm install -g opencode-ai. Ensure opencode is in PATH.

Local Ollama (for local models): Install Ollama (ollama serve), pull a model (e.g., ollama pull qwen2.5-coder:1.5b). In Kilo configuration, set provider to Ollama with base URL http://localhost:11434/v1 and model qwen2.5-coder:1.5b.

AI Runtime settings allow you to enable/disable workers, set default model, and configure web research toggle.

Known Limitations

• Platform: Current release artifacts are Linux x86_64 only (AppImage and .deb). macOS and Windows builds are not yet published.
• Unsigned artifacts: The AppImage and .deb are unsigned because TAURI_SIGNING_PRIVATE_KEY is not configured in the build environment. Verify checksums if you obtain them from a trusted source.
• Local provider dependency: Full functionality requires a local Ollama instance (or other provider) running. The bundled backend uses a local Ollama endpoint by default.
• Worker CLI availability: Workers (Claude Code, Kilo Code, OpenCode) must be installed and configured separately. AURA does not install them automatically.
• Model quality: Depends on the configured model. Local models (e.g., qwen2.5-coder:1.5b) may have limited tool-calling ability.
• GUI/Display required: The Tauri desktop application requires a graphical environment (Wayland/X11). Headless operation is not supported.
• Alpha/Preview stability: This is an Alpha/Preview release. Expect occasional bugs, UI changes, and breaking changes between releases.
• No cloud deployment: AURA Hub is a local desktop application; it does not provide a hosted service.

Release Notes (v0.1.20)

Release readiness, not new features. v0.1.20 makes the pipeline that builds AURA Hub honest about every target it has configured:

• Linux x64 — AppImage and .deb, built and run on ubuntu-latest.
• Windows x64 — NSIS installer, built and run on windows-latest.
• macOS arm64 / x64 — .app and .dmg, built and run on macos-latest and macos-15-intel.

Each artifact is produced by its own native toolchain on its own runner and then executed there — a build is not a run. Nothing is cross-compiled.

Fixed: the Claude Code adapter no longer locates its launcher from a hard-coded POSIX path list (it is now per-OS); the shell capability no longer describes itself as a POSIX shell (it never invokes one); and a version drift in package-lock.json that blocked the canonical scripts/bump-version.mjs release step is reconciled — with the bump tool fixed so it moves both root-project entries a lockfile contains.

Verified while preparing this release (on Linux): backend suite runs with zero failures (unit, non-unit, integration, e2e, differential policy and the Web Research fail-closed suite); frontend 245 passed; service suite 65 passed; npm run typecheck clean. All six version sources agree on 0.1.20 per node scripts/bump-version.mjs --check.

NOT verified: no v0.1.20 artifact exists yet for any platform, and scripts/release-verify.mjs cannot pass until signed artifacts do — run locally against the older unsigned files in dist-release/ it correctly reports FAIL. npm run build (tsc -b && vite build) does pass; cargo check and a release-profile cargo build are unverified for this working tree.

Hosted CI has since run on this branch and exposed nine real defects, all fixed — the list is in CHANGELOG.md. The pattern was the same in every case: a check that had only ever been observed on one Linux machine whose toolchain happened to satisfy it.

Windows and macOS runtime is unverified: no Windows or macOS artifact was executed while preparing this release — those platforms are built and run only on native CI runners. Their status is pipeline ready, not runtime verified. The artifacts listed below are still the v0.1.19 ones; no v0.1.20 installer is published yet.

Release Notes (v0.1.19)

Validated capabilities:

• AURA Agent — autonomous intent compilation, planning, and synthesis.
• Autonomous multi-worker delegation — Claude Code and Kilo Code run in parallel under AURA governance.
• Claude Code integration — inspects backend architecture.
• Kilo Code integration — inspects frontend architecture.
• Governed execution — workers run under capability-based policy, with audit trail.
• Verification — exit-code verification for research workers; audit trail records every delegation.
• Audit trail — immutable JSONL log of every delegation, approval, and execution.
• Shared mission identity — both workers share the same missionId and projectId.
• Parallel independent work — workers execute concurrently with overlap.
• Final synthesis — AURA combines both workers' findings into a single summary.
• Tauri desktop application — Linux AppImage (159 MB) and Debian package (96 MB) built and verified.
• Linux x86_64 release artifacts: AURA Hub_0.1.19_amd64.AppImage (159 MB) and AURA Hub_0.1.19_amd64.deb (96 MB).
• Bundled Python backend verified against current repository source (central agent, planner, policy, execution, verification, API server).

Alpha/Preview: This release is an Alpha/Preview. Expect occasional bugs, UI changes, and breaking changes between releases. Not recommended for production-critical workloads.

Security & Governance

• AURA controls workers — workers are capabilities invoked through the governed Fabric; they do not independently decide authorization.
• Delegation passes through the governed execution path — every agent.delegate goes through the Capability Fabric, policy engine, and approval ledger.
• Verification is separate from execution — workers are verified by exit-code and audit trail, not by trusting their output.
• Audit records capture execution — every delegation, approval, and execution is logged immutably in audit/trail.jsonl.
• Autonomous delegation does not mean unrestricted execution — workers run under capability-based policy, with scope paths and permission grants enforced.
• Capabilities requiring human approval remain approval-gated — e.g., system.uninstall, git.push, and other high-risk/irreversible capabilities still require explicit human approval.

Release Artifacts

Current Alpha/Preview release artifacts (Linux x86_64):

• AURA Hub_0.1.19_amd64.AppImage (159 MB) — make executable (chmod +x) and run.
• AURA Hub_0.1.19_amd64.deb (96 MB) — install with sudo dpkg -i or your package manager.

Both artifacts are unsigned because TAURI_SIGNING_PRIVATE_KEY was not configured in the build environment. They are functional but not cryptographically signed. Verify checksums (SHA256) if you obtain them from a trusted source.

Artifacts are produced by the canonical build command npm run desktop:build (which runs tauri build after desktop:prepare:build). The bundled Python backend matches the current repository source (central agent, planner, policy, execution, verification, API server).

Release Checklist

• Backend tests pass (python3 -m pytest backend/tests — 2121 collected, zero failures)
• Frontend tests pass (npm run test:front → 245 passed)
• TypeScript check passes (npm run typecheck)
• Production build passes (npm run build)
• Tauri cargo check passes (not run for this release)
• Worker readiness: 5 installed, 5 configured, 0 drifted
• Real Tauri E2E multi-worker mission passes (Claude + Kilo, autonomous, verified)
• Version consistency: package.json (0.1.20), tauri.conf.json (0.1.20), Cargo.toml (0.1.20)
• Secret audit: no accidental secrets committed (scanned for API keys, tokens, private keys, passwords)
• Artifact verification: AppImage and .deb generated, backend resources match source
• Release notes written (see above)
• Installation documentation updated (AppImage and .deb instructions)
• Signing: configure TAURI_SIGNING_PRIVATE_KEY for production distribution (not required for Alpha/Preview)

Note: The Tauri production build (npm run desktop:build) succeeds and produces both AppImage and .deb artifacts. The build warning about missing signing key is expected in CI environments without a private key.

Security

Found a vulnerability? Please don't open a public issue — see SECURITY.md for how to report it responsibly.

Release Notes

See CHANGELOG.md for what's shipped on this branch, release by release.

License

Licensed under the Apache License, Version 2.0.

Acknowledgements

AURA Hub is built on the shoulders of React, Vite, Tauri, Tailwind CSS, Framer Motion, Zustand, and Monaco Editor — and on every AI provider whose API it integrates with as a first-class, validated citizen rather than an afterthought.

Governance model inspired by the Pull-Request-first, CODEOWNERS-enforced patterns used by Kubernetes, VS Code, and React.