AgenticX

MCPAI代理

提供方 DemonDamon · 包名 agenticx

AI代理 stdio · 本地进程 未标注 社区 / 第三方 Claude DesktopCursorClineClaude Code
查看接入方式

AgenticX is a unified, production-ready multi-agent platform — Python SDK + CLI (agx) + Studio server + Machi desktop app. Features Meta-Agent orchestration, 15+ LLM providers, MCP Hub, hierarchical m

一句话选型结论

按资料字段整理

AgenticX 属于AI代理类 MCP 服务器,stdio · 本地进程,鉴权方式未标注,可直接接入 Claude Desktop、Cursor、Cline 等,有可直接执行的安装命令。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类AI代理 传输方式stdio · 本地进程 鉴权未标注 部署方式本地部署
GitHub 星标 113 仓库热度,无公开仓库时显示未标注
工具数 未标注 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

AI代理
数量来自来源目录的标注,具体工具清单以官方文档为准
工具数量未标注暴露给模型可调用的工具个数
资源数量0可读取的资源条目
提示词数量0内置提示词模板数量

能力标签

agent-framework agentic-workflows ai-agent ai-orchestration chatbot

支持客户端

适用场景

agent-frameworkagentic-workflowsai-agent

安装与配置

stdio · 本地进程 未标注
客户端在本机拉起子进程,数据不出本机
pip install agenticx

这条命令只是入口,具体启动参数请按官方文档补齐,不要直接照搬到别的服务器。

  1. 1
    准备运行环境

    stdio 服务在本地起进程,需要先装好 Cross-platform,再按安装命令拉取依赖。

  2. 2
    安装服务

    复制上面的安装命令执行;命令里带占位符的位置,换成自己的密钥或路径。

  3. 3
    写入客户端配置

    在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,让新配置生效。

  4. 4
    验证是否可用

    连接成功后随便调一个只读工具,确认能返回结果,再接入正式流程。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
给代理接外部能力

让代理在任务中途调用搜索、数据库等真实工具。

多步任务编排

把一串操作拆成步骤,由代理按顺序执行。

自动化重复流程

把固定流程交给代理跑,减少手工操作。

选择建议

选之前先看这几条
按条目字段给出的判断,不替你决定用不用

值得选的地方

  • 有现成的安装命令,不用自己找入口,照着跑就能起服务。
  • 已适配 Claude Desktop、Cursor、Cline,换客户端不用重新研究配置。

先想清楚的地方

  • stdio 方式要求本地装好运行时(如 Node.js),换机器要重新装一遍。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在AI代理场景里让模型直接调用外部能力的人。
  • 已经在用 Claude Desktop、Cursor 的用户,接入路径最短。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

  • 完全不想在本地装环境的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
AgenticX当前 未标注 stdio · 本地进程 本地部署 有 2026-04-20
Filesystem 560c4363 13 未标注 本地部署 无 2026-05-17
Server Everything (everything) 11 stdio · 本地进程 本地部署 有 2026-05-17
Time 7365cb6d 2 SSE · 服务端推送 远程部署 有 2026-05-18
Everything Claude Code 未标注 stdio · 本地进程 本地部署 有 2026-05-17
Openmemory 557e1585 未标注 stdio · 本地进程 本地部署 有 2026-05-17

服务器档案

AI代理
字段来自项目仓库与公开索引,中文说明由本站标注
提供方DemonDamon上游标注的维护方 DemonDamon
分类AI代理本站按上游分类展示
连接方式stdio · 本地进程客户端在本机拉起子进程,数据不出本机
鉴权方式未标注远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时agenticx · Cross-platform本地安装时用到的包标识与运行时
部署类型本地部署上游给出的部署形态
最近核验2026-04-20上游最后核验时间

详细介绍

34.8 KB
来自项目仓库与上游目录的原文,未做删改

A unified agent technology stack spanning the Python Agent Runtime, Near Desktop, and Enterprise


Language / 语言: English | 中文


Security advisory

LiteLLM (PyPI): Malicious releases litellm 1.82.7 and 1.82.8 were removed from PyPI after reports that they could exfiltrate API keys. If you ever installed either version, uninstall them, rotate any credentials that may have been exposed, and upgrade to a release the upstream project and PyPI list as safe (for example 1.82.9+, per current upstream guidance). Check your environment with pip show litellm.


