{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"autogen-starter","slug":"autogen-starter","name":"AutoGen Starter","type":"template","url":"https://github.com/microsoft/autogen/tree/main/samples","page_url":"https://unfragile.ai/autogen-starter","categories":["app-builders","rag-knowledge"],"tags":[],"pricing":{"model":"free","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"autogen-starter__cap_0","uri":"capability://planning.reasoning.multi.agent.conversation.orchestration.with.group.chat.patterns","name":"multi-agent conversation orchestration with group chat patterns","description":"Implements BaseGroupChat abstraction enabling multiple agents to communicate in structured conversation flows with configurable termination conditions and message routing. Uses AgentRuntime protocol to manage agent lifecycle, message subscriptions, and event propagation across agent instances. Supports round-robin, speaker selection, and custom routing strategies for coordinating agent interactions without explicit message passing code.","intents":["I need multiple AI agents to collaborate on a task by having them discuss and build on each other's responses","I want to define when a multi-agent conversation should stop based on specific conditions or agent decisions","I need to control the order and flow of agent participation in group conversations"],"best_for":["Teams building autonomous multi-agent systems for code review, research, or problem-solving","Developers prototyping agent collaboration patterns without building custom message routing","Organizations needing human-in-the-loop oversight of agent conversations"],"limitations":["Termination conditions are evaluated after each agent turn, adding latency proportional to conversation length","No built-in persistence of conversation state — requires external storage for audit trails","Message routing complexity increases with agent count; no automatic load balancing across distributed runtimes"],"requires":["Python 3.10+","autogen-core and autogen-agentchat packages","At least one ChatCompletionClient implementation (OpenAI, Anthropic, or local LLM via autogen-ext)"],"input_types":["natural language prompts","structured agent configurations","termination condition definitions"],"output_types":["conversation transcripts","agent messages with metadata","termination reason and final state"],"categories":["planning-reasoning","multi-agent-orchestration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"autogen-starter__cap_1","uri":"capability://tool.use.integration.llm.powered.agent.with.tool.calling.and.code.execution","name":"llm-powered agent with tool calling and code execution","description":"AssistantAgent wraps ChatCompletionClient to enable agents to call external tools via schema-based function registry with native bindings for OpenAI, Anthropic, and Ollama function-calling APIs. Integrates with CodeExecutorAgent for executing generated code in sandboxed environments. Agents maintain conversation history and can reason about tool outputs to refine responses iteratively.","intents":["I want an agent that can write and execute code to solve problems, not just discuss them","I need agents to call external APIs or functions as part of their reasoning process","I want to provide custom tools that agents can discover and use autonomously"],"best_for":["Developers building code-generation and code-execution workflows","Teams needing agents that can interact with external systems (APIs, databases, file systems)","Researchers prototyping autonomous coding agents"],"limitations":["Code execution requires explicit sandbox setup (Docker, local Python environment); no built-in isolation","Tool schema validation adds ~50-100ms per tool call for complex schemas","No automatic tool discovery — tools must be explicitly registered in agent configuration"],"requires":["Python 3.10+","ChatCompletionClient implementation (OpenAI API key, Anthropic key, or local Ollama instance)","For code execution: Python environment or Docker container with execution permissions","autogen-ext for CodeExecutorAgent implementations"],"input_types":["natural language prompts","tool schema definitions (JSON Schema format)","code snippets for execution"],"output_types":["tool call requests with arguments","code execution results","refined agent responses based on tool outputs"],"categories":["tool-use-integration","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"autogen-starter__cap_10","uri":"capability://tool.use.integration.mcp.model.context.protocol.integration.for.standardized.tool.discovery","name":"mcp (model context protocol) integration for standardized tool discovery","description":"Integrates with Model Context Protocol servers to discover and use tools via standardized MCP interface. Agents can connect to MCP servers (local or remote) and automatically discover available tools without hardcoding tool schemas. Tool calls are routed through MCP protocol, enabling interoperability with any MCP-compatible service. Supports resource access patterns for files, databases, and APIs.","intents":["I want agents to discover and use tools from MCP servers without hardcoding tool definitions","I need agents to access resources (files, databases, APIs) through standardized MCP interface","I want to integrate agents with existing MCP-compatible services and tools"],"best_for":["Organizations standardizing on MCP for tool integration across multiple AI systems","Developers building extensible agent systems that work with MCP ecosystem","Teams needing interoperability between agents and other MCP-compatible applications"],"limitations":["MCP server discovery and connection adds startup latency (100-500ms per server)","Tool schema translation from MCP to agent format may lose provider-specific features","No built-in caching of MCP tool schemas; repeated discovery calls hit the server"],"requires":["Python 3.10+","MCP integration from autogen-ext","MCP server(s) running and accessible (local or remote)","MCP client library for protocol communication"],"input_types":["MCP server connection details (host, port, or stdio)","resource paths for MCP resources","tool invocation requests"],"output_types":["discovered tool schemas","tool execution results","resource content (files, data)"],"categories":["tool-use-integration","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"autogen-starter__cap_11","uri":"capability://automation.workflow.distributed.agent.execution.via.grpc.worker.runtime","name":"distributed agent execution via grpc worker runtime","description":"GrpcWorkerAgentRuntime enables agents to execute on remote worker processes/machines via gRPC protocol. Central coordinator dispatches agent tasks to workers, collects results, and manages message routing across distributed agents. Supports horizontal scaling by adding more worker processes. Agents are location-transparent — same code runs locally or distributed without modification.","intents":["I want to scale agent execution across multiple machines for parallel processing","I need to isolate agent execution in separate processes for fault tolerance","I want to distribute computationally expensive agent tasks across a cluster"],"best_for":["Large-scale multi-agent systems requiring horizontal scaling","Organizations running agents on Kubernetes or other container orchestration platforms","Teams needing fault isolation and process-level resource limits"],"limitations":["gRPC communication adds 10-50ms latency per agent message vs local execution","Distributed execution requires infrastructure setup (worker processes, networking, service discovery)","Message serialization/deserialization overhead for complex agent states"],"requires":["Python 3.10+","GrpcWorkerAgentRuntime from autogen-core","gRPC server and client libraries","Worker processes running agent code","Network connectivity between coordinator and workers"],"input_types":["agent task definitions","agent configurations","message routing specifications"],"output_types":["agent execution results","distributed message logs","worker status and health metrics"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"autogen-starter__cap_12","uri":"capability://automation.workflow.conversation.state.persistence.and.replay.for.debugging.and.audit","name":"conversation state persistence and replay for debugging and audit","description":"Enables capturing and persisting complete conversation state (messages, agent decisions, tool calls, results) to external storage for later analysis, debugging, or replay. Agents emit structured events that can be logged to databases, files, or observability platforms. Supports replaying conversations to reproduce issues or analyze agent behavior deterministically.","intents":["I want to log all agent conversations for compliance and audit purposes","I need to debug agent behavior by replaying conversations and inspecting decision points","I want to analyze agent performance and identify improvement opportunities"],"best_for":["Regulated industries (finance, healthcare) requiring conversation audit trails","Teams debugging complex multi-agent interactions","Organizations analyzing agent performance and behavior patterns"],"limitations":["Persistence overhead depends on storage backend; database writes can add 50-200ms per message","Replay is deterministic only if LLM responses are cached; live LLM calls produce different outputs","Large conversations (1000+ messages) require efficient storage and indexing"],"requires":["Python 3.10+","Storage backend (database, file system, observability platform)","Event serialization format (JSON, Protocol Buffers)","Logging/persistence implementation"],"input_types":["agent messages and events","conversation metadata","tool call and execution results"],"output_types":["persisted conversation logs","structured event records","replay traces"],"categories":["automation-workflow","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"autogen-starter__cap_13","uri":"capability://tool.use.integration.web.and.file.interaction.agents.with.sandboxed.resource.access","name":"web and file interaction agents with sandboxed resource access","description":"Enables agents to read files, write outputs, and interact with web resources (HTTP requests, web scraping) through sandboxed interfaces. Agents can fetch web content, parse HTML/JSON, and save results without direct file system access. Supports resource access patterns with permission controls and rate limiting. Integrations in autogen-ext provide implementations for common web/file operations.","intents":["I want agents to fetch and analyze content from websites","I need agents to read input files and write results to output files safely","I want agents to interact with web APIs and process responses"],"best_for":["Data collection and analysis workflows with web scraping","Document processing systems that read and generate files","Agents that need to interact with external web services"],"limitations":["Web requests add latency (1-5 seconds per request) and are subject to rate limiting","File I/O is sandboxed to specific directories; no access to system files outside sandbox","HTML parsing requires robust error handling for malformed or dynamic content"],"requires":["Python 3.10+","Web/file interaction implementations from autogen-ext","HTTP client library (requests, httpx, or similar)","File system permissions for sandbox directories"],"input_types":["URLs for web requests","file paths (within sandbox)","HTTP request parameters","HTML/JSON content for parsing"],"output_types":["web response content","parsed data structures","written files","HTTP status codes"],"categories":["tool-use-integration","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"autogen-starter__cap_2","uri":"capability://memory.knowledge.retrieval.augmented.agent.with.memory.and.knowledge.integration","name":"retrieval-augmented agent with memory and knowledge integration","description":"Integrates memory systems (vector stores, knowledge bases) with agents via autogen-ext, enabling agents to retrieve relevant context before generating responses. Supports RAG patterns where agents query external knowledge sources, incorporate retrieved documents into prompts, and refine answers based on retrieved context. Memory systems are pluggable and can use different backends (in-memory, vector databases, custom implementations).","intents":["I want agents to answer questions by retrieving relevant documents or knowledge before responding","I need agents to maintain and query a knowledge base of domain-specific information","I want to augment agent reasoning with external context without hardcoding it into prompts"],"best_for":["Teams building question-answering systems over large document collections","Organizations implementing domain-specific AI assistants with proprietary knowledge bases","Developers needing agents that can learn from and reference past interactions"],"limitations":["Retrieval latency depends on vector store implementation; no built-in caching of frequent queries","Embedding quality directly impacts retrieval relevance; requires tuning similarity thresholds","No automatic knowledge base updates — requires explicit refresh/reindexing workflows"],"requires":["Python 3.10+","Vector store implementation (e.g., Chroma, Pinecone, or custom via autogen-ext)","Embedding model (OpenAI embeddings, local models via autogen-ext)","Document collection in supported format (text, PDF, markdown)"],"input_types":["natural language queries","document collections for indexing","embedding model specifications"],"output_types":["retrieved document chunks with relevance scores","augmented prompts with context","agent responses grounded in retrieved knowledge"],"categories":["memory-knowledge","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"autogen-starter__cap_3","uri":"capability://memory.knowledge.teachable.agent.with.dynamic.knowledge.acquisition","name":"teachable agent with dynamic knowledge acquisition","description":"Implements agents that can learn from user feedback and examples during conversations, updating their behavior without retraining. Uses message history and feedback signals to refine agent responses iteratively. Agents can store learned patterns in memory systems and apply them to future interactions. Enables human-in-the-loop learning where agents improve through interaction.","intents":["I want an agent that learns from corrections and examples I provide during our conversation","I need agents to remember user preferences and adapt their responses over time","I want to teach agents domain-specific patterns without retraining the underlying LLM"],"best_for":["Interactive AI assistants that improve through user feedback","Customer support systems that learn from agent-customer interactions","Educational applications where agents adapt to student learning patterns"],"limitations":["Learning is session-scoped unless explicitly persisted to memory system","No automatic conflict resolution when learned patterns contradict base LLM behavior","Feedback signals must be explicitly provided; no implicit learning from conversation outcomes"],"requires":["Python 3.10+","Memory system for storing learned patterns (autogen-ext)","Feedback mechanism (user ratings, corrections, or explicit labels)","AssistantAgent or custom agent with message history access"],"input_types":["user feedback (corrections, ratings, examples)","conversation history","learned pattern specifications"],"output_types":["updated agent behavior","stored learned patterns","improved responses on similar future queries"],"categories":["memory-knowledge","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"autogen-starter__cap_4","uri":"capability://automation.workflow.human.in.the.loop.agent.approval.and.override.workflows","name":"human-in-the-loop agent approval and override workflows","description":"Enables agents to pause execution and request human approval before taking actions (tool calls, code execution, final responses). Implements bidirectional communication where humans can override agent decisions, provide corrections, or inject new instructions mid-conversation. Uses message subscription and event routing to integrate human feedback into agent decision loops without blocking other agents.","intents":["I need agents to ask for approval before executing potentially risky operations like code or API calls","I want to override agent decisions in real-time without restarting the entire conversation","I need to inject human guidance into agent reasoning mid-task"],"best_for":["High-stakes applications (financial, medical, infrastructure) requiring human oversight","Teams building collaborative human-AI systems with explicit approval gates","Organizations with compliance requirements for AI decision logging and human review"],"limitations":["Approval workflows add latency proportional to human response time; no automatic timeout handling","No built-in UI for human approval — requires custom integration with chat interfaces or dashboards","Concurrent approval requests from multiple agents can create UX complexity without explicit prioritization"],"requires":["Python 3.10+","AgentRuntime with subscription support for message routing","Human interface (web UI, chat platform, CLI) for receiving and responding to approval requests","Mechanism for injecting human responses back into agent message stream"],"input_types":["agent action requests (tool calls, code execution, responses)","human approval/rejection decisions","human-provided corrections or alternative instructions"],"output_types":["approval request notifications","human decision signals","agent execution resumption with human feedback"],"categories":["automation-workflow","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"autogen-starter__cap_5","uri":"capability://code.generation.editing.code.execution.agent.with.sandboxed.environment.management","name":"code execution agent with sandboxed environment management","description":"CodeExecutorAgent provides safe code execution in isolated environments (Docker containers, local Python processes, or remote sandboxes) with resource limits and output capture. Agents can generate code, submit it for execution, and receive results without direct access to the host system. Supports multiple language runtimes and execution strategies configured via autogen-ext implementations.","intents":["I want agents to write and execute code safely without risking the host system","I need to run code generated by agents with resource limits (CPU, memory, timeout)","I want agents to test their code and iterate based on execution results"],"best_for":["Data science and research workflows where agents analyze datasets and generate visualizations","Educational platforms teaching programming with AI assistance","Automated testing and code generation systems requiring execution verification"],"limitations":["Sandbox setup overhead (Docker image pull, container startup) adds 2-5 seconds per execution","Output capture is limited by sandbox I/O constraints; large outputs may be truncated","No automatic dependency installation — code must use pre-installed libraries or explicit pip install"],"requires":["Python 3.10+","Docker (for container-based execution) OR local Python environment with execution permissions","CodeExecutorAgent implementation from autogen-ext","Resource limits configuration (timeout, memory, CPU)"],"input_types":["Python code strings","code generation requests","execution parameters (timeout, resource limits)"],"output_types":["execution results (stdout, stderr)","return values","execution status (success, timeout, error)"],"categories":["code-generation-editing","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"autogen-starter__cap_6","uri":"capability://tool.use.integration.multi.provider.llm.client.abstraction.with.fallback.and.routing","name":"multi-provider llm client abstraction with fallback and routing","description":"ChatCompletionClient protocol abstracts LLM interactions across OpenAI, Anthropic, Azure OpenAI, Ollama, and custom providers. Agents use the same code regardless of underlying LLM provider. Supports configurable routing, fallback chains (try OpenAI, fall back to Anthropic if rate-limited), and provider-specific parameter mapping. Implemented via autogen-ext with native bindings for each provider's API.","intents":["I want agents to work with any LLM provider without changing agent code","I need to switch LLM providers or use multiple providers in parallel for cost/latency optimization","I want automatic fallback to alternative LLM providers if the primary provider fails"],"best_for":["Teams evaluating multiple LLM providers and wanting to switch without code changes","Cost-conscious organizations using cheaper models for simple tasks and premium models for complex reasoning","Enterprises with multi-cloud or on-premises LLM deployments"],"limitations":["Provider-specific features (vision, function calling variants) require conditional code paths","Fallback routing adds latency for failed requests before trying alternative provider","Token counting and cost estimation vary by provider; no unified accounting"],"requires":["Python 3.10+","API keys for desired LLM providers (OpenAI, Anthropic, Azure, etc.)","autogen-ext with provider-specific implementations","Network access to LLM provider APIs or local Ollama instance"],"input_types":["chat messages (system, user, assistant)","tool schemas for function calling","provider configuration (model name, API key, endpoint)"],"output_types":["LLM completions","tool call requests","token usage metadata"],"categories":["tool-use-integration","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"autogen-starter__cap_7","uri":"capability://planning.reasoning.agent.team.composition.with.role.based.specialization","name":"agent team composition with role-based specialization","description":"Enables defining specialized agents with distinct roles (code reviewer, data analyst, researcher, executor) that collaborate on complex tasks. Each agent has configurable system prompts, tools, and capabilities. Teams are composed by instantiating multiple agents and connecting them via BaseGroupChat with role-aware routing. Agents can delegate tasks to teammates based on expertise.","intents":["I want to create a team of specialized agents that each handle different aspects of a problem","I need agents to recognize when a task is outside their expertise and delegate to a specialist","I want to define clear roles and responsibilities for agents in a multi-agent system"],"best_for":["Complex problem-solving workflows requiring multiple skill domains (code, analysis, research)","Organizations simulating team dynamics with AI agents","Research projects studying multi-agent collaboration patterns"],"limitations":["Role definition is manual; no automatic role inference from task requirements","Delegation logic must be explicitly programmed or learned; no built-in expertise matching","Team coordination overhead increases with agent count; no automatic load balancing"],"requires":["Python 3.10+","Multiple AssistantAgent or specialized agent instances","BaseGroupChat implementation for team orchestration","Role-specific system prompts and tool configurations"],"input_types":["task descriptions","role definitions (system prompts, tools, capabilities)","agent specialization parameters"],"output_types":["team conversation transcripts","role-specific outputs","final team decision or solution"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"autogen-starter__cap_8","uri":"capability://planning.reasoning.termination.condition.evaluation.for.conversation.control","name":"termination condition evaluation for conversation control","description":"Implements pluggable termination conditions that evaluate after each agent turn to determine if a group chat should end. Supports conditions like 'max turns reached', 'agent votes to stop', 'specific keyword detected', or custom logic. Termination is evaluated asynchronously without blocking other agents. Provides termination reason and final state to enable post-conversation analysis.","intents":["I want conversations to end automatically when a solution is found or max iterations reached","I need agents to vote on whether to continue or stop a conversation","I want to detect when agents reach consensus or deadlock and terminate appropriately"],"best_for":["Autonomous multi-agent systems that need to self-terminate without external intervention","Cost-conscious applications where conversation length directly impacts LLM costs","Research studying agent consensus and decision-making"],"limitations":["Termination evaluation adds latency after each turn; complex conditions can add 100-500ms","No built-in deadlock detection; custom conditions required for sophisticated termination logic","Termination is immediate once condition is met; no graceful shutdown or cleanup phase"],"requires":["Python 3.10+","BaseGroupChat implementation","Termination condition class implementing required interface","Access to agent messages and conversation state"],"input_types":["termination condition definitions","agent messages and conversation history","custom condition parameters"],"output_types":["boolean termination signal","termination reason string","final conversation state"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"autogen-starter__cap_9","uri":"capability://automation.workflow.graphflow.task.orchestration.with.dag.based.agent.workflows","name":"graphflow task orchestration with dag-based agent workflows","description":"GraphFlow enables defining agent workflows as directed acyclic graphs (DAGs) where nodes are agents or tasks and edges represent dependencies. Agents execute in topological order with automatic parallelization of independent branches. Supports conditional branching based on agent outputs and dynamic task injection. Integrates with AgentRuntime for distributed execution across multiple workers.","intents":["I want to define complex multi-step workflows where agents depend on outputs from other agents","I need to parallelize independent agent tasks for faster execution","I want to implement conditional logic where agent outputs determine which agents run next"],"best_for":["Data processing pipelines with multiple transformation stages","Research workflows requiring sequential analysis steps","Organizations automating complex business processes with AI agents"],"limitations":["DAG construction requires upfront planning; dynamic task injection adds complexity","No automatic cycle detection; circular dependencies cause runtime hangs","Distributed execution via GrpcWorkerAgentRuntime adds network latency and requires infrastructure setup"],"requires":["Python 3.10+","GraphFlow implementation from autogen-agentchat","Agent instances for each DAG node","For distributed execution: GrpcWorkerAgentRuntime and worker processes"],"input_types":["DAG definition (nodes, edges, dependencies)","agent configurations","initial task inputs"],"output_types":["execution results from each node","final workflow output","execution trace with timing"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"autogen-starter__headline","uri":"capability://app.builders.multi.agent.ai.application.framework","name":"multi-agent ai application framework","description":"AutoGen Starter is a framework for building multi-agent AI applications that facilitate collaborative interactions between agents and humans, supporting customizable workflows and retrieval-augmented generation.","intents":["best multi-agent framework","multi-agent system for collaborative AI","how to build AI agents","RAG framework for multi-agent applications","AI conversation patterns for development"],"best_for":["developers building AI applications","teams needing collaborative AI solutions"],"limitations":[],"requires":["Python 3.10+ or .NET 8.0+"],"input_types":["agent configurations","conversation patterns"],"output_types":["multi-agent interactions","customizable workflows"],"categories":["app-builders","rag-knowledge"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":56,"verified":false,"data_access_risk":"high","permissions":["Python 3.10+","autogen-core and autogen-agentchat packages","At least one ChatCompletionClient implementation (OpenAI, Anthropic, or local LLM via autogen-ext)","ChatCompletionClient implementation (OpenAI API key, Anthropic key, or local Ollama instance)","For code execution: Python environment or Docker container with execution permissions","autogen-ext for CodeExecutorAgent implementations","MCP integration from autogen-ext","MCP server(s) running and accessible (local or remote)","MCP client library for protocol communication","GrpcWorkerAgentRuntime from autogen-core"],"failure_modes":["Termination conditions are evaluated after each agent turn, adding latency proportional to conversation length","No built-in persistence of conversation state — requires external storage for audit trails","Message routing complexity increases with agent count; no automatic load balancing across distributed runtimes","Code execution requires explicit sandbox setup (Docker, local Python environment); no built-in isolation","Tool schema validation adds ~50-100ms per tool call for complex schemas","No automatic tool discovery — tools must be explicitly registered in agent configuration","MCP server discovery and connection adds startup latency (100-500ms per server)","Tool schema translation from MCP to agent format may lose provider-specific features","No built-in caching of MCP tool schemas; repeated discovery calls hit the server","gRPC communication adds 10-50ms latency per agent message vs local execution","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.7,"quality":0.9,"ecosystem":0.49999999999999994,"match_graph":0.25,"freshness":0.52,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.1,"match_graph":0.35,"freshness":0.05}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-06-17T09:51:02.370Z","last_scraped_at":null,"last_commit":null},"community":{"stars":null,"forks":null,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=autogen-starter","compare_url":"https://unfragile.ai/compare?artifact=autogen-starter"}},"signature":"/LcVqVzc2IPzr4G/WvowhbZV6XkIeVrs76pF8cfAiWMIZ4/Xm3AwwxIfkHqI5U0whI2/7mGgXYzhr/qow+5ECg==","signedAt":"2026-06-20T02:22:09.972Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/autogen-starter","artifact":"https://unfragile.ai/autogen-starter","verify":"https://unfragile.ai/api/v1/verify?slug=autogen-starter","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"}}