Pinvou Agent: a Rust and Tauri desktop agent that ends in files, not chat replies
Open-source desktop AI agent for tools, files, knowledge, workflows, and real deliverables.
At a glance
- What is it?
- Pinvou Agent bundles work, design, and coding modes into one local-first desktop app, with MCP connectors and ACP-backed coding agents. Here is what the repository documents, where the preview build still looks thin, and who should wait.
- Who is it for?
- Adopt Pinvou Agent if you want a single desktop surface for research, visual design, and project coding, and you are comfortable running preview software from GitHub Releases. Skip it if you need a stable release channel, in-app updates, or a fully offline stack while also using cloud models and remote connectors.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository received new commits within the last day.
- What is it written in?
- Mainly Rust, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 15, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
The deliverable problem Pinvou Agent is aimed at
Most chat interfaces end a task with text. Pinvou Agent is built around the opposite expectation. The README says it is designed for tasks that should end with a result, not just another chat response, and the artifact panel is the mechanism that enforces this: it automatically collects every file the agent creates or edits, so a session produces a set of previewable, locatable files rather than a transcript. That framing explains the three modes. Work mode combines attachments, the local knowledge base, personas, Skills, MCP tools, and workflows to research and write. Design mode turns a prompt into a poster or data visualization that opens in an editor where elements can be selected and copy, fonts, colors, dimensions, and layout adjusted. Code mode hands a real project to an external coding agent. The intended user is someone whose daily output is documents, visuals, or code, and who is willing to run a desktop application rather than a browser tab. The repository does not publish adoption numbers, and none of the feature claims here can be treated as independently measured.
What the architecture implies: Tauri shell, Rust core, React front end
The repository layout puts the application under pinvou3-app, with a src-tauri directory holding the Rust side and icons, and a package.json at pinvou3-app/package.json that the version badge reads. The topics list confirms the stack: tauri, rust, react, desktop-app. The practical consequence is a native shell hosting a web front end, which is why the app can reach local files, local model endpoints, and the machine's GPU and disk state. Runtime state is centralized: sessions, settings, knowledge, and runtime extensions all live under ~/.pinvou3/, according to the README. That single directory is the boundary that matters for backup, migration, and inspection. The README does not describe the internal retrieval pipeline beyond calling it full-text and vector retrieval, so the embedding model, index format, and chunking strategy are not verifiable from the supplied material. Treat the knowledge base as a documented feature, not a documented implementation.
MCP, CLI connectors, and the ACP path for coding agents
Tool access is unified rather than per-mode. The README describes one tool store covering local MCP servers, remote MCP servers, CLI tools, and API connectors, with OAuth or SSO authorization where the provider supports it, so keys are not pasted by hand. Named connectors include Feishu (Lark), DingTalk, WeCom, Tencent Meeting, Tencent ima, Obsidian, enterprise knowledge bases, and legal and enterprise data services. Code mode takes a different route: Codex, Claude Code, or Kimi are driven through ACP, documented at docs/multi-agent-acp.md. The README states that the coding agent can read and edit a real project or an isolated temporary workspace, run commands, and surface plans, tool steps, permission requests, and file changes, and that sessions stay bound to their workspace and can be continued after restarting the app. The workspace binding is the interesting design choice. It means the app is a host for other agents rather than a replacement for them, and it means your existing Codex or Claude Code setup is the thing doing the file edits.
Getting a preview build running
There is no package-manager install documented. The README points to GitHub Releases for the preview download, and the most recent tagged release is v0.9.3 (Pinvou 0.9.3 预览版), published 2026-09-09, following v0.9.2 and v0.9.1 earlier in the month. The platform badge lists Windows, macOS, and Linux. Model configuration is either in the app settings or through environment variables. The README gives this local vLLM example: export DEEPSEEK_BASE_URL="http://127.0.0.1:8000/v1", export DEEPSEEK_API_KEY="local-no-auth", and export DEEPSEEK_MODEL="your-model-name". Built-in templates cover local vLLM, DeepSeek, Kimi, Qwen, Doubao, MiniMax, Zhipu (GLM), MiMo, OpenAI, Anthropic, Gemini, and xAI, and a custom OpenAI-compatible endpoint can be filled in by hand. Multiple configurations can be saved, cloud entries can carry display aliases, and switching happens per session without changing the model identifier sent to the provider. One caveat is stated outright: updates arrive through GitHub Releases, and in-app update checks are not enabled yet, so upgrading is a manual download.
Where the preview build is likely to disappoint
Three limitations are visible without running anything. First, the release channel. Every listed release is labelled a preview (预览版), and three releases landed within eight days in September 2026. That cadence suggests active development rather than a settled interface, and anyone pinning the app for a team should expect churn in settings, storage layout, or connector behaviour. Second, the privacy story is conditional. The README's own note says whether data leaves your machine depends on the model and tools you enable, and that cloud models, remote MCP servers, and third-party connectors send the relevant requests to their respective services. A local model with local tools stays local; anything else does not. If your requirement is a hard offline guarantee, the connector catalogue works against you. Third, the knowledge base is described at the feature level only. Full-text and vector retrieval, multiple collections per chat, independent enable and disable, and provenance in answers are all claimed, but the README does not state which embedding model is used, whether it runs locally, or how large an index the app handles. Anyone whose corpus is measured in millions of documents has no basis in this material to expect it to work.
How it differs from running an editor plugin or a standalone coding agent
The obvious comparison is a coding agent used on its own, whether that is Codex, Claude Code, or Kimi invoked from a terminal. Pinvou Agent does not compete with those on code editing. It drives them through ACP and adds a workspace around them: session persistence across restarts, a permission and tool-step view, an artifact panel, and a knowledge base the coding agent can draw on. The difference in approach is that a standalone agent is scoped to a repository, while this app is scoped to a person's work across documents, visuals, and code, with the coding agent as one component. The trade-off is real. You inherit an Electron-style desktop runtime, a ~/.pinvou3/ state directory, and a preview release cadence, in exchange for one place to keep sessions and artifacts. If all you do is edit code in one repository all day, the terminal agent plus your editor is fewer moving parts, and this app adds a layer you would rarely open.
Licence, maintenance, and what upgrading costs you
The project is MIT licensed, which permits commercial and private use, modification, and redistribution provided the copyright notice and permission notice are retained. This is a summary of the standard MIT terms, not legal advice; read the LICENSE file in the repository before relying on it. Redistribution matters here because the app ships as a desktop binary: if you repackage or bundle it internally, the notice obligation travels with it, and you should check the licences of the bundled connectors and any models you download separately. Maintenance cost is dominated by two things the README makes explicit. Upgrades are manual downloads from GitHub Releases because in-app update checks are not enabled, so someone has to watch the release feed. And the local voice input feature downloads speech models on demand, which means storage and, on some machines, GPU or memory headroom to account for. The monitoring view for GPU, memory, disk, model service, and context usage exists precisely because those resources are the ones that run out.
Editorial conclusion
Adopt Pinvou Agent if you want a single desktop surface for research, visual design, and project coding, and you are comfortable running preview software from GitHub Releases. Skip it if you need a stable release channel, in-app updates, or a fully offline stack while also using cloud models and remote connectors. Before installing, check the ACP document at docs/multi-agent-acp.md for which coding agents are supported, and confirm that the tools you intend to enable keep data on your machine, since the README states plainly that cloud models and remote MCP servers send requests to their respective services.
Community notes