{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-agentscope-ai--agentscope","slug":"agentscope-ai--agentscope","name":"agentscope","type":"agent","url":"https://docs.agentscope.io/","page_url":"https://unfragile.ai/agentscope-ai--agentscope","categories":["ai-agents"],"tags":["agent","chatbot","large-language-models","llm","llm-agent","mcp","multi-agent","multi-modal","react-agent"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-agentscope-ai--agentscope__cap_0","uri":"capability://planning.reasoning.react.reasoning.acting.loop.with.pluggable.model.backends","name":"react reasoning-acting loop with pluggable model backends","description":"Implements a closed-loop reasoning-acting pattern where the LLM decides on tool calls, a Toolkit executes them, and results are integrated back into working memory for the next reasoning step. The architecture composes pluggable Model (OpenAI, Anthropic, Gemini, DashScope, Ollama), Formatter (provider-specific API payload conversion), Memory (working + optional long-term), and Toolkit components, enabling flexible agent behavior without strict prompt constraints.","intents":["Build an agent that reasons about tasks and calls tools iteratively without hardcoded orchestration","Swap between different LLM providers (OpenAI, Anthropic, Ollama) without rewriting agent logic","Integrate both local functions and MCP-based external tools into a single reasoning loop"],"best_for":["Teams building production agents that need to support multiple LLM providers","Developers who want flexible agent composition without opinionated orchestration patterns","Organizations deploying agents locally, serverless, or on Kubernetes"],"limitations":["ReActAgent is the primary implementation; custom agent types require extending AgentBase","Reasoning quality depends entirely on underlying LLM capability; no built-in prompt optimization beyond Formatter abstraction","Multi-turn reasoning can accumulate token costs; long-term memory integration required for extended conversations"],"requires":["Python 3.9+","API key for at least one supported model provider (OpenAI, Anthropic, Gemini, DashScope, or local Ollama instance)","agentscope package installed (pip install agentscope)"],"input_types":["natural language queries","structured task descriptions","message history (Msg objects with content blocks)"],"output_types":["agent decisions (tool calls with parameters)","tool execution results","final reasoning outputs","message history with reasoning trace"],"categories":["planning-reasoning","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-agentscope-ai--agentscope__cap_1","uri":"capability://automation.workflow.multi.agent.orchestration.via.msghub.with.pipeline.patterns","name":"multi-agent orchestration via msghub with pipeline patterns","description":"Manages message broadcasting and coordination between multiple agents through a MsgHub component that automatically routes messages to enrolled participants. Supports predefined pipeline patterns (sequential_pipeline, fanout_pipeline) for complex multi-agent workflows where agents communicate asynchronously and decisions flow through the system. Built on top of the Msg abstraction, enabling agents to exchange structured messages with content blocks.","intents":["Coordinate multiple specialized agents (e.g., researcher, analyzer, writer) in a sequential workflow","Broadcast a task to multiple agents in parallel and aggregate their responses","Build hierarchical agent systems where agents can delegate to other agents"],"best_for":["Teams building complex multi-agent systems with clear communication patterns","Applications requiring agent specialization (e.g., one agent for research, one for analysis)","Workflows where agents need to see each other's outputs and respond accordingly"],"limitations":["MsgHub is synchronous; no built-in async/await support for concurrent agent execution","Pipeline patterns are predefined (sequential, fanout); custom orchestration requires manual MsgHub management","No built-in deadlock detection or timeout handling for circular agent dependencies","Message routing is broadcast-based; no selective message filtering or routing rules"],"requires":["Python 3.9+","Multiple agent instances (each with their own Model, Memory, Toolkit)","agentscope package with multi-agent support"],"input_types":["Msg objects (agent messages with content blocks)","pipeline configuration (sequential or fanout)","agent enrollment list"],"output_types":["message history across all agents","final outputs from each agent","execution trace showing message flow"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-agentscope-ai--agentscope__cap_10","uri":"capability://planning.reasoning.model.fine.tuning.and.optimization.with.rl.and.prompt.tuning","name":"model fine-tuning and optimization with rl and prompt tuning","description":"Supports model optimization through reinforcement learning (RL)-based fine-tuning and prompt tuning. RL fine-tuning allows agents to optimize their behavior based on reward signals, improving decision-making over time. Prompt tuning optimizes prompt templates without modifying model weights. Model selection capabilities enable choosing the best model for specific tasks based on performance metrics.","intents":["Improve agent performance over time through reinforcement learning","Optimize prompts for specific tasks without fine-tuning models","Select the best model for a task based on performance and cost tradeoffs"],"best_for":["Teams with resources for RL training pipelines","Applications where agent performance is critical","Organizations optimizing for cost and latency"],"limitations":["RL fine-tuning requires reward signal definition; no automatic reward inference","RL training is computationally expensive; requires significant infrastructure","Prompt tuning results are task-specific; limited generalization","Model selection requires baseline performance data; cold-start problem for new tasks"],"requires":["Python 3.9+","agentscope package","RL training infrastructure (for RL fine-tuning)","Reward function definition","Baseline performance metrics"],"input_types":["agent trajectories (for RL)","reward signals","prompt templates","performance metrics"],"output_types":["fine-tuned models","optimized prompts","model selection recommendations","performance improvements"],"categories":["planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-agentscope-ai--agentscope__cap_11","uri":"capability://text.generation.language.realtime.voice.agent.support.with.text.to.speech.and.audio.streaming","name":"realtime voice agent support with text-to-speech and audio streaming","description":"Provides realtime voice agent capabilities through integration with text-to-speech (TTS) models and audio streaming. Agents can process audio input, reason about it, and generate spoken responses in real-time. The architecture supports streaming audio for low-latency interactions and integrates with realtime model backends that support audio I/O natively.","intents":["Build voice-based agents that can have natural conversations","Create interactive voice assistants with low-latency responses","Process audio input and generate spoken output in real-time"],"best_for":["Teams building voice assistants or conversational AI","Applications requiring natural voice interaction","Developers creating realtime agent experiences"],"limitations":["Realtime audio processing adds latency; network delays impact user experience","TTS quality varies by provider; some providers have limited voice options","Audio streaming requires careful buffer management; underflow/overflow can cause glitches","Realtime models are limited; not all providers support audio I/O"],"requires":["Python 3.9+","agentscope package with realtime support","TTS model (OpenAI, Google, etc.)","Realtime model backend (if using native audio support)","Audio I/O hardware and libraries"],"input_types":["audio streams (WAV, MP3, etc.)","audio samples (raw PCM)","text prompts"],"output_types":["audio streams (TTS output)","transcribed text","agent responses"],"categories":["text-generation-language","image-visual"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-agentscope-ai--agentscope__cap_12","uri":"capability://planning.reasoning.evaluation.framework.for.agent.performance.assessment","name":"evaluation framework for agent performance assessment","description":"Provides an evaluation framework for assessing agent performance across multiple dimensions (accuracy, efficiency, safety, user satisfaction). Evaluators can be custom-defined or use built-in metrics. The framework supports batch evaluation of agent trajectories, enabling systematic performance comparison across different agent configurations, models, or strategies.","intents":["Measure agent accuracy and effectiveness on benchmark tasks","Compare performance across different models or agent configurations","Identify failure modes and edge cases in agent behavior"],"best_for":["Teams iterating on agent design and wanting quantitative feedback","Organizations requiring performance baselines before production deployment","Researchers benchmarking agent approaches"],"limitations":["Evaluation metrics are task-specific; no universal agent quality metric","Batch evaluation requires collecting agent trajectories; adds overhead","Custom evaluators require domain expertise; no automatic metric inference","Evaluation results may not correlate with real-world performance"],"requires":["Python 3.9+","agentscope package","Benchmark datasets or test cases","Evaluation metric definitions"],"input_types":["agent trajectories","expected outputs","evaluation metrics"],"output_types":["performance scores","metric breakdowns","comparison reports"],"categories":["planning-reasoning","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-agentscope-ai--agentscope__cap_13","uri":"capability://planning.reasoning.planning.with.plannotebook.for.structured.task.decomposition","name":"planning with plannotebook for structured task decomposition","description":"Provides a PlanNotebook abstraction for structured task planning and decomposition. Agents can break down complex tasks into subtasks, track progress, and reason about dependencies. PlanNotebook integrates with the agent's memory and reasoning loop, enabling agents to maintain and update plans as they execute tasks.","intents":["Break down complex tasks into manageable subtasks","Track task progress and dependencies","Enable agents to reason about task structure and adjust plans dynamically"],"best_for":["Applications with complex, multi-step tasks","Teams building planning-focused agents","Systems requiring transparent task decomposition"],"limitations":["Plan quality depends on agent reasoning; no automatic plan optimization","Plan updates are manual; no automatic replanning on task failure","PlanNotebook integration requires explicit agent implementation","No built-in plan validation or feasibility checking"],"requires":["Python 3.9+","agentscope package","Agent implementation using PlanNotebook"],"input_types":["task descriptions","task constraints","subtask definitions"],"output_types":["task plans","progress tracking","plan updates"],"categories":["planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-agentscope-ai--agentscope__cap_2","uri":"capability://tool.use.integration.mcp.model.context.protocol.tool.integration.with.stateless.and.stateful.clients","name":"mcp (model context protocol) tool integration with stateless and stateful clients","description":"Provides native integration for the Model Context Protocol, allowing agents to discover and invoke standardized external tools through HttpStatelessClient (for stateless tool calls) or StatefulClientBase (for tools requiring session state). The Toolkit component manages both local functions and MCP-based tools, exposing them to the ReActAgent through a unified interface. Formatters handle conversion of tool schemas into provider-specific function-calling formats.","intents":["Connect agents to external tool ecosystems (e.g., Claude's MCP servers) without custom integration code","Use stateful tools that require session management (e.g., browser automation, database connections)","Discover tool capabilities dynamically from MCP servers and expose them to agents"],"best_for":["Teams integrating with MCP-compatible tool servers (Anthropic ecosystem, community tools)","Applications requiring external tool access without building custom API wrappers","Developers building tool servers that need to work with multiple agent frameworks"],"limitations":["MCP integration requires tools to implement the MCP protocol; legacy tools need wrapping","HttpStatelessClient adds network latency per tool call; no built-in caching or batching","StatefulClientBase requires managing session lifecycle; no automatic cleanup on agent shutdown","Tool discovery is dynamic but schema validation is delegated to the Formatter; malformed schemas may cause runtime errors"],"requires":["Python 3.9+","MCP server instance running (local or remote)","agentscope with MCP support (pip install agentscope[mcp])","Network connectivity to MCP server (for HttpStatelessClient)"],"input_types":["MCP server URI (http://localhost:3000)","tool schemas (JSON)","tool invocation parameters"],"output_types":["tool execution results","tool schema definitions","error messages from MCP server"],"categories":["tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-agentscope-ai--agentscope__cap_3","uri":"capability://tool.use.integration.agent.to.agent.a2a.protocol.communication.for.cross.system.agent.networks","name":"agent-to-agent (a2a) protocol communication for cross-system agent networks","description":"Enables AgentScope agents to communicate with external agent systems across the network using the A2A protocol, allowing agents to discover, invoke, and coordinate with agents outside their local system. Agents can send messages to remote agents and receive responses, facilitating distributed multi-agent systems where agents may be built on different frameworks or deployed independently.","intents":["Build distributed agent networks where agents can be deployed independently and communicate across services","Integrate AgentScope agents with agents built on other frameworks (e.g., AutoGen, LangChain agents)","Create agent marketplaces where specialized agents can be discovered and invoked on-demand"],"best_for":["Organizations with polyglot agent deployments (multiple frameworks, multiple services)","Microservices architectures where agents are deployed as independent services","Platforms building agent ecosystems or marketplaces"],"limitations":["A2A protocol is still emerging; limited ecosystem of compatible agent systems","Network latency and reliability become factors in agent coordination; no built-in retry or circuit-breaker patterns","Message serialization/deserialization overhead for cross-network communication","No built-in authentication or encryption; requires external security layer"],"requires":["Python 3.9+","A2A protocol implementation (agentscope A2A module)","Network connectivity between agent systems","Agent discovery mechanism (registry, DNS, or manual configuration)"],"input_types":["remote agent identifiers","Msg objects (serializable message format)","agent capability/schema information"],"output_types":["responses from remote agents","agent discovery results","communication status/errors"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-agentscope-ai--agentscope__cap_4","uri":"capability://text.generation.language.unified.message.abstraction.msg.with.content.blocks.for.multi.modal.communication","name":"unified message abstraction (msg) with content blocks for multi-modal communication","description":"Provides a unified Msg object that encapsulates agent communication with support for multiple content block types (text, images, audio, structured data), enabling agents to exchange multi-modal information. The Msg abstraction decouples message structure from provider-specific formats, allowing Formatters to convert messages into OpenAI, Anthropic, Gemini, or other provider APIs. Content blocks are composable, allowing rich message payloads with mixed content types.","intents":["Build agents that work with text, images, audio, and structured data in a unified way","Switch between LLM providers without changing message structure or agent logic","Create message history that captures the full context of agent interactions including multi-modal content"],"best_for":["Teams building multi-modal agents (vision, audio, text)","Applications requiring provider-agnostic message handling","Developers building agent frameworks or middleware"],"limitations":["Content block types are predefined; custom content types require extending the Msg class","Multi-modal support depends on underlying LLM provider capabilities; not all providers support all content types","Message serialization for storage/transmission requires custom handling for binary content (images, audio)","No built-in compression or optimization for large content blocks"],"requires":["Python 3.9+","agentscope package","Understanding of Msg and content block types"],"input_types":["text strings","image data (file paths, URLs, or binary)","audio data","structured data (JSON, dicts)"],"output_types":["Msg objects with content blocks","provider-specific API payloads (via Formatter)","message history with full context"],"categories":["text-generation-language","image-visual"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-agentscope-ai--agentscope__cap_5","uri":"capability://tool.use.integration.provider.specific.formatter.abstraction.for.api.payload.conversion","name":"provider-specific formatter abstraction for api payload conversion","description":"Converts unified Msg objects into provider-specific API payloads through a pluggable Formatter architecture. Each provider (OpenAI, Anthropic, Gemini, DashScope, Ollama) has a corresponding Formatter that handles protocol-specific details like function calling schemas, tool_use blocks, and message role mappings. Formatters are automatically selected based on the configured Model, enabling seamless provider switching.","intents":["Switch between LLM providers without rewriting agent message handling code","Handle provider-specific quirks (e.g., OpenAI function calling vs Anthropic tool_use) transparently","Build custom formatters for new providers or proprietary APIs"],"best_for":["Teams evaluating multiple LLM providers and wanting to avoid vendor lock-in","Organizations with custom or proprietary LLM APIs","Developers building agent frameworks that need multi-provider support"],"limitations":["Adding a new provider requires implementing a custom Formatter; no automatic schema mapping","Provider-specific features (e.g., vision capabilities, tool calling variants) may not be fully exposed through the abstraction","Formatter logic can become complex for providers with many quirks; maintenance burden grows with provider count","No built-in validation of formatted payloads; malformed payloads may only fail at API call time"],"requires":["Python 3.9+","agentscope package","Understanding of target provider's API (for custom formatters)"],"input_types":["Msg objects with content blocks","message history","tool schemas"],"output_types":["provider-specific API payloads (JSON)","formatted message lists","function calling schemas"],"categories":["tool-use-integration","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-agentscope-ai--agentscope__cap_6","uri":"capability://memory.knowledge.working.memory.short.term.and.long.term.memory.with.session.management","name":"working memory (short-term) and long-term memory with session management","description":"Provides a dual-memory architecture where working memory holds the current conversation context (message history) and optional long-term memory persists information across sessions using configurable backends (vector stores, databases). Working memory is automatically managed by agents, while long-term memory requires explicit integration through memory retrieval/storage operations. Session management enables agents to resume from previous states or maintain persistent knowledge across multiple conversations.","intents":["Maintain conversation context within a single agent session without token explosion","Persist agent knowledge across multiple conversations or sessions","Retrieve relevant historical information from long-term memory to augment current reasoning"],"best_for":["Applications requiring persistent agent state (chatbots, personal assistants)","Systems where agents need to learn from past interactions","Multi-session applications where context must survive agent restarts"],"limitations":["Working memory is in-process; no distributed memory for multi-instance deployments","Long-term memory integration is optional and requires manual implementation; no automatic memory management","Memory retrieval adds latency; no built-in caching or indexing optimization","Session management requires explicit session IDs; no automatic session lifecycle management"],"requires":["Python 3.9+","agentscope package","Optional: vector store or database for long-term memory (Chroma, Pinecone, etc.)"],"input_types":["message history (Msg objects)","session identifiers","memory queries (text or embeddings)"],"output_types":["working memory state (message list)","retrieved memories (text, embeddings, or structured data)","session metadata"],"categories":["memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-agentscope-ai--agentscope__cap_7","uri":"capability://tool.use.integration.toolkit.based.function.and.tool.management.with.local.and.remote.execution","name":"toolkit-based function and tool management with local and remote execution","description":"Manages both local Python functions and remote tools (MCP, A2A) through a unified Toolkit interface. Functions are registered with schemas that enable the ReActAgent to discover and invoke them. The Toolkit handles function execution, error handling, and result formatting. Tool schemas are automatically converted by Formatters into provider-specific function-calling formats (OpenAI, Anthropic, etc.), enabling agents to decide when and how to call tools.","intents":["Register local Python functions as agent tools without manual schema definition","Expose tool capabilities to agents in a provider-agnostic way","Execute tools (local or remote) and integrate results back into agent reasoning"],"best_for":["Developers building agents with custom business logic","Teams integrating existing Python functions into agents","Applications requiring both local and remote tool execution"],"limitations":["Tool schema definition is manual; no automatic schema inference from function signatures","Error handling is basic; tool failures may not provide actionable feedback to agents","No built-in tool result caching; repeated tool calls execute every time","Tool execution is synchronous; no async/await support for long-running tools"],"requires":["Python 3.9+","agentscope package","Tool functions with proper signatures and docstrings"],"input_types":["Python functions","tool schemas (JSON)","tool invocation parameters"],"output_types":["tool execution results","error messages","tool metadata/schemas"],"categories":["tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-agentscope-ai--agentscope__cap_8","uri":"capability://memory.knowledge.retrieval.augmented.generation.rag.with.vector.stores.and.document.readers","name":"retrieval-augmented generation (rag) with vector stores and document readers","description":"Provides RAG capabilities through a Knowledge Base abstraction that integrates with vector stores (Chroma, Pinecone, etc.) and document readers for ingesting and retrieving information. Agents can query the knowledge base to augment reasoning with relevant documents or facts. The architecture supports embedding models for semantic search and document chunking strategies for optimal retrieval.","intents":["Build agents that can answer questions grounded in a corpus of documents","Implement semantic search over large document collections","Augment agent reasoning with relevant context from a knowledge base"],"best_for":["Applications requiring document-grounded AI (customer support, research assistants)","Teams building knowledge-intensive agents","Systems where agents need to cite sources or provide evidence"],"limitations":["RAG quality depends on document chunking and embedding model quality; no automatic optimization","Vector store integration requires external services; adds infrastructure complexity","Retrieval latency can impact agent response time; no built-in caching","Document readers support limited formats; custom readers required for proprietary formats"],"requires":["Python 3.9+","agentscope package","Vector store instance (Chroma, Pinecone, etc.)","Embedding model (OpenAI, local, etc.)","Documents to index"],"input_types":["documents (text, PDF, markdown)","queries (text)","embedding vectors"],"output_types":["retrieved documents/chunks","relevance scores","augmented context for agents"],"categories":["memory-knowledge","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-agentscope-ai--agentscope__cap_9","uri":"capability://automation.workflow.observability.and.tracing.with.opentelemetry.otel.integration","name":"observability and tracing with opentelemetry (otel) integration","description":"Provides built-in observability through OpenTelemetry integration, enabling agents to emit traces, metrics, and logs for monitoring and debugging. Traces capture agent reasoning steps, tool calls, and model invocations, providing visibility into agent behavior. Metrics track performance (latency, token usage, tool call counts). Logs capture detailed execution information. OTel exporters send data to observability backends (Jaeger, Datadog, etc.).","intents":["Monitor agent behavior in production and debug issues","Track agent performance metrics (latency, token usage, cost)","Understand agent reasoning steps and tool call patterns"],"best_for":["Teams deploying agents in production","Organizations requiring compliance and audit trails","Developers debugging complex multi-agent systems"],"limitations":["OTel integration adds overhead; tracing can impact agent latency","Trace data volume can be large; requires external storage and analysis","OTel exporter configuration is required; no built-in local storage","Trace sampling may lose important debugging information"],"requires":["Python 3.9+","agentscope package with OTel support","OpenTelemetry SDK and exporters","Observability backend (Jaeger, Datadog, etc.)"],"input_types":["agent execution events","tool call invocations","model API calls"],"output_types":["traces (execution flow)","metrics (latency, token usage)","logs (detailed events)"],"categories":["automation-workflow","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":50,"verified":false,"data_access_risk":"high","permissions":["Python 3.9+","API key for at least one supported model provider (OpenAI, Anthropic, Gemini, DashScope, or local Ollama instance)","agentscope package installed (pip install agentscope)","Multiple agent instances (each with their own Model, Memory, Toolkit)","agentscope package with multi-agent support","agentscope package","RL training infrastructure (for RL fine-tuning)","Reward function definition","Baseline performance metrics","agentscope package with realtime support"],"failure_modes":["ReActAgent is the primary implementation; custom agent types require extending AgentBase","Reasoning quality depends entirely on underlying LLM capability; no built-in prompt optimization beyond Formatter abstraction","Multi-turn reasoning can accumulate token costs; long-term memory integration required for extended conversations","MsgHub is synchronous; no built-in async/await support for concurrent agent execution","Pipeline patterns are predefined (sequential, fanout); custom orchestration requires manual MsgHub management","No built-in deadlock detection or timeout handling for circular agent dependencies","Message routing is broadcast-based; no selective message filtering or routing rules","RL fine-tuning requires reward signal definition; no automatic reward inference","RL training is computationally expensive; requires significant infrastructure","Prompt tuning results are task-specific; limited generalization","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.7560406348090914,"quality":0.35,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.1,"match_graph":0.28,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:21.549Z","last_scraped_at":"2026-05-03T13:57:11.504Z","last_commit":"2026-04-30T08:27:43Z"},"community":{"stars":24557,"forks":2647,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=agentscope-ai--agentscope","compare_url":"https://unfragile.ai/compare?artifact=agentscope-ai--agentscope"}},"signature":"SRnLUA8FRmBGwXBjXruvianCk77xQUaeQWE7XjbIz+oPQyt05mBurHbldZCzl7U9kKmTJe7C55kSYUjms8trAw==","signedAt":"2026-06-20T10:43:38.137Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/agentscope-ai--agentscope","artifact":"https://unfragile.ai/agentscope-ai--agentscope","verify":"https://unfragile.ai/api/v1/verify?slug=agentscope-ai--agentscope","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}