Async IDE

What is Async IDE?

Async IDE is an AI-native desktop shell built from scratch on Electron + React + Monaco. It is not a VS Code fork — the entire codebase is intentionally lean, fully transparent, and hackable.

The central idea is simple: the agent is the center of gravity, not a chat panel bolted onto the side of an editor. Everything — workspace access, tool execution, diff review, terminal operations — revolves around a transparent Think → Plan → Execute → Observe loop that you can see, steer, and interrupt at any time.

• Apache 2.0 • BYOK for models • Local-first by default

Highlights

• Agent-first loop — Autonomous multi-round tool execution with streaming parameter cards (Read, Write, Edit, Glob, Grep, Shell, etc.) and approval gates for sensitive operations.
• Four Composer modes — Agent (full auto), Plan (review first, then run), Ask (read-only Q&A), and Debug (systematic troubleshooting).
• Team mode — Multi-agent collaboration with Lead planning, specialist execution, reviewer verification, and plan-approval workflows.
• Multi-model, multi-provider — Anthropic, OpenAI, Gemini, plus any OpenAI-compatible endpoint (Ollama, vLLM, self-hosted). Auto model selection included.
• Git-native — Status, diff, staging, commit, and push integrated into the UI; agent-driven changes stay in sync with your real repo.
• IM bot bridge — Wire Telegram, Slack, Discord, and Feishu (Lark) into the same Agent / Team toolchain as the desktop app, with per-integration model, workspace, and allowlist config.
• Built-in tools — Browser automation (with custom headers / fingerprint), LSP-powered editor intelligence, MCP server support, file index & symbol search, and an all-in-one terminal shared between user and agent.
• Local & private — Threads, settings, and plans live on your machine. No cloud lock-in.

Screenshots

Agent Layout

Model Settings

Appearance Color Palette

Mac Codex Theme

Browser Tool Invocation (customizable request headers)

Multi-Agent Collaborative Expert Group

Control the App via External Chat Bots

All-in-One Terminal (commands invokable by Agents and bots)

Core Features

Autonomous Agent Loop

• Streaming tool parameters with trajectory cards for clear execution visibility.
• Plan and Agent dual modes: review the plan first, or let the agent run directly.
• Approval gates for shell commands and file writes.
• Editor context sync so agent edits can focus on the relevant file and line range.
• Support for nested sub-agents, background execution, and timeline-style activity rendering.

Multi-Model Support

• Built-in adapters for Anthropic, OpenAI, and Gemini.
• Support for OpenAI-compatible endpoints like Ollama, vLLM, aggregators, or self-hosted services.
• Streaming thinking blocks on supported models.
• Auto mode to automatically pick the best available model.

Developer Experience

• Monaco editor with multi-tab support, syntax highlighting, and diff review flows.
• Git integration: status, diff, staging, commit, and push all available from the UI.
• xterm.js terminal: for both user commands and observing agent shell operations.
• Composer with @ file mentions, rich segments, and persistent threads.
• Quick Open palette (Ctrl/Cmd+P) and keyboard-first navigation.
• Built-in i18n support for English and Simplified Chinese.
• Support for local disk skills, workspace config merge, and tool approval controls.

IM / Bot Integrations

Async can act as the host for coding agents on external chat surfaces, not only inside the Electron UI.

• Platforms — Telegram, Slack, Discord, and Feishu (Lark) via dedicated adapters under main-src/bots/platforms/.
• Same runtime — Inbound messages run through botRuntime: normal threads use agentLoop, while Team mode uses the same teamOrchestrator path as the desktop Composer, including worker streaming and tool status where applicable.
• Per integration — Enable/disable, display name, default model, default Composer mode (agent / ask / plan / team), workspace root(s), optional allowlists for chats and users, and an extra system prompt on top of project rules.
• Connectivity — Optional HTTP proxy URL per platform when vendor APIs must go through a corporate proxy.
• Feishu — App credentials, optional encryption, streaming interactive cards for long-running replies, and session hygiene when integration settings change.
• Configuration UI — Managed from Settings → Bots (SettingsBotsPanel.tsx).

For a deeper module-level walkthrough, see the maintainer-oriented notes under docs/llm-wiki/.

Technical Architecture

┌─────────────────────────────────────────────────────────┐
│                    Renderer Process                    │
│  React + Vite  │  Monaco Editor  │  xterm.js Terminal  │
│  Composer / Chat / Plan / Agent UI                     │
└──────────────────────────┬──────────────────────────────┘
                           │  contextBridge (IPC)
┌──────────────────────────▼──────────────────────────────┐
│                      Main Process                      │
│  agentLoop.ts  │  toolExecutor.ts  │  LLM Adapters     │
│  gitService    │  threadStore      │  settingsStore    │
│  workspace     │  LSP session      │  PTY terminal     │
└─────────────────────────────────────────────────────────┘

