{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-microsoft--taskweaver","slug":"microsoft--taskweaver","name":"TaskWeaver","type":"agent","url":"https://microsoft.github.io/TaskWeaver/","page_url":"https://unfragile.ai/microsoft--taskweaver","categories":["data-analysis"],"tags":["agent","ai-agents","code-interpreter","copilot","data-analysis","llm","openai"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-microsoft--taskweaver__cap_0","uri":"capability://planning.reasoning.code.first.task.planning.with.llm.driven.decomposition","name":"code-first task planning with llm-driven decomposition","description":"Transforms natural language user requests into executable Python code snippets through a Planner role that decomposes tasks into sub-steps. The Planner uses LLM prompts (planner_prompt.yaml) to generate structured code rather than text-only plans, maintaining awareness of available plugins and code execution history. This approach preserves both chat history and code execution state (including in-memory DataFrames) across multiple interactions, enabling stateful multi-turn task orchestration.","intents":["I want to break down a complex data analytics task into executable steps automatically","I need the agent to understand what code it previously executed and build on that state","I want to avoid re-explaining context across multiple requests in a session"],"best_for":["data analysts building multi-step analytics workflows","teams automating repetitive data processing pipelines","developers prototyping agents that need stateful execution"],"limitations":["Planner decomposition quality depends on LLM capability; weaker models may produce suboptimal task breakdowns","State preservation is in-memory only within a session; no built-in persistence across sessions without external storage","Complex nested task dependencies may require manual intervention if the Planner's decomposition is incorrect"],"requires":["Python 3.9+","API key for OpenAI, Anthropic, or compatible LLM provider","TaskWeaver framework installed from source or pip"],"input_types":["natural language task description","code snippets (optional, for context)","plugin definitions (YAML)"],"output_types":["executable Python code","task decomposition plan","execution status and results"],"categories":["planning-reasoning","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-microsoft--taskweaver__cap_1","uri":"capability://planning.reasoning.multi.role.agent.orchestration.with.controlled.communication","name":"multi-role agent orchestration with controlled communication","description":"Implements a role-based architecture where specialized agents (Planner, CodeInterpreter, External Roles like WebExplorer) communicate exclusively through the Planner as a central hub. Each role has a specific responsibility: the Planner orchestrates, CodeInterpreter generates/executes Python code, and External Roles handle domain-specific tasks. Communication flows through a message-passing system that ensures controlled conversation flow and prevents direct agent-to-agent coupling.","intents":["I want to add specialized agents (e.g., web search, image processing) without breaking existing orchestration","I need to ensure all agent interactions are logged and auditable","I want to swap out the code execution backend without changing agent logic"],"best_for":["teams building extensible multi-agent systems for data workflows","organizations requiring audit trails of agent interactions","developers implementing domain-specific external roles (WebExplorer, ImageReader, etc.)"],"limitations":["All communication routing through Planner adds latency (~50-200ms per message) compared to direct agent communication","Adding new roles requires implementing the role interface and registering with the Planner; no dynamic role discovery","External roles must be pre-defined in configuration; runtime role creation is not supported"],"requires":["Python 3.9+","Role implementation following TaskWeaver's role interface","Configuration file defining available roles and their capabilities"],"input_types":["role definitions (Python classes)","role configuration (YAML)","messages (structured JSON)"],"output_types":["role responses (structured JSON)","execution logs","role availability metadata"],"categories":["planning-reasoning","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-microsoft--taskweaver__cap_10","uri":"capability://automation.workflow.observability.and.execution.tracing","name":"observability and execution tracing","description":"Provides comprehensive logging and tracing of agent execution, including LLM prompts/responses, code generation, execution results, and inter-role communication. Tracing is implemented via an event emitter system (event_emitter.py) that captures execution events at each stage. Logs can be exported for debugging, auditing, and performance analysis. Integration with observability platforms (e.g., OpenTelemetry) is supported for production monitoring.","intents":["I want to debug why the agent made a particular decision or generated incorrect code","I need to audit all agent actions for compliance or security purposes","I want to monitor agent performance and identify bottlenecks"],"best_for":["teams deploying agents to production with compliance requirements","developers debugging agent behavior and LLM interactions","organizations monitoring agent performance and cost"],"limitations":["Verbose logging can generate large log files; no built-in log rotation or compression","Tracing adds overhead (~5-10% latency per event); high-frequency tracing can impact performance","Log storage and analysis require external infrastructure (e.g., ELK stack, Datadog); no built-in log aggregation","Sensitive data (API keys, user inputs) may be logged; requires careful configuration to avoid leaking secrets"],"requires":["Python 3.9+","Logging configuration (log level, output format)","Optional: observability platform integration (OpenTelemetry, Datadog, etc.)"],"input_types":["execution events (LLM calls, code execution, role communication)"],"output_types":["structured logs (JSON or text)","execution traces (timeline of events)","performance metrics (latency, token usage)"],"categories":["automation-workflow","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-microsoft--taskweaver__cap_11","uri":"capability://automation.workflow.configuration.and.verification.system","name":"configuration and verification system","description":"Externalizes agent configuration (LLM provider, plugins, roles, execution limits) into YAML files, enabling users to customize behavior without code changes. The configuration system includes validation to ensure required settings are present and correct (e.g., API keys, plugin paths). Configuration is loaded at startup and can be reloaded without restarting the agent. Supports environment variable substitution for sensitive values (API keys).","intents":["I want to configure the agent (LLM provider, plugins, roles) without modifying code","I need to validate configuration before running the agent","I want to use different configurations for development, testing, and production"],"best_for":["teams deploying agents across multiple environments","organizations with non-technical users who need to customize agent behavior","developers building agent platforms with pluggable configurations"],"limitations":["Configuration validation is basic; complex constraints (e.g., plugin compatibility) are not checked","Configuration changes require agent restart (except for some dynamic settings); no hot-reload for all settings","YAML syntax errors can be cryptic; no built-in schema validation or helpful error messages","Environment variable substitution is limited to string values; complex types require manual parsing"],"requires":["Python 3.9+","YAML configuration files","Environment variables for sensitive values (optional)"],"input_types":["YAML configuration files","environment variables"],"output_types":["parsed configuration (Python dict)","validation errors (if configuration is invalid)"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-microsoft--taskweaver__cap_12","uri":"capability://automation.workflow.evaluation.and.testing.framework","name":"evaluation and testing framework","description":"Provides tools for evaluating agent performance on benchmark tasks and testing agent behavior. The evaluation framework includes pre-built datasets (e.g., data analytics tasks) and metrics for measuring success (task completion, code correctness, execution time). Testing utilities enable unit testing of individual components (Planner, CodeInterpreter, plugins) and integration testing of full workflows. Results are aggregated and reported for comparison across LLM providers or agent configurations.","intents":["I want to benchmark my agent against standard datasets to measure performance","I need to test agent behavior before deploying to production","I want to compare different LLM providers or configurations"],"best_for":["teams evaluating agent quality and performance","researchers benchmarking agent frameworks","developers testing agent behavior before production deployment"],"limitations":["Evaluation datasets are limited to data analytics tasks; custom domains require manual dataset creation","Metrics are task-specific; no universal metrics for all agent types","Evaluation is time-consuming (requires multiple LLM API calls); can be expensive for large benchmarks","No built-in statistical significance testing; results may vary due to LLM stochasticity"],"requires":["Python 3.9+","Evaluation datasets (provided or custom)","LLM API keys for evaluation runs","TaskWeaver framework with evaluation utilities"],"input_types":["evaluation tasks (natural language descriptions)","expected outputs (for comparison)"],"output_types":["evaluation results (success/failure, metrics)","performance reports (aggregated metrics)","comparison reports (across configurations)"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-microsoft--taskweaver__cap_13","uri":"capability://data.processing.analysis.json.processing.and.structured.data.handling","name":"json processing and structured data handling","description":"Provides utilities for parsing, validating, and manipulating JSON data throughout the agent workflow. JSON is used for inter-role communication (messages), plugin definitions, configuration, and execution results. The JSON processing layer handles serialization/deserialization of Python objects (DataFrames, custom types) to/from JSON, with support for custom encoders/decoders. Validation ensures JSON conforms to expected schemas.","intents":["I want to serialize Python objects (DataFrames, custom types) for inter-role communication","I need to validate JSON data against schemas","I want to handle JSON parsing errors gracefully"],"best_for":["teams building multi-role agents with JSON-based communication","developers handling complex data structures in agent workflows","organizations with strict data validation requirements"],"limitations":["Custom type serialization requires manual encoder/decoder implementation; no automatic schema generation","Large DataFrames may be inefficient to serialize to JSON; requires custom compression or streaming","JSON schema validation is optional; no enforcement of schema compliance","Parsing errors are generic; no helpful error messages for schema violations"],"requires":["Python 3.9+","JSON schema definitions (optional)","Custom encoders/decoders for non-standard types (optional)"],"input_types":["JSON strings or dicts","Python objects (DataFrames, custom types)"],"output_types":["parsed JSON (dicts)","serialized JSON (strings)","validation results (pass/fail with errors)"],"categories":["data-processing-analysis","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-microsoft--taskweaver__cap_2","uri":"capability://code.generation.editing.python.code.generation.and.execution.with.plugin.integration","name":"python code generation and execution with plugin integration","description":"The CodeInterpreter role generates executable Python code based on task requirements and executes it in an isolated runtime environment. Code generation is LLM-driven and context-aware, with access to plugin definitions that wrap custom algorithms as callable functions. The Code Execution Service sandboxes execution, captures output/errors, and returns results back to the Planner. Plugins are defined via YAML configs that specify function signatures, enabling the LLM to generate correct function calls.","intents":["I want to execute arbitrary Python code as part of an agent workflow without manual script writing","I need to call custom business logic (plugins) from generated code safely","I want to capture and return code execution results (stdout, variables, errors) to the agent"],"best_for":["data scientists automating pandas/numpy workflows","teams wrapping proprietary algorithms as plugins for agent access","developers building code-generation agents for data transformation"],"limitations":["Code execution is sandboxed but not fully isolated; malicious code could still access the host filesystem if permissions allow","Generated code quality depends on LLM capability; complex algorithms may require manual refinement","Plugin YAML definitions must be manually maintained; no automatic schema inference from Python functions","Execution timeout and memory limits must be configured; runaway code can hang the agent"],"requires":["Python 3.9+ with pandas, numpy (for data analytics use cases)","Plugin definitions in YAML format with function signatures","Code Execution Service running (local or remote)","LLM API key for code generation"],"input_types":["natural language task description","plugin definitions (YAML)","execution context (variables, DataFrames)"],"output_types":["executable Python code (string)","execution results (stdout, return values)","error messages and tracebacks","updated execution state (variables)"],"categories":["code-generation-editing","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-microsoft--taskweaver__cap_3","uri":"capability://tool.use.integration.plugin.system.with.yaml.based.function.wrapping","name":"plugin system with yaml-based function wrapping","description":"Extends TaskWeaver's functionality by wrapping custom algorithms and tools into callable functions via a plugin architecture. Plugins are defined declaratively in YAML configs that specify function names, parameters, return types, and descriptions. The plugin system registers these definitions with the CodeInterpreter, enabling the LLM to generate correct function calls with proper argument passing. Plugins can wrap Python functions, external APIs, or domain-specific tools (e.g., data validation, ML model inference).","intents":["I want to expose my custom business logic to the agent without modifying the framework","I need the agent to know what functions are available and their signatures","I want to add new capabilities (e.g., database queries, API calls) without recompiling"],"best_for":["teams building domain-specific agent applications with custom tools","organizations wrapping legacy code as plugins for agent access","developers extending TaskWeaver without forking the codebase"],"limitations":["Plugin YAML configs must be manually written and maintained; no automatic schema generation from Python docstrings","Plugin discovery is static (defined at startup); runtime plugin registration is not supported","Type hints in YAML are limited to basic types (string, int, float, list, dict); complex nested types require custom serialization","Plugin execution errors are returned as strings; no structured error handling or retry logic built-in"],"requires":["Python 3.9+","Plugin implementation (Python function or class)","YAML config file with function signature and metadata","TaskWeaver framework installed"],"input_types":["plugin implementation (Python callable)","YAML configuration (function name, parameters, description, return type)","function arguments (passed from generated code)"],"output_types":["function return value (any Python type)","execution logs","error messages"],"categories":["tool-use-integration","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-microsoft--taskweaver__cap_4","uri":"capability://memory.knowledge.session.based.memory.and.state.management","name":"session-based memory and state management","description":"Manages session lifecycle and preserves execution state across multiple user interactions. Sessions maintain both chat history (text messages) and code execution history (generated code, results, variable state). The Session Manager handles session creation, persistence, and cleanup. Memory is implemented via an Attachment system that stores DataFrames, variables, and other Python objects in-memory, enabling subsequent code generations to reference previous results without serialization.","intents":["I want to continue a multi-turn conversation without re-explaining context","I need the agent to remember variables and DataFrames from previous steps","I want to pause and resume a workflow across multiple user interactions"],"best_for":["interactive data analysis workflows where users refine queries iteratively","long-running analytics pipelines that span multiple user sessions","teams collaborating on shared analysis tasks"],"limitations":["Session state is in-memory only; no built-in persistence to disk or database (requires external integration)","Large DataFrames in memory can consume significant RAM; no automatic garbage collection or eviction policies","Session isolation is process-level; concurrent sessions in the same process may interfere if not properly isolated","No built-in session timeout or expiration; sessions persist until explicitly closed"],"requires":["Python 3.9+","TaskWeaver framework with Session Manager","Sufficient RAM to hold in-memory state (DataFrames, variables)"],"input_types":["session ID (string)","user messages (text)","code execution results"],"output_types":["session state (variables, DataFrames)","chat history","execution history","session metadata"],"categories":["memory-knowledge","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-microsoft--taskweaver__cap_5","uri":"capability://text.generation.language.llm.provider.abstraction.with.multi.provider.support","name":"llm provider abstraction with multi-provider support","description":"Abstracts LLM interactions behind a provider interface that supports multiple LLM backends (OpenAI, Anthropic, local models via Ollama, Keywords AI, etc.). The LLM Integration layer handles API calls, prompt formatting, token counting, and response parsing. Configuration is externalized (YAML), allowing users to switch LLM providers without code changes. Supports both chat-based and completion-based LLM APIs with consistent error handling and retry logic.","intents":["I want to use different LLM providers (OpenAI, Anthropic, local) interchangeably","I need to switch LLM providers without modifying agent code","I want to use cost-effective local models instead of cloud APIs"],"best_for":["teams evaluating multiple LLM providers for cost/performance tradeoffs","organizations with on-premises requirements using local LLMs","developers building LLM-agnostic agent frameworks"],"limitations":["LLM provider switching requires configuration changes and may affect prompt compatibility (different models have different instruction-following capabilities)","Token counting is approximate for non-OpenAI models; actual token usage may differ","Retry logic is generic; provider-specific error handling (rate limits, quota exceeded) requires custom implementation","Local LLM support (Ollama) requires running a separate Ollama server; no built-in model management"],"requires":["Python 3.9+","API key for chosen LLM provider (OpenAI, Anthropic, etc.) OR Ollama server running locally","Configuration file specifying LLM provider and model name"],"input_types":["prompts (text)","system messages (text)","chat history (structured messages)"],"output_types":["LLM responses (text)","token usage metadata","error messages"],"categories":["text-generation-language","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-microsoft--taskweaver__cap_6","uri":"capability://code.generation.editing.code.execution.service.with.sandboxing.and.error.capture","name":"code execution service with sandboxing and error capture","description":"Provides a sandboxed runtime environment for executing generated Python code. The Code Execution Service spawns a Python kernel, executes code snippets, captures stdout/stderr, handles exceptions, and returns results. Execution is isolated from the main agent process to prevent crashes or security issues. Supports timeout limits to prevent runaway code. Results (return values, variable state) are captured and made available to subsequent code generations.","intents":["I want to execute generated code safely without crashing the agent","I need to capture code output and errors for debugging","I want to prevent infinite loops or resource exhaustion from hanging the agent"],"best_for":["production agent deployments requiring code execution safety","teams running untrusted or auto-generated code","developers debugging agent-generated code"],"limitations":["Sandboxing is process-level, not container-level; determined attackers could escape via OS vulnerabilities","Timeout enforcement is approximate; code may exceed timeout before being killed","Memory limits are not enforced; large DataFrames can consume all available RAM","Execution errors are captured as strings; no structured error types or recovery suggestions"],"requires":["Python 3.9+","Code Execution Service running (local or remote)","Timeout and resource limit configuration"],"input_types":["Python code (string)","execution context (variables, imports)","timeout limit (seconds)"],"output_types":["execution result (return value or None)","stdout/stderr (text)","error traceback (text)","execution time (seconds)","updated variable state"],"categories":["code-generation-editing","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-microsoft--taskweaver__cap_7","uri":"capability://tool.use.integration.external.role.integration.for.domain.specific.tasks","name":"external role integration for domain-specific tasks","description":"Enables integration of specialized external roles (e.g., WebExplorer for web search, ImageReader for image analysis) that handle domain-specific tasks outside the core Planner/CodeInterpreter loop. External roles communicate with the Planner via the same message-passing interface, allowing them to be composed into workflows. Each external role implements a specific capability (web search, image processing, database queries) and returns results that can be consumed by the CodeInterpreter.","intents":["I want to add web search capability to my agent without implementing it from scratch","I need to process images or PDFs as part of my workflow","I want to query databases or external APIs through specialized roles"],"best_for":["teams building multi-modal agents (text, images, web data)","organizations integrating external services (web search, database queries) into workflows","developers extending TaskWeaver with domain-specific capabilities"],"limitations":["External roles must be pre-implemented; no automatic role generation from API specs","Communication with external roles adds latency; web search or API calls may take seconds","External role failures are not automatically retried; error handling is delegated to the Planner","No built-in caching of external role results; repeated queries incur full latency"],"requires":["Python 3.9+","External role implementation (Python class)","API keys or credentials for external services (e.g., web search API, database connection)","Configuration defining available external roles"],"input_types":["role request (structured message)","query parameters (task-specific)"],"output_types":["role response (structured data)","search results, images, database records, etc.","error messages"],"categories":["tool-use-integration","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-microsoft--taskweaver__cap_8","uri":"capability://automation.workflow.console.and.web.ui.interfaces.for.agent.interaction","name":"console and web ui interfaces for agent interaction","description":"Provides multiple user interfaces for interacting with TaskWeaver agents: a console CLI for terminal-based interaction and a web UI for browser-based access. Both interfaces handle session management, display chat history and code execution results, and allow users to provide feedback or corrections. The web UI includes visualization of task decomposition and execution flow. Interfaces are decoupled from the core agent logic via a session API.","intents":["I want to interact with the agent via command line for scripting and automation","I need a web interface for non-technical users to run analytics workflows","I want to visualize task decomposition and execution flow"],"best_for":["developers building agent applications with multiple interaction modes","teams deploying agents to non-technical users via web UI","data analysts using CLI for reproducible workflows"],"limitations":["Web UI requires separate deployment (web server, frontend framework); adds operational complexity","Console UI is text-only; no rich visualization of results (charts, tables require external tools)","Both interfaces are stateless from the agent's perspective; session state is managed server-side","No built-in authentication or multi-user support; requires external auth layer for production"],"requires":["Python 3.9+ for console UI","Node.js and web framework (React, Vue, etc.) for web UI","TaskWeaver framework with UI components"],"input_types":["user text input (natural language queries)","session ID (for resuming sessions)"],"output_types":["chat messages (text)","code snippets (syntax-highlighted)","execution results (text, tables, charts)","task decomposition visualization"],"categories":["automation-workflow","text-generation-language"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-microsoft--taskweaver__cap_9","uri":"capability://planning.reasoning.task.decomposition.with.execution.history.awareness","name":"task decomposition with execution history awareness","description":"The Planner decomposes complex user requests into executable sub-tasks while maintaining awareness of the execution history (previous code, results, variables). Decomposition is LLM-driven and uses prompts (planner_prompt.yaml) that include context about available plugins, previous executions, and task dependencies. The Planner generates a task plan as code, executes it via the CodeInterpreter, and iteratively refines the plan based on execution results.","intents":["I want the agent to break down a complex analytics task into manageable steps automatically","I need the agent to adapt its plan based on intermediate results","I want to understand how the agent decomposed my request"],"best_for":["data analysts with complex multi-step workflows","teams automating exploratory data analysis","developers building agents that need to handle ambiguous or open-ended requests"],"limitations":["Decomposition quality depends on LLM capability; weaker models may produce suboptimal or incorrect plans","Plan adaptation is reactive (based on execution results); no proactive planning for potential failures","Complex task dependencies may require manual intervention if the Planner's decomposition is incorrect","No built-in plan validation; incorrect plans are only detected during execution"],"requires":["Python 3.9+","LLM API key for Planner prompts","Planner prompt configuration (planner_prompt.yaml)","Plugin definitions for the Planner to reference"],"input_types":["user request (natural language)","execution history (previous code, results)","plugin definitions (YAML)"],"output_types":["task decomposition plan (code)","execution results","refined plan (if adaptation is needed)"],"categories":["planning-reasoning","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":44,"verified":false,"data_access_risk":"high","permissions":["Python 3.9+","API key for OpenAI, Anthropic, or compatible LLM provider","TaskWeaver framework installed from source or pip","Role implementation following TaskWeaver's role interface","Configuration file defining available roles and their capabilities","Logging configuration (log level, output format)","Optional: observability platform integration (OpenTelemetry, Datadog, etc.)","YAML configuration files","Environment variables for sensitive values (optional)","Evaluation datasets (provided or custom)"],"failure_modes":["Planner decomposition quality depends on LLM capability; weaker models may produce suboptimal task breakdowns","State preservation is in-memory only within a session; no built-in persistence across sessions without external storage","Complex nested task dependencies may require manual intervention if the Planner's decomposition is incorrect","All communication routing through Planner adds latency (~50-200ms per message) compared to direct agent communication","Adding new roles requires implementing the role interface and registering with the Planner; no dynamic role discovery","External roles must be pre-defined in configuration; runtime role creation is not supported","Verbose logging can generate large log files; no built-in log rotation or compression","Tracing adds overhead (~5-10% latency per event); high-frequency tracing can impact performance","Log storage and analysis require external infrastructure (e.g., ELK stack, Datadog); no built-in log aggregation","Sensitive data (API keys, user inputs) may be logged; requires careful configuration to avoid leaking secrets","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.6181959491117816,"quality":0.35,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.6,"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:22.062Z","last_scraped_at":"2026-05-03T13:58:39.623Z","last_commit":"2026-03-23T06:17:21Z"},"community":{"stars":6156,"forks":774,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=microsoft--taskweaver","compare_url":"https://unfragile.ai/compare?artifact=microsoft--taskweaver"}},"signature":"SN6DkEAkWVWuU7HI5rPBsBn9WVZEqmTn/Uu3wPZq2IDBYGJIjKxs1BVJhuA6TD9CnFrQHbTgcjevfKCSODHfCg==","signedAt":"2026-06-21T19:26:09.397Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/microsoft--taskweaver","artifact":"https://unfragile.ai/microsoft--taskweaver","verify":"https://unfragile.ai/api/v1/verify?slug=microsoft--taskweaver","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"}}