Wevir

A local-first desktop workspace for AI coding agents

English · 简体中文 · Downloads · Discussions

---

Overview

Wevir is an open-source, local-first agent workspace that runs Codex, Claude Code, and other coding agents side by side, on any model. It supports your own API keys, any OpenAI-compatible endpoint, and existing subscriptions, most with multiple accounts.

A local Host owns the session timeline, the model gateway, every engine, and the data on your machine. Because these sit in one place, a session keeps its context when the engine, model, or account changes, and project knowledge, checks, and reviews are shared across engines. The desktop app, the wevir CLI, the web client, and the phone app connect to the same Host.

Highlights

• One session across engines. Hand a session to another engine or provider with a handoff brief that can be previewed before switching and is flagged when it falls out of date. When a subscription reaches its usage limit, continue the turn on another model, or resume automatically when the limit resets.
• Project memory for every engine. Agents keep project and global notes that every engine reads, each with its source and revision history; notes the user has edited are protected from agent overwrites.
• Independent review. A second opinion from another provider runs read-only on a snapshot of the session. Project checks run after each turn, with optional bounded repair, and a task retro links every line to its source.
• Tuning from real sessions. Wevir trials one change to a project's instructions, skills, or memory at a time and keeps or reverts it after five sessions, based on check pass rate and failed turns.
• Delegation. A project channel's coordinator routes each request to a thread and reports back; assistants run errands under rules you set, reachable from the phone app.
• Model per task, not per app. The open-source Codex agent runtime runs locally; Wevir's gateway translates its requests for OpenAI, Anthropic, Google, DeepSeek, a dozen other providers, local Ollama, and any OpenAI-compatible endpoint. Switch model or provider between turns within the same session.
• Multiple subscriptions, multiple accounts. Codex (ChatGPT), Claude Code, Grok, OpenCode, Antigravity, and Cursor subscriptions work side by side, each with multi-account support and per-account usage.
• Review before anything lands. Commands outside the sandbox require approval, every turn is checkpointed, and the changes pane shows per-turn, branch, or uncommitted diffs with comments, staging, and commits.
• Local-first. Sessions, settings, and API keys stay in a local data directory. Keys are held by the Host and never passed to the agent process.

Features

Models and accounts

• One runtime, many providers: OpenAI, Anthropic, Google AI Studio, Google Vertex AI, Azure OpenAI / Microsoft Foundry, SpaceXAI (Grok API), DeepSeek, Alibaba Cloud Model Studio, Kimi, Z.ai / Zhipu GLM, Xiaomi MiMo, MiniMax, StepFun, Tencent Cloud TokenHub, Azure Claude, RedPill, Ollama (local and cloud), and any OpenAI-compatible endpoint. The gateway converts requests to OpenAI Responses, Chat Completions, or Anthropic Messages, including reasoning and tool calls.
• Key isolation: API keys live in the Host's secret store and are never passed to the runtime process.
• Subscriptions: ChatGPT sign-in, plus Claude, OpenCode, Grok, Antigravity, WorkBuddy, Devin, Cursor, GitHub Copilot, and Kiro subscriptions. Wevir runs the vendor's own client or SDK with your existing sign-in; client download and sign-in are available in Settings. Requirements per source: Status.
• Multiple accounts: ChatGPT, Claude, Grok, OpenCode, Antigravity, Cursor, and GitHub Copilot support multiple accounts, with per-account credential and session directories, labels such as Work or Personal, and separate usage. WorkBuddy, Devin, and Kiro are limited to one account.
• Mid-session switching: Change model and reasoning effort between turns; switches are marked in the timeline.

Continuity

• Handoff: Move a session to another engine or provider. The receiving agent gets a brief of the task, constraints, notes, and recent history within a fixed size budget; the brief can be previewed, and a brief prepared before the session moved on is rejected as stale.
• Usage limits: A turn stopped by a subscription's usage limit continues on another model from the limit card, or resumes automatically after the reset. Sources whose quota is also used up are listed last.
• Memory: Project and global notes written by agents and read by every engine, with source, revisions, withdrawal, and conflict detection; notes edited by the user are not overwritten.
• Rules across engines: AGENTS.md, CLAUDE.md, and similar rule files apply to every engine.

Quality and review

• Second opinion: /second-opinion asks another provider or model to review the current changes. It runs read-only in a snapshot worktree; the review appears as a card and reaches the agent only when quoted.
• Checks and repair: Saved test, build, typecheck, and lint checks run after each turn. A test check passes only when tests actually ran. Optional repair sends failures back to the agent within attempt, time, and token limits.
• Task retro: A per-session account of the goal, progress, changes, checks, decisions, and next steps, built from the event log without a model call; each line links to its source.
• Tuning: Opt-in. Each trial applies one change to rules, skills, memory, or guardrails, measures the next five sessions against the baseline, and keeps or reverts it. One switch, a monthly token cap, and undo on every change.

Channels and assistants

• Project channels: A project timeline with a resident coordinator. Requests open threads, follow-ups go to the matching thread, and finished threads collapse to a line.
• Assistants: Long-lived agents with their own workspace, schedule, and per-action rules (do, do and report, ask first, prepare only); group chats with several assistants.
• Phone: Sessions, approvals, channels, and assistants on iOS and Android, over an end-to-end encrypted connection to your computer.

Sessions

• Live timeline: Streaming replies, plans, tool calls, subagents (each its own session), approvals, and agent questions.
• Steering: Plan mode, long-running goals, steering or queued messages during a turn, context compaction, and code review.
• Permission modes: Ask for approval, auto-approve, or full access.
• Branch and recover: Side questions, branching into a new session, rewinding the last turn, and a recap on return.
• Isolation: Sessions in a fresh Git worktree, multi-folder environments, or project-free chat.
• Input: Image attachments; one-click start for agent-suggested follow-up tasks.

