AgentScope

Implements ReActAgent as a core abstraction that orchestrates reasoning, acting, and observation loops by leveraging models' native tool-calling capabilities rather than rigid prompt engineering. The framework uses a message protocol with content blocks to represent agent state, supports middleware for tool execution pipelines, and integrates with ChatModelBase provider architecture to work across OpenAI, Anthropic, Gemini, and DashScope APIs without model-specific branching logic.

Provides MsgHub as a centralized message broker that enables agents to communicate asynchronously through publish-subscribe patterns and subscriber broadcasting. Agents register as publishers/subscribers to named topics, and MsgHub routes messages between them with support for both local in-process communication and distributed deployment via Redis backend for multi-tenancy and session state management.

Implements state serialization that enables agents to save and restore their complete state (memory, reasoning, tool results) to persistent storage, enabling recovery from failures and resumption of interrupted tasks. Checkpointing is automatic at configurable intervals or on-demand, and supports multiple storage backends (local filesystem, cloud storage). Serialized state includes agent configuration, message history, and memory snapshots.

Provides deployment patterns and utilities for running agents in production across different infrastructure models: local development, serverless (AWS Lambda, Google Cloud Functions), and Kubernetes clusters. Deployment patterns include configuration management, environment variable handling, and infrastructure-specific optimizations. The framework abstracts deployment differences, enabling the same agent code to run across environments.

Enables agents to pause execution and request human approval or input at critical decision points through an interruption mechanism. Agents can define interruption points (e.g., before executing high-risk tools), and the framework routes interruption requests to human operators who can approve, reject, or modify agent actions. Interruption state is preserved across agent steps, enabling seamless resumption after human feedback.

Provides a tuning framework that enables agents to be optimized through reinforcement learning or supervised fine-tuning based on evaluation feedback. The framework supports collecting agent trajectories (reasoning steps, tool calls, outcomes), using evaluation metrics as reward signals, and fine-tuning the underlying LLM to improve agent behavior. Fine-tuning is integrated with the model provider APIs (OpenAI, Anthropic, etc.) for seamless optimization.

Provides a hook system that enables developers to inject custom logic at key points in the agent lifecycle: before/after reasoning, before/after tool execution, on error, on completion. Hooks are registered as callbacks and executed in sequence, enabling cross-cutting concerns (logging, monitoring, validation) without modifying core agent code. Hooks have access to agent state and can modify behavior (e.g., reject tool calls, transform outputs).

Implements an Agent-to-Agent (A2A) communication protocol that enables agents to send structured messages to other agents with request-response semantics. A2A is built on top of MsgHub and provides higher-level abstractions for agent-to-agent interaction, including message routing, timeout handling, and response correlation. Agents can invoke other agents as services without direct coupling.

Provides a Toolkit core architecture that enables declarative tool registration via decorators or explicit registration, with support for tool groups, meta-tools (tools that compose other tools), and middleware that intercepts tool execution before and after invocation. Tools are registered with JSON schemas for model function-calling, and execution is routed through middleware pipelines that can validate inputs, transform outputs, or implement cross-cutting concerns like logging or rate-limiting.

Integrates the Model Context Protocol (MCP) as a first-class subsystem, enabling agents to dynamically discover and invoke tools from external MCP servers without hardcoding tool definitions. MCP tools are registered into the Toolkit system and appear to agents as native tools, with automatic schema translation and execution routing through the MCP client protocol.

Implements a working memory system that maintains agent conversation history and state, with built-in memory compression to reduce token usage for long conversations (via summarization or sliding-window strategies), and Redis backend support for distributed deployments where multiple agent instances share session state. Memory is organized by session, enabling multi-tenancy and session isolation.

Provides pluggable long-term memory backends (Mem0 and ReME) that enable agents to store and retrieve persistent knowledge across sessions. Long-term memory is separate from working memory, allowing agents to accumulate insights over time and retrieve relevant past interactions. Integration is abstracted via a memory interface, enabling different backends without agent code changes.

Implements a RAG (Retrieval-Augmented Generation) system that enables agents to retrieve relevant documents from vector stores before generating responses. The system supports multiple vector store backends (Chroma, Pinecone, Weaviate, etc.) with automatic embedding generation, and provides semantic search capabilities to find relevant context for agent reasoning. RAG is integrated into the agent pipeline, allowing agents to augment prompts with retrieved documents.

Provides native support for multimodal agents that can process and generate text, images, audio, and video through a unified content block message protocol. Agents can invoke Realtime Voice APIs for streaming audio input/output and TTS models for text-to-speech synthesis. Content blocks are serialized into the message protocol, enabling seamless multimodal reasoning across different modalities without modality-specific branching logic.

Integrates OpenTelemetry as the observability backbone, providing automatic tracing of agent execution, tool calls, and model invocations through decorators and middleware. Traces are exported to OpenTelemetry-compatible backends (Jaeger, Datadog, etc.), enabling distributed tracing across multi-agent systems. Built-in metrics track agent performance, token usage, and error rates without manual instrumentation.

Provides an evaluation framework that enables systematic assessment of agent outputs using metrics and judges. Integration with OpenJudge enables LLM-based evaluation (e.g., comparing agent responses to ground truth), and the framework supports custom evaluators and metrics. Evaluations can be run on agent outputs to measure quality, correctness, and alignment without manual review.