Vision

AgenticX provides a unified, scalable, production-ready agent technology stack. Developers can build directly with the Python SDK and agx CLI, use Near Desktop as a local-first multi-agent workspace, or deploy AgenticX Enterprise for enterprise access, governance, compliance gateway, and audit capabilities.

System Architecture

The architecture consists of one shared capability core and two product forms:

  • AgenticX Core / Runtime: Python SDK, Studio Server, and Agent Runtime for orchestration, tools, MCP, memory, knowledge bases, Skills, Hooks, model adapters, secure sandboxes, observability, and evaluation.
  • Near Desktop: An Electron + React local-first workspace. Its default path connects to a local agx serve / agx-server, with multi-pane chat, avatars and group chat, workspaces, terminal, automation, Voice Focus, and an optional remote single-server backend.
  • AgenticX Enterprise: Web Portal, Admin Console, and Go AI Gateway for enterprise use. Employee chat passes through Portal BFF before the Gateway. The Gateway handles authentication, policy, quota, model relay, response governance, audit, and usage; it is not a full Agent Runtime.

Near and Enterprise share AgenticX abstractions and capabilities, but their current deployment paths are independent. Near defaults to the local Python Runtime; Enterprise uses the Go Gateway for its current online path. Enterprise Edge Agent is an MVP outside the default path, while Cluster Agent Runtime remains planned.

Core Features

Core Framework

  • Agent Core: Agent execution engine based on 12-Factor Agents methodology, with Meta-Agent CEO dispatcher, agent team management, think-act loop, event-driven architecture, self-repair, and overflow recovery
  • Embeddable ReActAgent (SDK primitive): Canonical async function-calling ReAct loop (ainvoke/astream) with a typed AgentEvent stream, multi-turn history in/out, parallel tool execution, and optional loop-detector / compactor / offloader injection — zero Studio/CLI coupling (legacy text-JSON TextReActAgent facade kept for compatibility)
  • Unified Offload: Offloader protocol + filesystem-backed FileOffloader keep large tool results / compressed context out of live history (inline reference placeholders, retrieved on demand); plus an in-workspace MCP gateway that runs MCP servers inside the sandbox
  • Orchestration Engine: Graph-based workflow engine + Flow system with decorators, execution plans, conditional routing, and parallel execution
  • Tool System: Unified tool interface with function decorators, MCP Hub (multi-server aggregation), remote tools v2, OpenAPI toolset, sandbox tools, skill bundles, and document routers
  • Memory System: Hierarchical memory (core / episodic / semantic), Mem0 deep integration, workspace memory, short-term memory, memory decay, hybrid search, compaction flush, MCP memory, and memory intelligence engine
  • LLM Providers: 15+ providers — OpenAI, Anthropic, Ollama, Gemini, Kimi/Moonshot, MiniMax, Ark/VolcEngine, Zhipu, Qianfan, Bailian/Dashscope — with response caching, transcript sanitizer, and failover routing
  • Communication Protocols: A2A inter-agent protocol (client / server / AgentCard / skill-as-tool), MCP resource access protocol
  • Task Validation: Pydantic-based output parsing, auto-repair, and guiderails

Avatar & Team Collaboration

  • Avatar System: Avatar registry (CRUD), group chat with multiple routing strategies (user-directed / meta-routed / round-robin)
  • Meta-Agent Runtime: CEO dispatcher with dynamic sub-agent orchestration, team management with concurrency limits, archived snapshots, and session isolation
  • Collaboration Patterns: Delegation, role-playing, conversation management, task locks, and collaboration metrics

Knowledge & Retrieval

  • Knowledge Base: Document processing pipeline with chunkers, readers, extractors, and graph builders (GraphRAG)
  • Multi-Brain Knowledge: Isolatable, per-avatar/session mountable "doc brain + code brain" architecture with cross-brain aggregated search
  • Code Semantic Index: Hybrid (vector + BM25) retrieval across multiple codebases, wired into the "code brain"
  • Retrieval System: Vector retriever, BM25 retriever, graph retriever, hybrid retriever, auto-retriever, and reranker
  • Embeddings: OpenAI, Bailian, SiliconFlow, LiteLLM, with smart routing

