[opensourcedex]

agentscope is a free, open source ai interaction & interfaces project written in Python and released under Apache-2.0. It has 35,223 GitHub stars, 3,774 forks and 369 open issues, and was last pushed 14 hours ago. On this registry it ranks #21 of 156 tracked projects in AI Interaction & Interfaces, with 5 head-to-head comparisons available. It gained 2,596 stars over the last 30 tracked days.

What is agentscope?

What it is

AgentScope 2.0 is a production-ready agent framework written in Python and released under the Apache-2.0 licence. It provides a set of essential abstractions for building agents, and it is designed explicitly for increasingly agentic large language models. Rather than wrapping models in strict prompts and opinionated orchestrations, the framework leans on the reasoning and tool use abilities the models already have, so the agent logic follows rising model capability instead of fighting it. The project lives in the Python AI and machine learning ecosystem, with a documented homepage at docs.agentscope.io and a repository that has accumulated 31,686 stars and 3,508 forks over roughly three years.

The concrete problem it solves is the gap between a raw model API and a working agent that can be inspected, debugged and deployed. AgentScope supplies the SDK layer for composing agents out of building blocks: a ReAct reasoning-acting loop with structured output, realtime interruption and resume, and batched sequential or concurrent tool acting; a Toolkit that manages Python tools, MCP servers and skills, including built-in coding tools for shell access, file editing and search plus task and planning tools; and a Model layer spanning LLM, embedding and text-to-speech providers such as OpenAI, Anthropic and Gemini. On top of that layer it addresses the deployment side through channels, pipelines, a terminal console and protocol bridges, so an agent can move from a local script to a service reachable from group chat platforms.

Key capabilities

  • ReAct agent loop with structured output, realtime interruption and resume, and batched tool acting run either sequentially or concurrently.
  • Toolkit for agentic tool management over Python tools, MCP servers and skills, shipping built-in coding tools (shell, file edit, search) and task/plan tools.
  • Model abstraction covering LLM, embedding and TTS across major providers including OpenAI, Anthropic and Gemini.
  • RealtimeAgent with support for DashScope, OpenAI, Gemini and xAI realtime APIs, and an experimental realtime voice agent.
  • A2A protocol support through A2AAgent, which allows chatting with any remote A2A agent.
  • Pipeline building block that runs multiple agents under a fixed logic behind one event stream.
  • Channels that connect agents to IM platforms, with DingTalk, Feishu (Lark) and Discord integrations, plus GitHub MCP Registry and ClawHub as built-in hubs.

Who uses it and how

  • Developers prototyping agents locally use the console building block to test and debug agents directly in the terminal.
  • Teams building multi-agent systems compose several agents into a pipeline so a fixed orchestration logic emits a single event stream.
  • Teams wiring agents into workplace chat deploy the agent service and attach channels such as DingTalk, Feishu or Discord.
  • Builders of voice interfaces adopt RealtimeAgent against a supported realtime API for speech-to-speech interaction.
  • Integ
project readme (upstream, from github) — read inline

AgentScope Logo

中文主页 | Documentation | Roadmap

arxiv pypi pypi discord docs license Ask DeepWiki

agentscope-ai%2Fagentscope | Trendshift

What is AgentScope 2.0?

AgentScope 2.0 is a production-ready, easy-to-use agent framework with essential abstractions that keep up with rising model capability.

We design for increasingly agentic LLMs. Our approach leverages the models' reasoning and tool use abilities rather than constraining them with strict prompts and opinionated orchestrations.

News

  • [2026-09] FEAT: agentscope-skill now supports AgentScope v2.
  • [2026-09] INTE: Support DashScope, OpenAI, Gemini and xAI realtime APIs in RealtimeAgent. Example | Docs
  • [2026-09] FEAT Experimental: Realtime voice agent supported. Example | Docs
  • [2026-09] FEAT: A2A protocol supported — chat with any remote A2A agent via A2AAgent. Example | Docs
  • [2026-08] FEAT: Pipeline supported — run multiple agents by a fixed logic behind one event stream. Example | Docs
  • [2026-08] INTE: DingTalk channel supported. Docs
  • [2026-08] FEAT: Console supported — test and debug agents in the terminal. Example | Docs
  • [2026-08] INTE: Feishu (Lark) and Discord channels supported. Feishu | Discord
  • [2026-08] FEAT: Channels supported — connect agents to IM platforms in agent service. Example | Docs
  • [2026-08] INTE: GitHub MCP Registry and ClawHub supported as built-in hubs. Example | Docs

More news →

Community

Welcome to join our community on

Discord DingTalk

Quickstart

Installation

AgentScope requires Python 3.11 or higher.

From PyPI
uv pip install agentscope
From source
# Pull the source code from GitHub
git clone -b main https://github.com/agentscope-ai/agentscope.git

# Install the package in editable mode
cd agentscope

uv pip install -e .

Agent

The SDK layer — compose an agent from a rich set of building blocks:

Building block What's inside
ReAct Reasoning-acting loop with structured output, realtime interruption & resume, and batched (sequential / concurrent) tool acting
Toolkit Agentic tool management over Python tools, MCP servers, and skills; ships with built-in coding tools (shell, file edit, search) and task/plan tools
Model LLM, embedding, and TTS across major providers (OpenAI, Anthropic, Gemini, DashScope, DeepSeek, Moonshot, Volcengine, xAI, Ollama)
Context Automatic compaction, tool-result offload, and context injection (system prompt, RAG, memory) via built-in middleware
Event System Unified event bus streaming reasoning, tool calls, and multimodal content (text, image, audio) to the frontend
Permission & HITL Fine-grained control over tools and resources, confirmation, bypass mode
Middleware Composable hooks across the loop — reply, reasoning, acting, model calling, permission checking, context compression, system prompt
Memory Agentic memory with switchable backends (ReMe, Mem0)
Workspace / Sandbox Isolated tool & code execution — local, Docker, Apple Container, Bubblewrap, E2B, OpenSandbox, Daytona, K8s

Start your first agent with AgentScope 2.0 in console:

from agentscope.agent import Agent
from agentscope.console import launch_console
from agentscope.tool import Toolkit, Bash, Grep, Glob, Read, Write, Edit
from agentscope.credential import DashScopeCredential
from agentscope.model import DashScopeChatModel

import os, asyncio


async def main() -> None:
    agent = Agent(
        name="Friday",
        system_prompt="You're a helpful assistant named Friday.",
        model=DashScopeChatModel(
            credential=DashScopeCredential(
              api_key=os.environ["DASHSCOPE_API_KEY"]
            ),
            model="qwen3.6-plus",
        ),
        toolkit=Toolkit(
            tools=[
                Bash(),
                Grep(),
                Glob(),
                Read(),
                Write(),
                Edit(),
            ]
        ),
    )

    # Chat with the agent in the terminal — streamed output, tool-call
    # confirmation and Ctrl+C interruption are all handled for you
    await launch_console(agent)

asyncio.run(main())

Agent Service — All You Need to Build Your App

AgentScope ships a batteries-included agent service — a FastAPI backend with a pre-built Web UI (examples/web_ui) that turns your agents into a multi-tenant, multi-session application, with rich capabilities out of the box:

Capability What you get
Serving Multi-tenancy, multi-session isolation, FastAPI backend, pre-built Web UI
Agent Team Leader–worker orchestration, built-in team tools, task planning
Channels Connect agents to IM platforms — Feishu (Lark), Discord, custom channels, message routing
RAG Service Blob storage, index worker, multi-tenant retrieval
MCP & Skill Hub Browse hubs (GitHub MCP Registry, ClawHub), install into your library, add to a workspace
Resource Sharing Group- and org-level management for sharing models, MCP servers, skills, and workspaces
Persistence SQL & NoSQL persistence of agent state and sessions
Scheduling Scheduled tasks, agent wakeup, background task offloading

Everything above is composable, so you can assemble your own application on top of the service with minimal glue code.


Agent team — a leader agent spawns workers and coordinates them through the built-in team tools.

Task planning — the agent breaks complex work into a tracked plan and updates it as it goes.

Permission control in bypass mode — the agent runs end-to-end without pausing for tool-call confirmations.

Background task offloading — a long-running tool moves to the background; its result later wakes the agent up and the conversation resumes.

Run the following commands to start the agent service backend and the web UI:

git clone -b main https://github.com/agentscope-ai/agentscope.git
cd agentscope/examples/agent_service

# start the agent service backend
python main.py

Then open another terminal to start the web UI:

cd agentscope/examples/web_ui

# start the webui
pnpm install
pnpm dev

Contributing

We welcome contributions from the community! Please refer to our CONTRIBUTING.md for guidelines on how to contribute.

License

AgentScope is released under Apache License 2.0.

Publications

If you find our work helpful for your research or application, please cite our papers.

@article{agentscope_v1,
    author  = {Dawei Gao, Zitao Li, Yuexiang Xie, Weirui Kuang, Liuyi Yao, Bingchen Qian, Zhijian Ma, Yue Cui, Haohao Luo, Shen Li, Lu Yi, Yi Yu, Shiqi He, Zhiling Luo, Wenmeng Zhou, Zhicheng Zhang, Xuguang He, Ziqian Chen, Weikai Liao, Farruh Isakulovich Kushnazarov, Yaliang Li, Bolin Ding, Jingren Zhou}
    title   = {AgentScope 1.0: A Developer-Centric Framework for Building Agentic Applications},
    journal = {CoRR},
    volume  = {abs/2508.16279},
    year    = {2025},
}

@article{agentscope,
    author  = {Dawei Gao, Zitao Li, Xuchen Pan, Weirui Kuang, Zhijian Ma, Bingchen Qian, Fei Wei, Wenhao Zhang, Yuexiang Xie, Daoyuan Chen, Liuyi Yao, Hongyi Peng, Zeyu Zhang, Lin Zhu, Chen Cheng, Hongzhu Shi, Yaliang Li, Bolin Ding, Jingren Zhou}
    title   = {AgentScope: A Flexible yet Robust Multi-Agent Platform},
    journal = {CoRR},
    volume  = {abs/2402.14034},
    year    = {2024},
}

Contributors

All thanks to our contributors:

Frequently asked questions

Is agentscope free to use?

agentscope is open source under the Apache-2.0 licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does agentscope do?

Build and run agents you can see, understand and trust.

What is agentscope written in?

agentscope is primarily written in Python. Its source is publicly available at https://github.com/agentscope-ai/agentscope, and it has 35,223 GitHub stars.