Tech Stack

• Built from scratch on Electron + React + Monaco — not a VS Code fork. The architecture is intentionally lean: two processes (main + renderer), clear IPC boundaries, and no inherited extension ecosystem to maintain.
• agentLoop.ts handles multi-round tool calls, partial JSON streaming, tool repair, and aborts.
• Structured assistant messages are persisted locally and expanded to provider-native tool formats when needed.
• Local persistence stores threads, settings, and plans as JSON / Markdown under user data.
• gitService provides the Git layer used by the UI for status, diff, staging, commit, and push.
• LSP integration uses TypeScript Language Server for in-editor intelligence.

Project Structure

Async/
├── main-src/                  # Bundled -> electron/main.bundle.cjs (Node / Electron main)
│   ├── index.ts               # App entry: windows, userData, IPC registration
│   ├── agent/                 # agentLoop.ts, toolExecutor.ts, agentTools.ts, toolApprovalGate.ts
│   ├── llm/                   # OpenAI / Anthropic / Gemini adapters & streaming
│   ├── lsp/                   # TypeScript LSP session
│   ├── mcp/                   # Model Context Protocol integration
│   ├── memdir/                # Memory directory management
│   ├── bots/                  # IM bot controller, runtime, connectivity, platform adapters
│   ├── ipc/register.ts        # Core IPC handlers (chat, threads, agent, plan)
│   ├── ipc/handlers/          # Domain-specific IPC handlers (git, fs, mcp, settings, ...)
│   ├── shell/                 # Shell command execution
│   ├── threadStore.ts         # Persistent threads + messages (JSON)
│   ├── settingsStore.ts       # settings.json
│   ├── gitService.ts          # Porcelain status, diff previews, commit/push
│   ├── workspace.ts           # Open-folder root & safe path resolution
│   ├── workspaceFileIndex.ts  # File indexing for workspace
│   ├── workspaceSymbolIndex.ts    # Symbol indexing
│   └── workspaceUsageStats.ts     # Workspace usage statistics
├── src/                       # Vite + React renderer
│   ├── App.tsx                # Shell layout, chat, composer modes, Git / explorer
│   ├── AgentChatPanel.tsx     # Agent chat interface
│   ├── AgentLeftSidebar.tsx   # Agent activity sidebar
│   ├── AgentRightSidebar.tsx  # Agent tools and results
│   ├── ChatComposer.tsx       # Message composer component
│   ├── EditorMainPanel.tsx    # Monaco editor panel
│   ├── SettingsPage.tsx       # Settings UI
│   ├── SettingsBotsPanel.tsx  # IM bot integrations (Telegram / Slack / Discord / Feishu)
│   ├── WorkspaceExplorer.tsx  # File explorer
│   ├── hooks/                 # Custom React hooks
│   ├── i18n/                  # Locale messages (en / zh-CN)
│   └── ...                    # Agent UI, Plan review, Monaco, terminal, ...
├── electron/
│   ├── main.bundle.cjs        # esbuild output (do not edit by hand)
│   └── preload.cjs            # contextBridge -> window.asyncShell
├── docs/assets/               # Logo, screenshots
├── scripts/
│   └── export-app-icon.mjs    # Rasterize SVG -> resources/icons/icon.png
├── esbuild.main.mjs           # Builds main process
├── vite.config.ts             # Renderer build
└── package.json

Data Storage

Default location under Electron's userData directory:

• async/threads.json: threads and chat messages.
• async/settings.json: model configuration, API keys, layout, agent options, and bot integrations.
• .async/plans/: Markdown plan documents generated in Plan mode.

The renderer may use localStorage for lightweight UI state, but the authoritative data source for conversations is threads.json.

Getting Started

Prerequisites

• Node.js >= 18
• npm >= 9
• Git (recommended)

Install and Run

git clone https://github.com/ZYKJShadow/Async.git
cd Async
npm install
npm run desktop

If you prefer Gitee:

git clone https://gitee.com/shadowsocks_z/Async.git
cd Async
npm install
npm run desktop

Development

npm run dev          # Dev server with hot reload
npm run dev:debug    # Same, with DevTools open
npm run icons        # Generate app icons from SVG

Acknowledgements

We are grateful to the open-source community and projects like Claude Code that helped demonstrate the power of agent-driven development — Async IDE builds on that momentum with its own take on transparent, local-first AI workflows.

Community

Have questions, ideas, or just want to chat with a community of developers?

• Forum: linux.do — Join the discussion, share your setup, report issues, and stick around.

License

This project is open-sourced under the Apache License 2.0.