Skills & Self-Evolution

  • Skill System: Registration and full lifecycle management — dangerous-pattern security scan gate, 5-strategy fuzzy patch, .changelog versioning, source tagging, and per-skill enable/disable
  • Skill Self-Evolution: Captures tool-call observations at runtime and auto-distills new skills via background LLM session review; quality gate, usage stats, and deprecation form the lifecycle loop
  • Extension Ecosystem (AGX Bundle): Bundle definitions (skills / mcp_servers / avatars / memory_templates), local install/uninstall, multi-source registry aggregated search

Long-Horizon Autonomous Coding

  • Long-Run Orchestration: Polls multiple task sources (manual queue / Cron / Linear / project features), per-task isolated workspaces, stall self-healing, continuation/failure dual-track backoff, incremental token accounting
  • Project State Machine: Disk-backed single source of truth with a versioned feature state machine, file locks / atomic writes, powering an auditable "init → implement → verify → commit" loop

Developer Entry Points

  • CLI Tools (agx): serve, studio, gateway, feishu, loop, project, agent, workflow, deploy, monitor, docs, mineru, sandbox, skills, hooks, config, cc-bridge, memory-graph, generate, and tools
  • Studio Server: FastAPI REST API + SSE backend wiring sessions, messages, avatars, group chat, MCP, Skills, Hooks, knowledge bases, and runtime execution
  • Embeddable SDK: Core Agent / Task / Tool / AgentExecutor plus an independent ReActAgent path that does not depend on the desktop app
  • Extension Protocols: A2A, MCP, AG-UI, OpenAPI, and remote tools

Near Desktop

  • Local-first: Electron + React + Zustand + Vite; Electron starts and manages local agx serve / agx-server over REST API + SSE
  • Multi-agent Workspace: Multi-pane chat, Meta-Agent, avatars, group chat, sub-agent status, session history, and per-pane model selection
  • Workspace and Execution: Working directories, file references, embedded terminal, Computer Use, MCP, Skills, Hooks, knowledge bases, and data sources
  • Extended Experiences: Automation, Voice Focus, Claude Code Bridge, and Feishu / personal WeChat sidecars
  • Optional Remote Mode: A single remote agx serve backend is implemented; Cluster / HA multi-replica runtime remains planned

AgenticX Enterprise

  • Enterprise Entry and Control Plane: Web Portal, Portal BFF, and Admin Console for identity, models and channels, policy, quota, audit, and operations
  • Go AI Gateway: JWT / PAT authentication, subject identity, cache, rate limiting, policy evaluation, model and channel routing, streaming response governance, audit chain, and token usage
  • Real Data Infrastructure: PostgreSQL by default, optional MySQL, Redis for cache and distributed limits, and a must-succeed append-only JSONL audit fallback
  • Runtime Boundary: The Gateway is an enterprise compliance and model relay, not the Python Agent Runtime. Enterprise Edge Agent is a non-default MVP; Cluster Runtime has not started

Security and Sandbox

  • Safety Building Blocks: Leak detection, sanitization, injection detection, policy engine, input validation, tool guardrails, approval, and audit. The Studio path combines hooks, permissions, and path protection; it does not yet route every operation through the complete SafetyLayer
  • Sandbox: Docker / Microsandbox / Subprocess / remote HTTP backends; Jupyter kernel manager, stateful code interpreter, sandbox templates, and JSONL execution audit
  • Session Persistence: Studio writes to the ~/.agenticx/sessions file tree by default, with an optional Redis session backend. The database session service is a separate SDK module, not the default Studio path

Observability & Evaluation

  • Monitoring: Complete callback system, real-time metrics, Prometheus/OpenTelemetry integration, trajectory analysis, span tree, WebSocket streaming
  • Evaluation Framework: EvalSet-based evaluation, LLM judge, composite judge, span evaluator, trajectory matcher, trace-to-evalset converter
  • Data Export: Multi-format export (JSON / CSV / Prometheus), time series analysis

