Wegent

🚀 An open-source platform to define, organize, and run Agentic AI

English | 简体中文

🚀 Build Your Own AI Agent Workforce

From coding assistants to news analysts - deploy intelligent agents that actually work

Quick Start · Use Cases · Documentation · Development Guide

---

💡 What Can You Build?

Wegent empowers you to create powerful AI applications through intelligent agent orchestration:

🖥️ Web-Based Coding Assistant

Build a full-featured development environment in your browser with GitHub integration, supporting independent development spaces locally or in the cloud, capable of running multiple Coding Agents simultaneously

📰 News Intelligence Platform

Create a smart news aggregation and analysis system

🔧 Custom Agent Applications

The possibilities are endless - build agents for:

• Data Analysis: Automated report generation and visualization
• Content Creation: Blog posts, social media, and marketing materials
• Customer Support: Intelligent chatbots with contextual understanding
• DevOps Automation: CI/CD pipeline management and monitoring
• Research Assistant: Literature review and knowledge synthesis

---

📖 What is Wegent?

Wegent is an open-source AI native operating system that enables you to define, organize, and run intelligent agents at scale. Built on Kubernetes-style declarative API and CRD (Custom Resource Definition) design patterns, Wegent provides a standardized framework for creating and managing AI agent ecosystems.

🌟 Core Capabilities

1. 🎨 Configuration-Driven Agent Teams: Define and run personalized agent teams through YAML configuration with web UI - no secondary development required
2. ⚙️ Multi Execution Engines: Built on Agno and Claude Code agent engines at the bottom layer, supporting both dialogue and coding modes at the upper layer
3. 🔒 Isolated Sandbox Environments: Each agent team runs in an independent sandbox, enabling multiple teams to execute simultaneously
4. 🤝 Advanced Collaboration Modes: Dialogue mode supports parallel, leader-based, and other agent collaboration patterns for complex workflows like news insights and content retrieval
5. 💻 AI Coding Integration: Coding mode integrates with GitHub/GitLab and other code services to implement AI-driven development, code review, and other coding workflows

graph LR
    subgraph AIResource ["🌐 AI Native Resource"]
        subgraph YAMLDef ["📄 YAML Definitions"]
            Ghost["👻 Ghost<br/>Agent Soul"]
            Model["🧠 Model<br/>Model Configuration"]
            Shell["🐚 Shell<br/>Agent Program"]
            Bot["🤖 Bot<br/>Agent Instance"]
            CollabModel["🤝 Collaboration<br/>Collaboration Model"]
            Team["👥 Team<br/>Collaborative Team"]
        end
     end
    
    subgraph Wegent ["🚀 Wegent"]
        Workspace["💼 Workspace<br/>Work Environment"]
        TeamInstance["👥 Agent Team Instance<br/>Running Team"]
    end
   
      User["👤 User"]
      Task["🎯 Task<br/>User Task"]
    %% CRD Resource Relationships
    Ghost --> Bot
    Model --> Bot
    Shell --> Bot
    Bot --> Team
    CollabModel --> Team
    Shell --> Team
    
    %% Team Definition to Instance
    AIResource --> Wegent
    Workspace --> TeamInstance
    
    %% User Interaction Flow
    User --> Task
    Task --> TeamInstance
    TeamInstance --> Task
    
    %% Styling
    classDef yamlBox stroke-dasharray: 5 5
    classDef runtimeBox stroke:#ff6b6b,stroke-width:2px
    classDef resourceBox stroke:#4ecdc4,stroke-width:2px
    
    class YAMLDef yamlBox
    class Runtime runtimeBox
    class AIResource resourceBox

Loading

🎯 Key Concepts

• 👻 Ghost: The "soul" of an agent - defines personality, capabilities, and behavior patterns
• 🧠 Model: AI model configuration - defines environment variables and model parameters
• 🐚 Shell: The "executable" - A program capable of launching an agent
• 🤖 Bot: A complete agent instance combining Ghost + Shell + Model
• 👥 Team: Composed of multiple Bots + Collaboration Model, defining how agents work together
• 🤝 Collaboration: Defines the interaction patterns between Bots in a Team (like Workflow)
• 💼 Workspace: Isolated work environments for tasks and projects
• 🎯 Task: Executable units of work assigned to teams

