MyAgents: A Local-First Desktop AI Agent Workbench Built on Tauri with Multi-Tab Sessions and Task Scheduling

What MyAgents Is: Workspace-First, Not Chat-First

Most AI desktop applications are a chat window with tools added on top. MyAgents starts from a different premise: every agent session is bound to a real workspace, and the workspace is a first-class concept. A session has a file tree, a Git branch view, a list of available Skills and commands, a built-in terminal, and a built-in browser, all visible in the same window alongside the conversation.

The README describes the goal: to let people focus on judgment, taste, and review while handing off context management, tool calls, long-running execution, and repetitive work to the agent.

The target audience is developers and knowledge workers who want an AI agent that stays connected to their local environment across sessions, rather than starting each conversation from a blank slate. The application runs on macOS 13+ (Apple Silicon and Intel) and Windows 10+. It is built with Tauri v2 and Rust for the desktop layer, React 19 and TypeScript for the frontend, and a Node.js sidecar for the agent runtime.

Architecture: Tauri, Rust, and the Node.js Sidecar

The application has four distinct layers, as documented in the README's technical stack table. The desktop framework is Tauri v2 plus Rust, which handles file system access, the embedded terminal (xterm.js with portable-pty), the embedded browser (Tauri multi-Webview), and the HTTP/SSE proxy that bridges the frontend to the sidecar. The frontend is React 19 with TypeScript, Vite, and Tailwind CSS. The backend sidecar is a Node.js process (v24) running the Claude Agent SDK. Communication between the frontend and the sidecar goes through Tauri's invoke mechanism routed through the Rust proxy layer.

Local full-text search uses Tantivy with the tantivy-jieba tokenizer for CJK text support. This handles search over conversation history and workspace files without a separate search service.

Each agent session gets an isolated sidecar process. The README describes this as a key architectural principle: sidecar isolation by session, so one session's failure does not affect another. The project structure places React frontend code in src/renderer/, the Node.js sidecar in src/server/, the Tauri Rust layer in src-tauri/, built-in agents in bundled-agents/, and built-in Skills in bundled-skills/.

Setting Up the Development Environment

Development requires Node.js 22 or later (24 recommended), [email protected], and Rust installed via rustup. The actual Rust toolchain version is pinned in rust-toolchain.toml. Building for macOS also requires Git, Python 3.10+, and Apple Clang.

For macOS and Linux:

git clone https://github.com/hAcKlyc/MyAgents.git
cd MyAgents
./setup.sh
./start_dev.sh

For Windows:

git clone https://github.com/hAcKlyc/MyAgents.git
cd MyAgents
.\setup_windows.ps1
.\build_windows.ps1

The setup script checks the current build target and verified caches, downloads the Node runtime and Rust crates, and caches offline documentation and speech inference resources. It does not automatically install missing native build tools; it reports what is missing instead. Repeated runs reuse cached resources.

For Linux builds, the README specifies the required Tauri and WebKit system dependencies:

sudo apt-get install -y \
  build-essential libssl-dev libgtk-3-dev libayatana-appindicator3-dev \
  librsvg2-dev libwebkit2gtk-4.1-dev patchelf

In development, start the environment with:

./start_dev.sh

Type checking and linting run separately:

npm run typecheck
npm run lint

The lint command includes both ESLint and dependency-cruiser architecture boundary checks.

Multi-Provider Model Routing and Runtime Selection

MyAgents does not lock users to a single model provider. The README lists Anthropic (subscription and API), DeepSeek, Moonshot, Zhipu, MiniMax, Google Gemini, Huoshan Ark, SiliconFlow, ZenMux, OpenRouter, Xiaomi MiMo, and Alibaba Cloud Bailian as configurable providers. The actual list is controlled by the in-app model provider settings page.

Beyond model selection, the runtime layer is also swappable. The built-in agent runtime is the Claude Agent SDK running in the Node.js sidecar. An experimental section of the application (labeled as Labs in the README) allows switching the runtime to Claude Code CLI, OpenAI Codex CLI, or Google Gemini CLI for driving sessions. This separates the model provider from the execution mechanism.

MCP support covers STDIO, HTTP, and SSE connection methods. Built-in and external MCP servers can run simultaneously. Skills work at three levels: built-in skills shipped with the application, user-defined skills, and workspace-level skills scoped to a specific project. Calling a skill in a session uses the / prefix, and referencing a file uses @.

IM bot integration supports Telegram and DingTalk natively. Additional IM platforms connect through the OpenClaw plugin bridge. The README also mentions a myagents CLI tool and a small floating window widget as additional entry points into the same agent context.

The Task and Idea Center: Beyond Conversation

The task center is a distinct system that separates tasks from conversation history. The workflow, as the README describes it, is to capture a quick idea first, then discuss it with the AI to refine it into a concrete task, and then schedule and track that task as a state machine with execution logs.

The task system supports one-time tasks, repeating tasks, and tasks defined with a Cron expression. An optional local command sensor can poll a condition at low cost and wake the AI only when that condition is met, avoiding continuous polling. Each task tracks its execution state, run count, execution log, and error recovery information.

Conversation sessions, AI tool calls, IM bot messages, and background tasks all share the same scheduling infrastructure. This means a task started from a DingTalk message and a task started from the main session UI go through the same queue and can reference the same workspace context.

This is a meaningful architectural commitment: it means the application is designed to run agents on a schedule without user interaction, which has different reliability requirements than an interactive chat session. The README documents task state tracking and execution audit as explicit features.

Limitations, License, and a Comparison with Claude Desktop

Several limitations follow from the architecture. The embedded browser is a Tauri multi-Webview sub-view, not a full browser. The README does not document browser extension support or full devtools integration within the embedded view. The experimental external runtime support (Claude Code CLI, Codex CLI, Gemini CLI) is labeled as Labs, indicating it may be unstable.

The test suite includes a credentialed test layer (npm run test:credentialed) that requires real provider API keys and is explicitly marked for local-only execution. This means CI tests do not cover real provider integration, which is a gap for contributors validating changes to the model routing layer.

For comparison, Claude Desktop (Anthropic's official desktop application) is a chat-focused interface with MCP tool support. It provides a conversation experience and can call MCP-connected tools, but does not include a workspace file tree, built-in terminal, task scheduling, or multi-provider model routing. MyAgents adds those OS-level integrations at the cost of considerably more setup complexity and a heavier application footprint.

The AGPL-3.0-only license means deployed modifications must be open-sourced. The repository includes a COMMERCIAL-LICENSING.md file, suggesting that a separate commercial license is available for use cases where AGPL terms are not suitable. The last push was on 2026-09-27. The project is not archived and has been releasing weekly builds, with v0.4.21 shipped on 2026-09-22.

Editorial conclusion

MyAgents is appropriate for developers and power users who want a local-first AI agent workbench that ties together workspace files, task scheduling, a built-in terminal, and multi-provider model routing in a single desktop application. It is a poor fit for users who only need a simple conversation interface or whose work lives entirely in the browser. Before committing it to production workflows, review COMMERCIAL-LICENSING.md, since the AGPL-3.0-only license requires open-sourcing any network-deployed modifications, and a commercial license may be necessary for some use cases.

Frequently asked questions

Official sources

1. hAcKlyc/MyAgents on GitHub
2. License: AGPL-3.0
3. Project website
4. README
5. Releases