Storage Layer

  • Default Persistence: The ~/.agenticx file tree stores configuration, sessions, and workspaces; SQLite powers session metadata / FTS, and Studio can optionally use Redis for sessions
  • Knowledge Base Vectors: Chroma is the default Desktop knowledge-base backend; Qdrant, Milvus, Faiss, PgVector, and others depend on optional packages and specific module wiring
  • Unified Storage Abstractions: Key-value, vector, graph, and object interfaces are available, but some third-party adapters remain placeholders or are not wired into the Studio main path

GUI Agent / Embodiment

  • Action Reflection: A/B/C result classification with heuristic and VLM reflection modes
  • Stuck Detection & Recovery: Consecutive failure detection, repeat pattern recognition, intelligent recovery strategy recommendation
  • Action Caching: Action-tree-based trajectory caching with exact and fuzzy matching (up to 9x speedup)
  • REACT Output Parsing: Standardized REACT format parsing with compact action schema
  • Device-Cloud Routing: Dynamic selection of on-device or cloud model based on task complexity and sensitivity
  • DAG Task Verification: DAG-based multi-path task verification with dual semantic dependencies
  • Human-in-the-Loop: Collector, component, and event model for human oversight

Quick Start

Installation

Option 1: Install from PyPI (Recommended)```bash

Core install (lightweight, no torch, installs in seconds)

pip install agenticx

Install optional features as needed

pip install "agenticx[memory]" # Memory: mem0, chromadb, qdrant, redis, milvus
pip install "agenticx[document]" # Document processing: PDF, Word, PPT parsing
pip install "agenticx[graph]" # Knowledge graph: networkx, neo4j, community detection
pip install "agenticx[llm]" # Extra LLMs: anthropic, ollama
pip install "agenticx[monitoring]" # Observability: prometheus, opentelemetry
pip install "agenticx[mcp]" # MCP protocol
pip install "agenticx[database]" # Database backends: postgres, SQLAlchemy
pip install "agenticx[data]" # Data analysis: pandas, scikit-learn, matplotlib
pip install "agenticx[ocr]" # OCR (pulls in torch ~2GB): easyocr
pip install "agenticx[volcengine]" # Volcengine AgentKit
pip install "agenticx[all]" # Everything


> **Tip**: The core package includes only ~27 lightweight dependencies and installs in seconds. Heavy dependencies (torch, pandas, etc.) are optional extras - install only what you need.

> **Browser automation**: To run browser-use as an MCP server from AgenticX (`mcp_connect` / `mcp_call`), see examples/browser-use-mcp.md.

> **Desktop MCP upgrades (2026-04)**: Near Settings now supports MCP brand auto-discovery (Cursor / Trae / Claude / OpenClaw / Hermes / Codex), built-in Monaco JSON editor with schema validation, and one-click install from ModelScope MCP marketplace.

#### Option 2: Install from Source (Development)```bash
# Clone repository
git clone https://github.com/DemonDamon/AgenticX.git
cd AgenticX

# Using uv (recommended, 10-100x faster than pip)
pip install uv
uv pip install -e .                  # Core install
uv pip install -e ".[memory,graph]"  # Add optional features
uv pip install -e ".[all]"           # Everything
uv pip install -e ".[dev]"           # Development tools

# Or using pip
pip install -e .
pip install -e ".[all]"

Environment Setup```bash

Set environment variables

export OPENAI_API_KEY="your-api-key"
export ANTHROPIC_API_KEY="your-api-key" # Optional


> **Complete Installation Guide**: For system dependencies (antiword, tesseract) and advanced document processing features, see INSTALL.md

### CLI Quick Start

After installation, the `agx` command-line tool is available:```bash
# View version
agx --version

# Create a new project
agx project create my-agent --template basic

# Start the API server
agx serve --port 8000

# Parse documents (PDF/PPT/Word etc.)
agx mineru parse report.pdf --output ./parsed

> Full CLI Reference: See docs/cli.md for complete command documentation.

