Wegent

A self-hostable AI workspace for chat, coding, knowledge bases, automation, and local execution.

English | 简体中文

Quick Start · Core Scenarios · Wework Desktop · How It Grows · Documentation · Development Guide

Wework Desktop Is Now Available

Download the latest desktop build and choose the installer package that matches your operating system.

Download Wework Desktop

Why Wegent

Wegent is a self-hostable AI workspace for managing chat, coding tasks, knowledge bases, automation, and local execution in one place. You can ask questions over your own materials, hand code repositories to AI, turn recurring information checks into automated feeds, and let your team use the same assistants from DingTalk, Telegram, or other tools. When a task needs local repositories or intranet access, it can run on your own machine.

• Start privately: Launch a self-hosted workspace with one command and begin with chat and knowledge Q&A.
• Grow into team workflows: Share common assistants, models, tools, and knowledge bases instead of configuring them repeatedly.
• Choose where work runs: Run coding tasks, automation, and local-device jobs in the environment that fits the job.
• Fit existing tools: Bring AI into your current workflow through APIs or IM bots.

🚀 Quick Start

Prerequisite: Docker and Docker Compose.

curl -fsSL https://raw.githubusercontent.com/wecode-ai/Wegent/main/install.sh | bash -s -- --standalone

This starts the default Standalone mode: one container with SQLite for local trials and lightweight deployments.

Then open http://localhost:3000 in your browser.

Deployment Modes

Standalone can choose where coding/execution agents run:

Interactive macOS installs default to host; Linux and non-interactive installs default to container.

# Standalone mode (default executor mode)
curl -fsSL https://raw.githubusercontent.com/wecode-ai/Wegent/main/install.sh | bash -s -- --standalone

# Standalone mode with an explicit executor mode: host, container, or hybrid
curl -fsSL https://raw.githubusercontent.com/wecode-ai/Wegent/main/install.sh | bash -s -- --standalone --executor-mode host

# Standard mode
curl -fsSL https://raw.githubusercontent.com/wecode-ai/Wegent/main/install.sh | bash -s -- --standard

# Development mode
git clone https://github.com/wecode-ai/Wegent.git && cd Wegent && ./start.sh

# Standalone mode
docker logs -f wegent-standalone
docker restart wegent-standalone

# Standard mode
docker compose logs -f
docker compose down
docker compose up -d

# Development mode
./start.sh --status
./start.sh --restart
./start.sh --stop

See Standalone Mode and Quick Start for details.

Core Scenarios

Chat, Group Chat, and File Handling

Set up a private AI chat entrypoint. Wegent supports multiple models, multi-turn history, group chat with @mentions, file parsing, clarifying questions, answer checking, and long-term memory. When needed, AI can also read files, run commands, or generate diagrams.

Let AI Work on Code Repositories

Let AI work on code in isolated environments. Wegent connects to GitHub, GitLab, Gitea, and Gerrit so agents can clarify requirements, create branches, modify code, run tests, commit changes, and open pull requests.

Track Information and Publish Feeds

Turn AI into a continuously running task trigger. Set schedules or event triggers so AI can summarize information, analyze webpages, filter notifications, and publish results as a feed.

Knowledge Q&A

Upload documents, import webpages, or sync DingTalk multi-dimensional tables to build team knowledge bases. Wegent handles parsing, conversion, indexing, and retrieval so AI can answer with your own materials.

Local Device Execution

Install a local runner on your own machine and connect it securely to Wegent. Tasks can switch between cloud environments and local devices, which is useful when AI needs access to local repositories, intranet resources, or dedicated development environments.

Wework Desktop

Wework brings the AI coding workspace onto your own computer. You can open a local project, start a coding conversation, let AI read and edit files, review the changes, and keep working even when you are not connected to a Wegent server. When you do connect to a server, cloud models and remote devices appear in the same workspace instead of becoming a separate product.

It is designed for day-to-day coding work:

• Code where the repo already lives: work directly against local folders, private networks, local CLIs, and machine-specific setup.
• Continue real coding sessions: pick up local runtime conversations and keep context tied to the project.
• Review before you accept: inspect file changes, browse project files, and use the built-in terminal from the same workbench.
• Use local or cloud resources together: start locally by default, then add server models, cloud devices, and shared authentication when a team deployment is available.

For developer setup and packaging commands, see wework/README.md.

Team Tools and Existing Systems

Connect Wegent agents to DingTalk, Telegram, and other IM tools, or call them from existing applications through an API.

How It Grows

You do not need to learn every concept upfront. Wegent can start as a private AI workspace: choose a model, create an assistant, upload materials, and chat. As your team starts reusing these capabilities, you can turn common assistants, knowledge bases, coding tasks, and IM entrypoints into shared workflows.

Internally, Wegent splits an AI assistant into reusable pieces:

Ghost (prompt + MCP + Skills)
  + Shell (Chat / ClaudeCode / Dify)
  + Model (Claude / OpenAI / Gemini / DeepSeek / GLM, etc.)
  = Bot

Multiple Bots + collaboration mode = Team (the user-facing Agent)
Team + Workspace = Task (a traceable execution)

These relationships can be created in the web UI or managed with YAML. The web wizard supports "describe requirements → AI follow-up questions → live prompt tuning → one-click creation."

Deployment and Integration

Wegent can grow from a personal trial to a team deployment:

• Personal trial: Standalone mode starts one container, suitable for a laptop or lightweight server.
• Team deployment: Standard mode uses dedicated database, cache, and execution services for long-running use.
• Local devices: Connect your own machine as a place to run tasks that need local repositories or intranet access.
• Desktop app: Use Wework for a local-first coding workspace that can also connect back to a team Wegent deployment.
• Existing systems: Connect Wegent to team tools through APIs or IM bots.

graph TB
    User["User / API / IM"] --> Frontend["Next.js Web"]
    User --> Wework["Wework Desktop<br/>Tauri + React"]
    User --> Backend["FastAPI Backend"]
    Frontend --> Backend
    Wework --> Backend
    Wework --> WeworkExecutor["Local Executor Sidecar<br/>Codex / Local Work"]

    Backend --> MySQL[("MySQL / SQLite")]
    Backend --> Redis[("Redis")]
    Backend --> ChatShell["Chat Shell<br/>LangGraph + Multi-LLM"]
    Backend --> ExecutorManager["Executor Manager"]
    Backend --> KnowledgeRuntime["Knowledge Runtime"]

    ExecutorManager --> CloudExecutor["Cloud Executor<br/>ClaudeCode / Dify"]
    Backend <--> LocalExecutor["Local Executor<br/>WebSocket"]
    KnowledgeRuntime --> VectorStore["Elasticsearch / Qdrant / Milvus"]
    Backend --> DocConverter["Knowledge Doc Converter<br/>MinerU OCR"]

For Developers and Team Admins

• Application integration: Call Wegent agents from your own apps through /api/v1/responses.
• External tools: Use MCP to let AI call existing tools and services.
• Reusable capabilities: Package specialized abilities as Skills and load them only when needed.
• Local-first desktop runtime: Extend Wework when teams need local repositories, terminals, device tools, and cloud-connected coding workflows in one desktop app.
• Flexible runtimes: Use different runtime engines for chat, coding tasks, multi-agent work, and external app proxying.
• Central model management: OpenAI, Claude, Gemini, DeepSeek, GLM, and protocol-compatible model services.
• Team sharing and permissions: Groups, shared agents, shared models, shared Skills, and admin management.
• Observability: OpenTelemetry support across backend, frontend, and execution services.

Built-in Assistants

Documentation

• Quick Start
• Installation Guide
• Core Concepts
• Skill System
• YAML Specification
• OpenAPI Responses API
• Developer Guide

Contributing

We welcome contributions! Please see our Contributing Guide for details.

Support

• 🐛 Issues: GitHub Issues
• 💬 Discord: Join our community

Contributors

Thanks to the following developers for their contributions and efforts to make this project better. 💪