{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-microsoft--autogen","slug":"microsoft--autogen","name":"autogen","type":"framework","url":"https://microsoft.github.io/autogen/","page_url":"https://unfragile.ai/microsoft--autogen","categories":["frameworks-sdks"],"tags":["agentic","agentic-agi","agents","ai","autogen","autogen-ecosystem","chatgpt","framework","llm-agent","llm-framework"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-microsoft--autogen__cap_0","uri":"capability://planning.reasoning.multi.agent.orchestration.via.agentruntime.protocol","name":"multi-agent orchestration via agentruntime protocol","description":"Provides a protocol-based agent runtime abstraction (AgentRuntime) that enables agents to communicate asynchronously through a message-passing system with support for both single-threaded (SingleThreadedAgentRuntime) and distributed (GrpcWorkerAgentRuntime) execution models. Agents register with the runtime, subscribe to message topics, and process events through a subscription-based routing mechanism that decouples agent logic from transport concerns.","intents":["I need to coordinate multiple AI agents that can run locally or distributed across machines","I want to build agents that communicate asynchronously without tight coupling","I need to scale agent teams from single-process to multi-machine deployments"],"best_for":["teams building complex multi-agent systems requiring distributed execution","developers needing to decouple agent logic from deployment topology","enterprises migrating from monolithic to distributed agent architectures"],"limitations":["GrpcWorkerAgentRuntime requires gRPC infrastructure setup and network configuration","Message ordering guarantees depend on underlying transport (not globally ordered across distributed agents)","Debugging distributed agent interactions requires tracing/observability tooling (OpenTelemetry integration present but requires setup)"],"requires":["Python 3.10+","autogen-core package","gRPC and protobuf for distributed mode","OpenTelemetry API for observability"],"input_types":["Agent protocol implementations","Message objects (LLMMessage, BaseChatMessage, BaseAgentEvent)","Tool definitions (BaseTool interface)"],"output_types":["Routed messages between agents","Agent events and state changes","Subscription-based event streams"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-microsoft--autogen__cap_1","uri":"capability://tool.use.integration.llm.client.abstraction.with.multi.provider.support","name":"llm client abstraction with multi-provider support","description":"Abstracts LLM interactions through a ChatCompletionClient protocol that normalizes API differences across OpenAI, Azure OpenAI, Anthropic, Ollama, and other providers. Implementations handle provider-specific authentication, request/response formatting, and error handling, allowing agents to switch LLM backends without code changes. The abstraction layer sits in autogen-core with concrete implementations in autogen-ext.","intents":["I want to build agents that can use different LLM providers interchangeably","I need to switch between OpenAI, Azure, and local models without rewriting agent code","I want to implement fallback logic across multiple LLM providers"],"best_for":["teams evaluating multiple LLM providers and wanting to avoid vendor lock-in","enterprises using Azure OpenAI but needing fallback to open-source models","developers building cost-optimized systems that route to cheaper models based on task complexity"],"limitations":["Provider-specific features (vision, function calling schemas) require custom client implementations","Streaming response handling varies by provider; not all providers support identical streaming semantics","Rate limiting and quota management are provider-specific and not abstracted by the protocol"],"requires":["Python 3.10+","autogen-core package","API keys for target LLM providers (OpenAI, Azure, Anthropic, etc.)","autogen-ext for concrete client implementations"],"input_types":["Chat messages (LLMMessage format)","Provider configuration (API keys, endpoints, model names)","Tool/function schemas for function calling"],"output_types":["Chat completion responses","Token usage metrics","Structured function call results"],"categories":["tool-use-integration","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-microsoft--autogen__cap_10","uri":"capability://memory.knowledge.memory.and.context.management.for.agent.conversations","name":"memory and context management for agent conversations","description":"Provides memory abstractions for storing and retrieving conversation history, agent state, and contextual information. Implementations include in-memory storage (for single-session use) and pluggable external storage (vector databases, SQL stores). Memory systems support semantic search over conversation history, enabling agents to retrieve relevant past interactions. The framework integrates memory with agent reasoning, allowing agents to reference previous conversations and learn from history.","intents":["I want agents to remember previous conversations and learn from history","I need to retrieve relevant past interactions when handling new requests","I want to implement long-term memory for agents across multiple sessions"],"best_for":["applications requiring persistent agent memory across sessions","systems where agents need to reference past interactions","long-running agents that accumulate knowledge over time"],"limitations":["In-memory storage is lost on process restart; requires external persistence","Semantic search over memory requires vector embeddings, adding latency (~100-500ms per search)","Memory growth is unbounded; no built-in pruning or summarization of old interactions","Retrieving relevant context from large memory stores can be expensive (vector DB queries scale with corpus size)"],"requires":["Python 3.10+","autogen-agentchat package","Vector database or external storage (optional, for persistence)","Embedding model for semantic search (optional)"],"input_types":["Conversation messages","Agent state","Metadata (timestamps, tags, etc.)"],"output_types":["Retrieved conversation history","Relevant past interactions","Memory summaries"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-microsoft--autogen__cap_11","uri":"capability://tool.use.integration.cross.language.interoperability.via.grpc.and.net.sdk","name":"cross-language interoperability via grpc and .net sdk","description":"Enables agents and components written in Python to interoperate with .NET implementations through gRPC protocol buffers. The framework includes a .NET SDK (autogen-dotnet) that mirrors Python abstractions (Agent protocol, ChatCompletionClient, tools) and communicates with Python agents via gRPC. This allows mixed-language agent teams where Python and .NET agents collaborate through the same runtime.","intents":["I want to use .NET libraries or services in a Python agent system","I need to build agent teams with both Python and C# components","I want to integrate legacy .NET code into a Python agent framework"],"best_for":["enterprises with mixed Python/C# codebases","teams needing to leverage .NET libraries in agent systems","applications requiring high-performance .NET components alongside Python agents"],"limitations":["gRPC communication adds ~50-200ms latency per message compared to in-process calls","Requires gRPC infrastructure setup and network configuration",".NET SDK is newer and may have fewer integrations than Python ecosystem","Debugging cross-language interactions requires tracing across language boundaries"],"requires":["Python 3.10+ and .NET 8.0+","autogen-core (Python) and autogen-dotnet packages","gRPC runtime and protobuf compiler","Network connectivity between Python and .NET processes"],"input_types":["Python agent definitions",".NET agent implementations","gRPC service definitions"],"output_types":["Cross-language agent messages","Shared protocol buffer messages"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-microsoft--autogen__cap_12","uri":"capability://tool.use.integration.mcp.model.context.protocol.integration.for.tool.and.resource.access","name":"mcp (model context protocol) integration for tool and resource access","description":"Integrates the Model Context Protocol (MCP) to enable agents to discover and invoke tools and resources exposed by MCP servers. Agents can connect to MCP servers, query available tools and resources, and invoke them through a standardized protocol. This allows agents to access external services (web APIs, databases, file systems) through a unified interface without custom tool implementations.","intents":["I want agents to access tools and resources from MCP servers","I need to expose my services to agents through a standard protocol","I want to decouple agent implementation from specific tool implementations"],"best_for":["applications using MCP-compatible services and tools","teams building tool ecosystems that agents need to access","systems requiring standardized tool discovery and invocation"],"limitations":["MCP server availability and latency directly impact agent performance","Tool discovery happens at runtime; no static analysis of available tools","Error handling depends on MCP server implementation quality"],"requires":["Python 3.10+","autogen-ext package with MCP integration","MCP server running and accessible","MCP client library"],"input_types":["MCP server connection details","Tool invocation requests"],"output_types":["Available tools and resources from MCP server","Tool execution results"],"categories":["tool-use-integration","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-microsoft--autogen__cap_13","uri":"capability://data.processing.analysis.web.and.file.interaction.utilities.for.agent.tasks","name":"web and file interaction utilities for agent tasks","description":"Provides utility functions and abstractions for agents to interact with web content and files. Includes web scraping helpers, file I/O abstractions, and content parsing utilities. These utilities are used by specialized agents (WebSurfer, FileSurfer in MagenticOne) but are also available as standalone tools for custom agents. Supports reading/writing various file formats (text, JSON, CSV, etc.) and extracting content from web pages.","intents":["I want agents to read and write files in various formats","I need agents to extract and parse content from web pages","I want to provide file and web utilities to custom agents"],"best_for":["agents that need to interact with files and web content","applications requiring content parsing and extraction","systems where agents need to persist results to files"],"limitations":["Web scraping utilities depend on page structure; changes to website layouts break scrapers","File I/O is limited to configured working directories for security","No built-in handling of binary files or complex formats (images, PDFs require additional libraries)"],"requires":["Python 3.10+","autogen-ext package","File system access permissions","Optional: Playwright or Selenium for web interaction"],"input_types":["File paths","URLs","File content (text, JSON, CSV, etc.)"],"output_types":["File contents","Parsed web page content","Write confirmations"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-microsoft--autogen__cap_14","uri":"capability://automation.workflow.autogen.studio.visual.agent.builder.and.configuration.ui","name":"autogen studio visual agent builder and configuration ui","description":"A web-based UI (autogen-studio package) for visually designing and configuring multi-agent systems without code. Users can define agents, configure LLM models, register tools, and design team structures through a graphical interface. The UI generates Python code or configuration files that can be executed by the AutoGen runtime. Provides templates for common agent patterns and allows exporting configurations for version control.","intents":["I want to build agent systems without writing code","I need a visual way to design and test multi-agent workflows","I want to quickly prototype agent configurations and share them with non-technical stakeholders"],"best_for":["non-technical users building agent systems","rapid prototyping and experimentation with agent configurations","teams needing visual documentation of agent architectures"],"limitations":["Limited to pre-built agent types and patterns; custom agent logic requires code","Generated code may not be optimized for production use","Complex workflows with conditional logic are harder to express visually than in code"],"requires":["Python 3.10+","autogen-studio package","Web browser for UI access","Node.js (for running the UI server)"],"input_types":["Agent definitions (visual)","Tool configurations","LLM model selections"],"output_types":["Python code","Configuration files (JSON/YAML)","Executable agent systems"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-microsoft--autogen__cap_2","uri":"capability://tool.use.integration.tool.function.calling.with.schema.based.registration","name":"tool/function calling with schema-based registration","description":"Provides a BaseTool interface for registering callable functions with JSON schema definitions that agents can discover and invoke. Tools are registered with the agent runtime, and their schemas are automatically passed to LLM providers that support function calling (OpenAI, Anthropic). The framework handles schema validation, argument marshaling, and error handling between agent requests and tool execution.","intents":["I want agents to call external functions and APIs with type-safe argument passing","I need to expose Python functions to agents with automatic schema generation","I want agents to discover available tools and decide when to use them"],"best_for":["developers building agents that interact with APIs, databases, or custom services","teams needing type-safe function calling with automatic schema validation","applications requiring agents to execute code or system commands safely"],"limitations":["Schema generation relies on Python type hints; untyped functions require manual schema definition","Tool execution is synchronous by default; async tools require custom executor implementations","No built-in sandboxing or permission system; tool access control must be implemented at the application level"],"requires":["Python 3.10+","autogen-core package","Type hints on tool functions for automatic schema generation","LLM provider that supports function calling (OpenAI, Anthropic, etc.)"],"input_types":["Python functions with type hints","JSON schema definitions","Function call requests from agents"],"output_types":["JSON schema representations of tools","Function execution results","Error messages and exceptions"],"categories":["tool-use-integration","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-microsoft--autogen__cap_3","uri":"capability://planning.reasoning.assistantagent.with.llm.powered.reasoning.and.tool.use","name":"assistantagent with llm-powered reasoning and tool use","description":"A high-level agent implementation (in autogen-agentchat) that wraps the core Agent protocol with LLM-powered reasoning capabilities. AssistantAgent maintains conversation history, uses a ChatCompletionClient to generate responses, and automatically invokes registered tools based on LLM decisions. It implements a turn-based conversation loop where the agent reasons about user input, decides whether to call tools, executes them, and generates responses.","intents":["I want a ready-to-use agent that can reason and use tools without building from scratch","I need an agent that maintains conversation context and can handle multi-turn interactions","I want to quickly prototype an LLM-powered assistant with tool calling"],"best_for":["rapid prototyping of LLM-powered assistants","developers new to agent frameworks who want pre-built patterns","applications requiring single-agent reasoning with tool access"],"limitations":["Designed for single-agent scenarios; multi-agent coordination requires GroupChat or Team abstractions","Conversation history is in-memory only; no built-in persistence (requires external state store)","Tool selection is entirely LLM-driven; no explicit planning or constraint-based tool filtering"],"requires":["Python 3.10+","autogen-agentchat package","ChatCompletionClient implementation (from autogen-ext)","Registered tools via BaseTool interface"],"input_types":["User messages (text)","Tool definitions","System prompts and instructions"],"output_types":["Agent responses (text)","Tool invocation requests","Conversation history"],"categories":["planning-reasoning","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-microsoft--autogen__cap_4","uri":"capability://code.generation.editing.code.execution.agents.with.sandboxed.python.bash.execution","name":"code execution agents with sandboxed python/bash execution","description":"Provides CodeExecutorAgent and related code execution abstractions that allow agents to write and execute Python or bash code in isolated environments. The framework includes LocalCommandLineCodeExecutor for local execution and DockerCommandLineCodeExecutor for containerized execution. Code is executed in a subprocess or container with configurable working directories, environment variables, and timeout limits, with output captured and returned to the agent.","intents":["I want agents to write and execute code to solve problems or analyze data","I need to safely execute untrusted code in isolated containers","I want agents to have access to system commands and data processing tools"],"best_for":["data science and analytics applications where agents need to run analysis code","development assistants that generate and test code","applications requiring sandboxed code execution for security"],"limitations":["Docker execution requires Docker daemon running and adds ~500ms-2s overhead per execution","Local execution has no true isolation; malicious code can access the host filesystem and environment","Timeout handling is process-level; infinite loops in executed code will block the agent until timeout","Output capture is limited to stdout/stderr; side effects (file writes, network calls) are not automatically tracked"],"requires":["Python 3.10+","autogen-agentchat package","Docker (for DockerCommandLineCodeExecutor)","Appropriate system permissions for subprocess execution"],"input_types":["Python code strings","Bash/shell commands","Working directory paths","Environment variables"],"output_types":["Execution output (stdout/stderr)","Exit codes","Generated files (in working directory)","Execution errors and exceptions"],"categories":["code-generation-editing","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-microsoft--autogen__cap_5","uri":"capability://planning.reasoning.multi.agent.team.orchestration.with.groupchat.patterns","name":"multi-agent team orchestration with groupchat patterns","description":"Implements BaseGroupChat and derived classes (RoundRobinGroupChat, SelectorGroupChat) that coordinate multiple agents in structured conversation patterns. Teams manage agent turns, message routing, and termination conditions. The framework handles turn-taking logic, message broadcasting to all team members, and decision-making about which agent speaks next or when the conversation should end. Teams can be nested, allowing hierarchical agent structures.","intents":["I want multiple agents to collaborate on a task with structured turn-taking","I need agents to debate or discuss a problem before reaching a conclusion","I want to implement hierarchical teams where sub-teams report to a manager agent"],"best_for":["complex problem-solving requiring diverse agent perspectives","applications needing agent debate or consensus mechanisms","teams building hierarchical agent organizations"],"limitations":["Turn-taking logic is synchronous; no true parallelism (agents take turns sequentially)","Message history grows linearly with team size and conversation length; no built-in history pruning","Termination conditions are evaluated after each turn, adding latency for long conversations","No built-in conflict resolution; teams with disagreeing agents may loop indefinitely without explicit termination logic"],"requires":["Python 3.10+","autogen-agentchat package","Multiple Agent instances (AssistantAgent, CodeExecutorAgent, etc.)","Termination condition implementation"],"input_types":["List of agents","Initial user message","Termination conditions","Turn-taking strategy"],"output_types":["Team conversation history","Final response from designated agent","Termination reason"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-microsoft--autogen__cap_6","uri":"capability://planning.reasoning.termination.condition.evaluation.for.agent.conversations","name":"termination condition evaluation for agent conversations","description":"Provides a TerminationCondition abstraction that evaluates whether a multi-agent conversation should end based on custom logic. Conditions are evaluated after each agent turn and can inspect the full conversation history, agent states, and message content. Built-in conditions include MaxMessageTermination (stop after N messages), TextMatchTermination (stop when specific text appears), and custom implementations can combine multiple conditions with AND/OR logic.","intents":["I want teams to stop talking when they reach agreement or consensus","I need to prevent infinite loops in multi-agent conversations","I want to terminate conversations when specific goals are achieved"],"best_for":["applications requiring deterministic conversation endpoints","teams needing to prevent runaway agent interactions","systems where conversation cost or latency is a concern"],"limitations":["Evaluation happens synchronously after each turn, adding latency for complex conditions","No built-in learning from past conversations; conditions are static per run","Semantic understanding of 'agreement' or 'consensus' requires custom implementations; no built-in NLU"],"requires":["Python 3.10+","autogen-agentchat package","TerminationCondition implementation"],"input_types":["Conversation history","Agent messages","Custom state or metrics"],"output_types":["Boolean termination decision","Termination reason/metadata"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-microsoft--autogen__cap_7","uri":"capability://automation.workflow.graphflow.workflow.orchestration.for.complex.agent.pipelines","name":"graphflow workflow orchestration for complex agent pipelines","description":"Provides a graph-based workflow engine (GraphFlow) that defines agent interactions as directed acyclic graphs (DAGs) where nodes are agents or tasks and edges represent data flow. Workflows support conditional branching, parallel execution of independent paths, and dynamic routing based on agent outputs. The engine manages execution order, data passing between nodes, and error handling across the pipeline.","intents":["I want to define complex multi-step workflows with conditional logic and branching","I need to orchestrate agents in a DAG structure with explicit data dependencies","I want to visualize and reason about agent interaction patterns"],"best_for":["applications with complex, multi-step agent pipelines","teams needing explicit workflow definitions and visualization","systems requiring deterministic execution order and data flow"],"limitations":["DAG structure prohibits cycles; feedback loops require explicit re-entry nodes","Execution is sequential along paths; no true parallelism across independent branches (requires async runtime)","Conditional branching requires explicit condition functions; no built-in semantic routing"],"requires":["Python 3.10+","autogen-agentchat package","GraphFlow implementation (in autogen-ext or custom)"],"input_types":["Agent/task nodes","Edge definitions with data mappings","Conditional routing functions"],"output_types":["Workflow execution results","Execution trace/DAG traversal log","Final output from terminal nodes"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-microsoft--autogen__cap_8","uri":"capability://automation.workflow.magenticone.system.for.autonomous.web.and.file.interaction","name":"magenticone system for autonomous web and file interaction","description":"A specialized multi-agent system (MagenticOne) that combines web browsing, file manipulation, and code execution agents to autonomously complete tasks on the web and local filesystem. Agents include a WebSurfer (navigates web with browser automation), FileSurfer (reads/writes files), and Coder (executes code). A Conductor agent orchestrates these specialists, deciding which agent should handle each subtask and synthesizing results into final outputs.","intents":["I want an agent system that can autonomously browse the web and complete web-based tasks","I need agents to read, analyze, and generate files without human intervention","I want a system that can research information online and synthesize it into reports"],"best_for":["web automation and scraping tasks","autonomous research and report generation","applications requiring agents to interact with web UIs and file systems"],"limitations":["Web browsing requires Playwright or Selenium setup and browser driver management","JavaScript-heavy websites may not render correctly; relies on headless browser capabilities","File operations are limited to the configured working directory; no cross-filesystem access","Web interaction is slow (~2-5s per page load); not suitable for real-time applications"],"requires":["Python 3.10+","autogen-agentchat package","Playwright or Selenium for web browsing","Browser driver (Chromium, Firefox, etc.)"],"input_types":["Task descriptions (natural language)","URLs or file paths","Search queries"],"output_types":["Web page content and screenshots","File contents","Synthesized reports and summaries","Execution logs"],"categories":["automation-workflow","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-microsoft--autogen__cap_9","uri":"capability://automation.workflow.message.routing.and.subscription.based.event.system","name":"message routing and subscription-based event system","description":"Implements a publish-subscribe event system where agents subscribe to message topics and the runtime routes messages from producers to subscribers. Messages are typed (LLMMessage, BaseChatMessage, BaseAgentEvent) and include metadata for routing. The subscription mechanism enables loose coupling between agents; producers don't need to know about consumers, and new subscribers can be added without modifying producers.","intents":["I want agents to communicate without tight coupling or direct references","I need to broadcast messages to multiple agents based on topic subscriptions","I want to add new agents to a system without modifying existing agent code"],"best_for":["large agent systems with many interconnected agents","applications requiring dynamic agent addition/removal","systems needing to decouple agent logic from communication topology"],"limitations":["Subscription-based routing adds overhead compared to direct method calls (~10-50ms per message)","Message ordering is not globally guaranteed in distributed systems; only per-subscription ordering is maintained","Debugging message flow is harder than direct calls; requires tracing/observability tooling"],"requires":["Python 3.10+","autogen-core package","AgentRuntime implementation"],"input_types":["Message objects (LLMMessage, BaseChatMessage, BaseAgentEvent)","Topic/subscription identifiers"],"output_types":["Routed messages to subscribers","Subscription confirmations"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":56,"verified":false,"data_access_risk":"high","permissions":["Python 3.10+","autogen-core package","gRPC and protobuf for distributed mode","OpenTelemetry API for observability","API keys for target LLM providers (OpenAI, Azure, Anthropic, etc.)","autogen-ext for concrete client implementations","autogen-agentchat package","Vector database or external storage (optional, for persistence)","Embedding model for semantic search (optional)","Python 3.10+ and .NET 8.0+"],"failure_modes":["GrpcWorkerAgentRuntime requires gRPC infrastructure setup and network configuration","Message ordering guarantees depend on underlying transport (not globally ordered across distributed agents)","Debugging distributed agent interactions requires tracing/observability tooling (OpenTelemetry integration present but requires setup)","Provider-specific features (vision, function calling schemas) require custom client implementations","Streaming response handling varies by provider; not all providers support identical streaming semantics","Rate limiting and quota management are provider-specific and not abstracted by the protocol","In-memory storage is lost on process restart; requires external persistence","Semantic search over memory requires vector embeddings, adding latency (~100-500ms per search)","Memory growth is unbounded; no built-in pruning or summarization of old interactions","Retrieving relevant context from large memory stores can be expensive (vector DB queries scale with corpus size)","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.8551372714186198,"quality":0.35,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.3,"quality":0.2,"ecosystem":0.15,"match_graph":0.23,"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:22.062Z","last_scraped_at":"2026-05-03T13:57:11.503Z","last_commit":"2026-04-15T11:59:09Z"},"community":{"stars":57669,"forks":8699,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=microsoft--autogen","compare_url":"https://unfragile.ai/compare?artifact=microsoft--autogen"}},"signature":"gji7m2r3+CojphI44X6F/HOeYHsAg6vcp4Fnt+jCPuxKdP6aH2c3H3EuegUS+fRgEisUrbwMVq2iIh5oRnnyCw==","signedAt":"2026-06-22T17:25:23.138Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/microsoft--autogen","artifact":"https://unfragile.ai/microsoft--autogen","verify":"https://unfragile.ai/api/v1/verify?slug=microsoft--autogen","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"}}