Create Your First Agent```python

from agenticx import Agent, Task, AgentExecutor
from agenticx.llms import OpenAIProvider

Create agent

agent = Agent(
id="data-analyst",
name="Data Analyst",
role="Data Analysis Expert",
goal="Help users analyze and understand data",
organization_id="my-org"
)

Create task

task = Task(
id="analysis-task",
description="Analyze sales data trends",
expected_output="Detailed analysis report"
)

Configure LLM

llm = OpenAIProvider(model="gpt-4")

Execute task

executor = AgentExecutor(agent=agent, llm=llm)
result = executor.run(task)
print(result)


### Tool Usage Example```python
from agenticx.tools import tool

@tool
def calculate_sum(x: int, y: int) -> int:
    """Calculate the sum of two numbers"""
    return x + y

@tool
def search_web(query: str) -> str:
    """Search web information"""
    return f"Search results: {query}"

# Agents will automatically invoke these tools

Complete Examples

We provide rich examples demonstrating various framework capabilities:

Agent Core (M5)

Single Agent Example```bash

Basic agent usage

python examples/m5_agent_demo.py

- Demonstrates basic agent creation and execution
- Tool invocation and error handling
- Event-driven execution flow

**Multi-Agent Collaboration**```bash
# Multi-agent collaboration example
python examples/m5_multi_agent_demo.py
  • Multi-agent collaboration patterns
  • Task distribution and result aggregation
  • Inter-agent communication

Orchestration & Validation (M6 & M7)

Simple Workflow```bash

Basic workflow orchestration

python examples/m6_m7_simple_demo.py

- Workflow creation and execution
- Task output parsing and validation
- Conditional routing and error handling

**Complex Workflow**```bash
# Complex workflow orchestration
python examples/m6_m7_comprehensive_demo.py
  • Complex workflow graph structures
  • Parallel execution and conditional branching
  • Complete lifecycle management

Agent Communication (M8)

A2A Protocol Demo```bash

Inter-agent communication protocol

python examples/m8_a2a_demo.py

- Agent-to-Agent communication protocol
- Distributed agent systems
- Service discovery and skill invocation

### Observability Monitoring (M9)

**Complete Monitoring Demo**```bash
# Observability module demo
python examples/m9_observability_demo.py
  • Real-time performance monitoring
  • Execution trajectory analysis
  • Failure analysis and recovery recommendations
  • Data export and report generation

Memory System

Basic Memory Usage```bash

Memory system example

python examples/memory_example.py

- Long-term memory storage and retrieval
- Context memory management

**Healthcare Scenario**```bash
# Healthcare memory scenario
python examples/mem0_healthcare_example.py
  • Medical knowledge memory and application
  • Personalized patient information management

Human-in-the-Loop

Human Intervention Flow```bash

Human-in-the-loop example

python examples/human_in_the_loop_example.py

- Human approval workflows
- Human-machine collaboration patterns
- Risk control mechanisms

Detailed documentation: examples/README_HITL.md

### LLM Integration

**Chatbot**```bash
# LLM chat example
python examples/llm_chat_example.py
  • Multi-model support demonstration
  • Streaming response handling
  • Cost control and monitoring

Security Sandbox

Code Execution Sandbox```bash

Micro-sandbox example

python examples/microsandbox_example.py

- Secure code execution environment
- Resource limits and isolation

Technical blog: examples/microsandbox_blog.md

### Intent Recognition Service

**Intelligent Intent Recognition System**```bash
# Intent recognition service example
python examples/agenticx-for-intent-recognition/main.py

A production-grade, layered intent recognition service built entirely on the AgenticX framework, demonstrating real-world usage of Agents, Workflows, Tools, and Storage systems.

Architecture:
- Agent Layer: Hierarchical agent design — a base IntentRecognitionAgent (LLM-powered) with specialized agents (GeneralIntentAgent, SearchIntentAgent, FunctionIntentAgent) for fine-grained classification
- Workflow Engine: Pipeline-based orchestration — preprocessing → intent classification → entity extraction → rule matching → post-processing; plus dedicated workflows for each intent type
- Tool System: Hybrid entity extraction (UIE + LLM + Rule extractors with confidence-weighted fusion), regex/full-text matching, and a full post-processing suite (confidence adjustment, conflict resolution, entity optimization, intent refinement)
- API Gateway: Async service layer with rate limiting, concurrent control, batch processing, health checks, and performance metrics
- Storage: SQLite-backed data persistence for training data management via UnifiedStorageManager
- Data Models: Pydantic-based type-safe data contracts for API requests/responses and domain objects