💡 Detailed YAML Configuration Documentation:

• Complete YAML configuration examples and field descriptions

🚀 Quick Start

Prerequisites

• Docker and Docker Compose
• Git

1. Clone the repository

   git clone https://github.com/wecode-ai/wegent.git
   cd wegent

2. Start the platform

   docker-compose up -d

3. Access the web interface

   • Open http://localhost:3000 in your browser

4. Configure GitHub Access Tokens

   • Follow the page instructions to configure your GitHub access token

5. Configure Bot

   Wegent ships with a built-in development bot. For the Claude Code runtime, set the following environment variables:

   {
     "env": {
       "ANTHROPIC_MODEL": "openrouter,anthropic/claude-sonnet-4",
       "ANTHROPIC_AUTH_TOKEN": "sk-xxxxxx",
       "ANTHROPIC_BASE_URL": "http://xxxxx",
       "ANTHROPIC_DEFAULT_HAIKU_MODEL": "openrouter,anthropic/claude-haiku-4.5"
     }
   }

   Important - Environment Variable Names:

   Different Shell runtimes use different environment variable names for API authentication:

   • Claude Code Shell: Uses ANTHROPIC_AUTH_TOKEN
   • Agno Shell: Uses ANTHROPIC_API_KEY
   • Dify Shell: Uses DIFY_API_KEY and DIFY_BASE_URL

   Please set the correct variable based on your Shell configuration. Check the Shell's documentation or the executor/agents/ code for specific requirements.

6. Run task

   On the task page, select your project and branch, describe your development requirements, such as implementing a bubble sort algorithm using Python

🏗️ Architecture

graph TB
    subgraph "🖥️ Management Platform Layer"
        Frontend["🌐 Next.js Frontend"]
        Backend["⚙️ FastAPI Backend"]
        API["🚀 Declarative API"]
    end
    
    subgraph "📊 Data Layer"
        MySQL[("💾 MySQL Database")]
    end
    
    subgraph "🔍 Execution Layer"
        ExecutorManager["💯 Executor Manager"]
        Executor1["🚀 Executor 1"]
        Executor2["🚀 Executor 2"]
        ExecutorN["🚀 Executor N"]
    end
    
    subgraph "🤖 Agent Layer"
        Claude["🧠 Claude Code"]
        Agno["💻 Agno"]
        Dify["✨ Dify"]
    end


    %% System Interactions
    Frontend --> API
    API --> Backend
    Backend --> MySQL
    Backend --> ExecutorManager
    ExecutorManager --> Executor1
    ExecutorManager --> Executor2
    ExecutorManager --> ExecutorN

    %% AI Program Integration
    Executor1 --> Claude
    Executor2 --> Agno
    ExecutorN --> Dify

Loading

🛠️ Development

For detailed development setup instructions, please see the Development Guide.

Project Structure

wegent/
├── backend/          # FastAPI backend service
├── frontend/         # Next.js web interface
├── executor/         # Task execution engine
├── executor_manager/ # Execution orchestration
├── shared/           # Common utilities and models
└── docker/           # Container configurations

Quick Development Setup

1. Backend Development

   cd backend
   pip install -r requirements.txt
   uvicorn app.main:app --host 0.0.0.0 --port 8000 --reload

2. Frontend Development

   cd frontend
   npm install
   npm run dev

3. Run Tests

   # Backend tests
   cd backend && python -m pytest
   
   # Frontend tests
   cd frontend && npm test

For comprehensive setup instructions including database configuration, environment variables, and troubleshooting, refer to the Development Guide.

🤝 Contributing

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

Development Workflow

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Add tests
5. Submit a pull request

📞 Support

• 🐛 Issues: GitHub Issues

👥 Contributors

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

qdaxb

cc-yafei

fengkuizhi

feifei325

Micro66

moqimoqidea

---

Made with ❤️ by WeCode-AI Team