Skip to content

Architecture

Jump to bottom
Jazzen Chen edited this page May 24, 2026 · 9 revisions

Architecture

VibeAround is a local runtime with three main surfaces: desktop, browser, and messaging channels.

Desktop UI / Tauri
        |
        v
Rust runtime ---- Web dashboard / WebSocket / Preview proxy
        |
        +---- Agent processes over stdio / PTY
        |
        +---- Channel plugins over stdio JSON-RPC
        |
        +---- Local API bridge for provider/profile routes

Repository Layout

Path Role
src/core Rust runtime: agents, conversations, channels, previews, PTY, tunnels, auth, config
src/server Axum web server for /va/, APIs, WebSocket, pairing, preview proxy, local API bridge routes
src/desktop Tauri shell, desktop IPC commands, window setup, onboarding orchestration
src/desktop-ui React/Vite desktop UI
src/web React/Vite web dashboard
src/shared/client-ts Shared TypeScript API client and wire types
src/shared/ui Shared React UI primitives
src/shared/i18n Shared localization helpers
src/resources Embedded registries for agents, providers, plugins, tunnels, commands, MCP tools
src/plugins Plugin workspace for bundled/local channel plugins
src/skills VibeAround skills injected into supported agents

Runtime Responsibilities

Module Responsibility
Agents Discover, launch, and attach supported local CLIs
Conversations Route prompts, slash commands, session lifecycle, handover
Channels Start channel plugins and relay messages
Web server Serve dashboard, APIs, WebSocket, previews, local auth
PTY Browser terminal sessions and terminal launch integration
Profiles Provider definitions, model metadata, API bridge settings
API bridge Translate model API shapes and normalize provider quirks
Tunnels Expose dashboard/previews publicly when enabled
Auth Pair public browsers and issue local auth cookies

Local API Bridge

The bridge turns profile configuration into local loopback endpoints. It translates requests/responses through a shared event model so agents and providers do not need to speak the same API shape.

Supported shapes include:

  • OpenAI Responses
  • OpenAI Chat Completions
  • Anthropic Messages
  • Gemini Generate Content

Provider adapters handle details such as:

  • DeepSeek reasoning content
  • Claude model suffix normalization
  • tool-call history repair
  • model alias/fake ID mapping
  • provider-specific headers and endpoints

Desktop UI

The desktop UI communicates with Tauri commands. It owns high-level user flows:

  • onboarding
  • Launch
  • profile editor
  • workspace/session selectors
  • status/previews pages
  • settings

It does not store secrets in the project repo. Secrets are saved under the local VibeAround home directory.

Web Dashboard

The dashboard is served under /va/ by the same runtime. It provides:

  • Web Chat
  • Web Terminal
  • Previews
  • session/workspace views
  • runtime status

During development, Vite serves the frontend and proxies runtime APIs to the Rust server.

Channel Plugins

Channel plugins are Node.js subprocesses. They communicate with the Rust host through JSON-RPC over stdio. Plugins adapt platform events into VibeAround prompts and render responses back to the platform.

Data Flow

  1. A user sends a prompt from desktop, web, terminal, or an IM channel.
  2. VibeAround resolves the workspace, session, and selected agent/profile.
  3. The runtime launches or resumes the agent process.
  4. If a bridge profile is active, model API requests go through the local API bridge.
  5. Agent output streams back to the originating surface.
  6. Preview and handover helpers can expose additional local URLs or pairing codes.

Clone this wiki locally