Key capabilities:
- Three-tier Intent Classification: General dialogue (greetings, chitchat), information search (factual/how-to/comparison queries), and function/tool invocation
- Hybrid Entity Extraction: Combines UIE models, LLM, and rule-based extractors with intelligent fusion strategies
- Full Post-processing Pipeline: Confidence adjustment, conflict resolution, entity optimization, and intent refinement
- Extensible Design: Add new intent types by simply creating a new agent and workflow — zero changes to existing code

See: examples/agenticx-for-intent-recognition/

GUI Agent / Embodiment (M16)

GUI Automation Agent```bash

GUI Agent example

python examples/agenticx-for-guiagent/AgenticX-GUIAgent/main.py

- Complete GUI automation framework with human-aligned learning
- Action reflection (A/B/C classification) and stuck detection
- Action caching system for performance optimization
- REACT output parsing and compact action schema
- Device-Cloud routing for intelligent model selection
- DAG-based task verification

Key capabilities:
- **Action Reflection**: Automatic action result classification (success/wrong_state/no_change)
- **Stuck Detection**: Continuous failure detection and recovery strategy recommendation
- **Action Caching**: Trajectory caching with exact and fuzzy matching (up to 9x speedup)
- **REACT Parsing**: Standardized REACT format output parsing
- **Smart Routing**: Dynamic device-cloud model selection based on task complexity and sensitivity
- **DAG Verification**: Multi-path task verification with dual-semantic dependencies

See: examples/agenticx-for-guiagent/

### Data Suite

End-to-end **enterprise data** demos on top of A1–A8 (channels → OneID → governance → tags → boards → masking → patrol) plus a desensitized **B-layer delivery pack** skeleton.```bash
# Golden path (one command): FakeChannel → job → OneID → gov/tags → board → mask → patrol
python examples/data_suite/golden_path/run_golden_path.py

# Apply synthetic Brand-A / Market-X delivery pack (template for a separate customer B repo)
python examples/data_suite/delivery_pack/apply.py
Path What it is
examples/data_suite/golden_path/ Productized A-layer spine demo + README
examples/data_suite/delivery_pack/ B1–B6 config skeleton (register_pack); copy to a separate B repo for real projects

See also: docs/agx-data-suite/ (ops notes / Feishu manual links).

More Application Examples

Project Description Path
Data Suite Golden-path spine + delivery pack skeleton for enterprise data governance examples/data_suite/
Agent Skills Skill discovery, matching, and SOP-driven skill execution for agents examples/agenticx-for-agent-skills/
AgentKit Volcengine AgentKit integration with Docker-ready agent deployment examples/agenticx-for-agentkit/
ChatBI Conversational BI — natural language to data insights examples/agenticx-for-chatbi/
Deep Research Multi-source deep research and report generation examples/agenticx-for-deepresearch/
Doc Parser Intelligent document parsing (PDF, Word, PPT) examples/agenticx-for-docparser/
Finance Financial news hunting and analysis examples/agenticx-for-finance/
Future Prediction Predictive analysis and forecasting examples/agenticx-for-future-prediction/
GraphRAG Knowledge graph-enhanced retrieval-augmented generation examples/agenticx-for-graphrag/
Math Modeling Mathematical modeling assistant examples/agenticx-for-math-modeling/
Model Architecture Discovery Automated model architecture search and discovery examples/agenticx-for-modelarch-discovery/
Query Optimizer SQL/query optimization agent examples/agenticx-for-queryoptimizer/
Sandbox Secure code execution sandbox examples/agenticx-for-sandbox/
Spec Coding Specification-driven code generation examples/agenticx-for-spec-coding/
Vibe Coding AI-assisted creative/vibe coding examples/agenticx-for-vibecoding/

Development Progress

✅ Completed Modules (M1-M11, M13-M17)

