Noureddine RAMDI / DeepChat: a unified Electron desktop platform for multi-LLM AI agents with ACP integration

Created Mon, 04 May 2026 10:23:01 +0000 Modified Sat, 23 May 2026 20:41:27 +0000
947 Words
github-stars typescript electron ai-agents mcp acp multi-llm

ThinkInAIXYZ/deepchat

DeepChat tackles a common pain point in AI tooling: how to unify multiple language models, external AI agents, and tool integrations into a single, coherent desktop interface. It goes beyond standard chat clients by supporting both cloud and local models, multi-window/tab workflows, and even remote control through popular messaging platforms. The key technical highlight is its implementation of the Agent Client Protocol (ACP), which treats external autonomous agents as first-class ‘models’ with their own dedicated workspace UI. This design bridges the gap between simple chat interfaces and autonomous agent execution, making agent workflows feel integrated rather than bolted on.

what deepchat does and how it is built

DeepChat is an Electron-based desktop application built primarily in TypeScript. It serves as an AI agent platform that unifies multi-LLM chat, the Model Context Protocol (MCP) for tool calling, and the Agent Client Protocol (ACP) for integrating autonomous agents into one interface.

Architecturally, DeepChat supports multiple LLM providers including cloud APIs (OpenAI, Gemini, Anthropic, DeepSeek) and local models via Ollama. It implements the full MCP protocol, which standardizes how models access resources, prompts, and tools, using transport mechanisms like StreamableHTTP, Server-Sent Events (SSE), and stdio. The MCP protocol enables DeepChat to orchestrate tool invocations and extend model capabilities seamlessly.

The ACP integration is particularly notable: it allows external AI agents to connect and function as if they were standard chat models, complete with dedicated workspace UIs. This approach is quite novel — instead of treating agents as separate or secondary components, DeepChat brings them into the same UI and interaction model as LLM chatbots.

The app uses Electron for a native desktop experience with multi-window and tabbed UI architecture. It also supports remote control through messaging platforms like Telegram, Discord, Feishu, QQBot, and WeChat, enabling conversational AI interactions beyond the local machine.

DeepChat includes a modular Skills system compatible with the Agent Skills specification, allowing users to import/export task-specific instructions and extend AI assistants’ capabilities. Privacy is a consideration: user data is stored locally by default, supporting personal and commercial use cases under an Apache 2.0 license.

the agent client protocol integration as a technical strength

What sets DeepChat apart is the ACP integration that treats external agents as pluggable, first-class models.

Most multi-LLM chat clients focus on switching between or aggregating LLM outputs. DeepChat goes further by running autonomous agents that can execute workflows, call tools, and maintain state within dedicated UI workspaces.

This design abstracts away differences between a chat model and an autonomous agent, giving users a consistent experience regardless of which backend powers the interaction. Under the hood, the MCP protocol manages resources and tool invocations, while the ACP handles the lifecycle and UI integration of agents.

This architecture has tradeoffs. By supporting multiple protocols and integrating remote control, the codebase and runtime footprint become more complex compared to lightweight chat clients. Electron apps also tend to have a larger footprint, but this is a reasonable tradeoff for the feature set and cross-platform native experience.

The code quality is strong: the TypeScript codebase is well-structured, leveraging the MCP and ACP specifications to enforce protocol adherence and modularity. The Skills system adds flexibility for extending agent capabilities with reusable task modules.

Overall, DeepChat’s approach to blending multi-LLM orchestration, tool calling, and autonomous agent execution in one desktop app is relatively rare and well-executed.

quick start

DeepChat offers multiple installation paths depending on your platform and preferences:

Option 1: GitHub Releases

Download the latest installer for your OS from the GitHub Releases page:

  • Windows: .exe
  • macOS: .dmg
  • Linux: .AppImage or .deb

Option 2: Official Website

Download the app directly from the official website.

Option 3: Homebrew (macOS only)

brew install --cask deepchat

Once installed:

  1. Launch DeepChat.
  2. Open settings and navigate to the “Model Providers” tab.
  3. Add API keys for cloud models or configure local Ollama models.
  4. Create a new conversation by clicking the “+” button.
  5. Select your desired model and start chatting.

For a comprehensive guide, check the documentation index included in the app.

verdict

DeepChat is a solid choice if you need a unified desktop platform that blends multi-LLM chat with autonomous agent execution and tool integrations.

Its ACP implementation that treats agents as first-class models is a unique architectural choice that makes agent workflows feel native and integrated.

The project’s complexity and Electron base mean it’s not the lightest or simplest chat client, but if you require multi-agent orchestration, remote control, or a modular Skills system, it’s worth exploring.

For straightforward single-model chat needs or minimal setups, lighter web or CLI clients might be easier.

Overall, DeepChat offers a comprehensive and thoughtfully engineered platform for advanced AI interaction scenarios, especially for developers and power users who want to unify diverse AI workflows into one desktop app.

→ GitHub Repo: ThinkInAIXYZ/deepchat ⭐ 5,769 · TypeScript