Code and files

• Change review: Checkpoints before and after every turn; diffs for uncommitted work, the current branch, or a single turn.
• Files: Search, browse, preview, and edit project files; sandboxed HTML preview.
• Code intelligence: Go-to-definition, references, symbols, call hierarchy, and diagnostics via locally installed language servers (TypeScript, Python, Go, Rust, C/C++, Swift).

Agent tools

• Built-in browser: In-app page navigation, accessibility snapshots, and page interaction.
• Web access: Web search (Bocha or Tavily) and page fetching for gateway-connected models.
• Workspace tools: Background processes, project and global memory, a shared task board, session creation and messaging, and roles that preset a model, permissions, and instructions.
• Plugins: MCP servers, Skills, and plugin packages (Wevir, Codex, and Claude formats), installable by the agent from chat after approval.

Local Host

• One Host, many clients: The desktop app and CLI share sessions, the event log, and approvals; clients reconnect and resume from where they left off.
• Local storage: Sessions and settings in a local data directory (SQLite and plain files).
• Ten languages: English, Simplified and Traditional Chinese, French, German, Italian, Spanish, Japanese, Korean, and Russian.

Status

Wevir is in preview. Supported: shipped in the builds and covered by automated tests. Beta: functional, with less test coverage, a third-party client dependency, or no real-account verification yet. Planned: not yet available.

Area	Item	Status
Desktop app	macOS, Apple silicon	Supported
	macOS, Intel	Beta
	Windows x64	Beta
	Linux x64 and arm64 (AppImage, deb)	Beta
Mobile app	iOS (TestFlight)	Beta
	Android (APK)	Beta
Models	Codex runtime with API keys, OpenAI-compatible endpoints, or Ollama	Supported
	ChatGPT sign-in	Supported
Subscriptions	Claude	Beta
	OpenCode	Beta
	Grok	Beta
	Antigravity	Beta
	WorkBuddy	Beta
	Devin	Beta
	Cursor	Beta
	GitHub Copilot	Beta
	Kiro	Beta
Other	wevir CLI	Beta
	Web client	Beta
	Project channels and assistants	Beta
	Tuning	Beta
	Computer use	Beta

Known limitations

• Preview builds only. Every published build is a development build (0.0.1-beta.N), cut automatically from master after CI passes. Frequent updates; behavior may change between builds.
• Update channel. In-app updates follow the development channel; the stable channel has no releases yet.
• Subscription sources. They depend on each vendor's client or SDK and your existing sign-in, are subject to vendor terms, and may break when the client changes.
• Mobile app. iOS builds are distributed through TestFlight only. The Android build has no push notifications yet; alerts appear while the app is open.
• Platforms. No Windows on Arm build. Computer use is macOS only. On Linux only the AppImage updates in place; the deb build shows new versions with a link to the download page.

Bug reports: GitHub Issues. Questions and ideas: GitHub Discussions.

Downloads

Platform	Installer
	Download DMG
	Download DMG
	Download EXE
	Download AppImage or deb
	TestFlight beta: invitation via the Telegram group
	Download APK

Mobile app

The phone app connects to Wevir on your computers over an end-to-end encrypted connection (local network, Tailscale, or a self-hosted relay) and works with their sessions. All work runs on the computer.

Platform	Distribution
iOS	TestFlight beta. Invitations are issued in the Telegram group.
Android	Signed APK, published with every desktop preview build under the same version number. A newer APK installs over the existing one.

Pairing: Settings → Devices → Add phone.

Command line

The wevir CLI also ships on its own, with Node bundled, for Linux (x64 and arm64, glibc 2.28+, servers without a desktop included), macOS, and Windows x64. It uses the same data directory as the desktop app and attaches to a Host that is already running.

curl -fsSL https://dl.edgeweir.com/cli/install.sh | sh

Windows (PowerShell):

irm https://dl.edgeweir.com/cli/install.ps1 | iex

The script checks the package's sha256, installs to ~/.local/share/wevir-cli with a wevir link in ~/.local/bin (Windows: %LOCALAPPDATA%\Programs\wevir-cli, added to the user PATH), and installs the beta channel until a stable release exists; run it again to update. Then:

wevir host start
wevir provider add --kind deepseek-official
wevir session new -w ~/my-project "Summarize this repository"

Web client

Wevir Web is the desktop interface in the browser, connected to a computer running Wevir through an end-to-end encrypted relay. Sessions, projects, and credentials remain on that computer.

Deployment	Address
Hosted	web.wevir.si, with the Wevir relay on the same domain
Self-hosted	Site and relay on one domain on your own server: deployment guide and agent prompt

Pairing: Settings → Devices → Add web device.

Run from source

Requirements: Node.js 24.22.1+ (Node 24 LTS) and pnpm 12.6.0.

git clone https://github.com/marvinli001/wevir.git
cd wevir
pnpm install
bash scripts/fetch-codex.sh   # fetch the pinned Codex runtime
pnpm dev                      # start the desktop app

CLI: run pnpm build once, then pnpm --silent wevir --help. Commands, repository layout, and contribution rules: AGENTS.md.

Related repositories

Repository	Contents
Wevir-Labs/wevir-marketplace	Official plugin and skill marketplace
marvinli001/wevir-web	Web client and official relay (web.wevir.si); self-hosting

License

MIT License. Upstream code and third-party attributions: NOTICE.