Module Status Description
M1 ✅ Core Abstraction Layer — Agent, Task, Tool, Workflow, Event Bus, Component, and Pydantic data contracts
M2 ✅ LLM Service Layer — 15+ providers (OpenAI / Anthropic / Ollama / Gemini / Kimi / MiniMax / Ark / Zhipu / Qianfan / Bailian), response caching, failover routing
M3 ✅ Tool System — Function decorators, MCP Hub, remote tools v2, OpenAPI toolset, sandbox tools, skill bundles, document routers
M4 ✅ Memory System — Hierarchical (core / episodic / semantic), Mem0, workspace, short-term, memory decay, hybrid search, memory intelligence engine
M5 ✅ Agent Core — Meta-Agent CEO dispatcher, think-act loop, event-driven architecture, self-repair, overflow recovery, reflection
M6 ✅ Task Validation — Pydantic-based output parsing, auto-repair, guiderails
M7 ✅ Orchestration Engine — Graph-based workflow engine + Flow system with decorators, execution plans, conditional routing, parallel execution
M8 ✅ Communication Protocols — A2A (client / server / AgentCard / skill-as-tool), MCP resource access, AGUI protocol
M9 ✅ Observability — Callbacks, real-time monitoring, trajectory analysis, span tree, WebSocket streaming, Prometheus / OpenTelemetry integration
M10 ✅ Developer Experience — CLI (agx with 20+ commands), Studio Server (FastAPI REST + SSE), Near Desktop (Electron + React + Zustand, multi-pane)
M11 ✅ Safety building blocks — Leak detection, sanitization, injection detection, policy, guardrails, hooks, approval, and multi-backend sandbox; Studio does not yet use one complete SafetyLayer pipeline
M13 ✅ Knowledge & Retrieval — Knowledge base with document processing, chunkers, graphers (GraphRAG), readers; retrieval (vector / BM25 / graph / hybrid / auto); embeddings (OpenAI / Bailian / SiliconFlow / LiteLLM)
M14 ✅ Avatar & Collaboration — Avatar registry, group chat (user-directed / meta-routed / round-robin), delegation, role-playing, conversation patterns, team management
M15 ✅ Evaluation Framework — EvalSet, LLM judge, composite judge, span evaluator, trajectory matcher, trace converter
M16 ✅ Embodiment — GUI Agent framework with action reflection, stuck detection, action caching, REACT parsing, device-cloud routing, DAG verification, human-in-the-loop
M17 ✅ Storage abstractions and primary adapters — Default file / SQLite, optional Redis, Chroma knowledge base, and multiple vector / graph / object interfaces; some third-party adapters remain placeholders

🚧 Planned Modules

Module Status Description
M12 🚧 Agent Evolution — Architecture search, knowledge distillation, adaptive planning
M18 🚧 Core / Studio multi-tenancy and RBAC — Fine-grained tenant_id isolation is not wired into the Studio main path; Enterprise IAM is implemented on a separate product line

🆕 v0.5.0 Capability Snapshot

Capability Status Description
Skill Self-Evolution ✅ Runtime tool-call observation capture, auto-skill creation via session review, quality gate / usage stats / deprecation loop (learning)
Multi-Brain Knowledge ✅ Isolatable/mountable "doc brain + code brain" with cross-brain search (brain) + multi-codebase hybrid semantic index (code_index)
Long-Horizon Coding ✅ Long-run orchestration (multi-source / isolated workspaces / stall self-healing / continuation backoff, longrun) + disk-backed project state machine (project_state)
IM Channel Integration ✅ Remote command gateway for Feishu / WeCom / DingTalk / personal WeChat (iLink) (gateway)
Claude Code Bridge ✅ Token-protected local HTTP/NDJSON control plane, headless / visible TUI dual mode (cc_bridge)
Extension Ecosystem ✅ AGX Bundle definitions, local install/uninstall, multi-source registry aggregated search (extensions)
Embeddable ReActAgent ✅ Canonical async function-calling ReAct SDK primitive with typed event stream, multi-turn history, parallel tools, optional loop-detector / compactor / offloader, zero Studio/CLI coupling (agents)
Unified Offload & MCP Gateway ✅ Offloader protocol + FileOffloader for out-of-history large payloads, plus in-workspace MCP gateway (AgentScope v2 P0 internalization, core.offload / sandbox.mcp_gateway)

Core Advantages

  • Unified Abstraction: Clear and consistent core abstractions, avoiding conceptual confusion
  • Pluggable Architecture: All components are replaceable, avoiding vendor lock-in
  • Enterprise-Grade Monitoring: Complete observability, production-ready
  • Security First: Built-in security mechanisms and multi-tenant support
  • High Performance: Optimized execution engine and concurrent processing
  • Rich Ecosystem: Complete toolset and example library

System Requirements

  • Python: 3.10+
  • Memory: 4GB+ RAM recommended
  • System: Windows / Linux / macOS
  • Core Dependencies: ~27 lightweight packages, installs in seconds (see pyproject.toml)
  • Optional Dependencies: 15 feature groups available via pip install "agenticx[xxx]"

Contributing

We welcome community contributions! Please read CONTRIBUTING.md (中文:CONTRIBUTING_ZN.md) before opening a PR. In short:

  1. Submit Issues to report bugs or request features
  2. Fork the project and create a scoped feature branch (feat/ / fix/ / …)
  3. Submit Pull Requests with Conventional Commits; run the relevant tests (and Desktop npm run build when UI changes)
  4. Participate in code reviews and discussions

Acknowledgements / Upstream Credits

The personal WeChat (iLink) channel integration in AgenticX was built on top of the openilink-sdk-go library from OpeniLink Hub. We specifically relied on:

  • QR code binding flow — FetchQRCode / PollQRStatus APIs for the scan-to-bind UX
  • Message monitoring — client.Monitor() for real-time inbound message streaming
  • Outbound messaging — SendText / Push for reply delivery with context_token routing
  • CDN media handling — DownloadMedia / DownloadVoice for encrypted WeChat media

OpeniLink Hub's OpenClaw App also demonstrated an AI Agent gateway integration pattern that informed our adapter architecture.

We did not include OpeniLink Hub's web console, App Marketplace, or multi-bot management features. AgenticX's core multi-agent runtime, session management, and Desktop UI remain fully independent implementations.

> OpeniLink Hub — MIT License — github.com/openilink/openilink-hub

Additional reference: WorkBuddy — WeixinBot Guide for iLink protocol usage patterns.

Desktop development: The iLink Go sidecar binary is not committed to this repository. Before using the personal WeChat bridge locally, run make build in packaging/wechat-sidecar/ (requires Go 1.22+). See packaging/wechat-sidecar/README.md.

Citation

If you use AgenticX in your research, please cite:bibtex @software{agenticx2026, author = {{AgenticX Team}}, title = {AgenticX: Unified Multi-Agent Framework}, year = {2026}, url = {https://github.com/DemonDamon/AgenticX}, license = {Apache-2.0} }

License

…(正文过长,页面只展示前面部分,完整内容见仓库)

常见问题

8 问
答案由本站依据条目字段整理,不引用上游原文
AgenticX 怎么安装?

在客户端按下面的安装命令接入:pip install agenticx。对应的包名是 agenticx。装完在客户端配置里引用同一个包或端点。

AgenticX 怎么在 Claude Desktop、Cursor、Cline 里配置?

它的传输方式是stdio · 本地进程,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

AgenticX 收费吗?

本站不代收费用,也没有标注具体价格。是否收费取决于服务本身和背后的接口额度,正式使用前按官方说明确认。

AgenticX 需要 API Key 吗?

资料没有标注鉴权方式,是否需要密钥取决于服务本身,接入前按官方文档确认。

AgenticX 支持哪些客户端?

资料标注支持 Claude Desktop、Cursor、Cline、Claude Code;其他客户端只要能配置 MCP Server,也能用同样的命令或地址接入。

AgenticX 能提供哪些能力?

资料显示能力标签包括 agent-framework、agentic-workflows、ai-agent、ai-orchestration、chatbot。具体工具清单以官方文档为准。

AgenticX 需要什么运行环境?

运行时为 Cross-platform;属于本地进程,需要在本机装好运行环境。

AgenticX 是本地还是远程?

它是本地进程(stdio),由客户端在本机拉起。传输方式为stdio · 本地进程。

热门专题

按标签挑服务器
全部专题 →

服务器信息以作者仓库与官方文档为准;分类、传输方式与鉴权方式的中文说明为中文整理,最近核验 2026-04-20。