{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"composio","slug":"composio","name":"Composio","type":"repo","url":"https://github.com/ComposioHQ/composio","page_url":"https://unfragile.ai/composio","categories":["ai-agents"],"tags":[],"pricing":{"model":"free","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"composio__cap_0","uri":"capability://tool.use.integration.multi.framework.agent.tool.binding.with.unified.schema.translation","name":"multi-framework agent tool binding with unified schema translation","description":"Composio translates tool definitions into framework-specific formats (LangChain tool_choice, CrewAI @tool decorators, AutoGen function_map, OpenAI function_calling) via provider packages that wrap the core SDK. Each provider package implements a framework adapter that converts Composio's OpenAPI-based tool schemas into native function-calling conventions, enabling agents to discover and invoke tools without framework-specific boilerplate. The routing happens through a session-based tool router that maintains authentication context across framework calls.","intents":["I want to use the same tool integrations across LangChain, CrewAI, and AutoGen without rewriting tool definitions","I need my agent to call GitHub, Slack, and Jira APIs without managing separate SDK integrations for each framework","I want to switch agent frameworks without losing my tool setup"],"best_for":["teams building multi-framework agent systems","developers migrating between LangChain and CrewAI","enterprises standardizing on Composio as the tool layer across heterogeneous agent stacks"],"limitations":["Framework adapters add ~50-150ms overhead per tool invocation due to schema translation","Custom tool modifiers only work within Composio's modifier system, not directly in framework-native tool definitions","Some framework-specific features (e.g., parallel tool calling in OpenAI) require explicit provider-level support"],"requires":["Python 3.9+ or Node.js 18+","One of: LangChain 0.1+, CrewAI 0.1+, AutoGen 0.2+, or OpenAI SDK 1.0+","Composio API key from backend.composio.dev"],"input_types":["OpenAPI schema (internal representation)","Framework-native tool definitions (output from adapters)"],"output_types":["LangChain StructuredTool objects","CrewAI @tool decorated functions","AutoGen function_map dictionaries","OpenAI function_calling JSON schemas"],"categories":["tool-use-integration","framework-abstraction"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"composio__cap_1","uri":"capability://tool.use.integration.oauth.2.0.and.api.key.credential.management.with.automatic.token.refresh","name":"oauth 2.0 and api key credential management with automatic token refresh","description":"Composio's authentication system handles OAuth 2.0 flows, API key storage, and custom auth schemes through a centralized credential manager at the backend API. When an agent needs to call a tool (e.g., GitHub API), Composio retrieves the stored credential from the backend, automatically refreshes OAuth tokens if expired, and injects the auth header into the outgoing request. Credentials are stored server-side with encryption, and the SDK never handles raw secrets locally—only credential IDs are passed to agents.","intents":["I want my agent to authenticate with GitHub, Google, Slack without hardcoding API keys","I need OAuth tokens to refresh automatically so my agent doesn't fail mid-execution","I want to revoke a tool's access without redeploying my agent code"],"best_for":["production agents requiring secure credential handling","multi-tenant SaaS platforms where users connect their own tool accounts","teams with compliance requirements (SOC 2, HIPAA) for credential storage"],"limitations":["Credential refresh adds ~200-500ms latency on first tool call after token expiry","Custom auth schemes (non-OAuth, non-API-key) require manual implementation via custom tool modifiers","No local credential caching—all auth checks hit the backend API, creating a hard dependency on Composio's backend availability"],"requires":["Composio API key for backend authentication","OAuth app credentials (client_id, client_secret) for each OAuth-protected service","Network access to backend.composio.dev for credential retrieval"],"input_types":["OAuth authorization codes","API keys (plain text, encrypted in transit)","Custom auth tokens"],"output_types":["Authorization headers (Bearer tokens, API-Key headers)","Credential metadata (expiry time, scopes, connected account ID)"],"categories":["tool-use-integration","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"composio__cap_10","uri":"capability://tool.use.integration.cli.tool.for.local.development.toolkit.exploration.and.authentication.setup","name":"cli tool for local development, toolkit exploration, and authentication setup","description":"Composio provides a CLI (@composio/cli for TypeScript, composio CLI for Python) that enables developers to explore toolkits, test tool execution locally, and manage authentication without writing code. The CLI includes commands to list available toolkits, view tool schemas, test tool calls with sample parameters, and authenticate with external services. The CLI is built as a binary (via pkg for Node.js, PyInstaller for Python) and can be distributed standalone without requiring SDK installation.","intents":["I want to explore available Composio tools without reading documentation","I need to test a tool locally before integrating it into my agent","I want to authenticate with GitHub/Slack/etc. via CLI without writing code"],"best_for":["developers prototyping agents locally","teams onboarding new developers to Composio","quick exploration and testing workflows"],"limitations":["CLI is read-only for tool discovery—tool registration requires SDK or web UI","Authentication via CLI is session-based and doesn't persist across restarts without manual setup","CLI testing doesn't support complex workflows (multi-step tool chains, conditional logic)","Error messages may be less detailed than SDK errors due to CLI output constraints"],"requires":["Node.js 18+ (for TypeScript CLI) or Python 3.9+ (for Python CLI)","Composio API key (for authenticated commands)"],"input_types":["CLI command (string)","Tool name and parameters (for testing)"],"output_types":["Toolkit list (formatted table)","Tool schema (JSON or formatted text)","Tool execution result"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"composio__cap_11","uri":"capability://tool.use.integration.toolkit.version.management.with.independent.versioning.and.backward.compatibility","name":"toolkit version management with independent versioning and backward compatibility","description":"Composio manages toolkit versions independently—each toolkit (GitHub, Slack, Jira, etc.) has its own version number and release cycle. Agents can pin specific toolkit versions, enabling controlled updates without forcing all toolkits to upgrade together. The backend API supports multiple toolkit versions simultaneously, allowing gradual migration from old to new schemas. Breaking changes in toolkit schemas trigger major version bumps, and the SDK provides deprecation warnings for outdated versions.","intents":["I want to pin my agent to a specific GitHub toolkit version to avoid breaking changes","I need to migrate from GitHub toolkit v1 to v2 without affecting my Slack integration","I want to know when a toolkit version is deprecated so I can plan upgrades"],"best_for":["production agents requiring stability","teams with long-lived agent deployments","platforms managing multiple toolkit versions for different customers"],"limitations":["Version pinning requires explicit configuration—default behavior uses latest version","Backward compatibility is not guaranteed across major versions—breaking changes require code updates","Version metadata is not cached locally—agents must query the backend for version information","No automatic migration path between major versions—developers must manually update code"],"requires":["Composio SDK","Explicit version specification in agent code or configuration"],"input_types":["Toolkit name and version (e.g., 'github@2.0.0')"],"output_types":["Toolkit schema for specified version","Deprecation warnings (if applicable)"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"composio__cap_12","uri":"capability://tool.use.integration.agent.framework.provider.packages.with.native.integration.patterns","name":"agent framework provider packages with native integration patterns","description":"Composio provides framework-specific provider packages (composio-langchain, composio-crewai, @composio/langchain, etc.) that implement native integration patterns for each framework. For LangChain, the provider exports StructuredTool objects that integrate with LangChain's tool_choice mechanism. For CrewAI, the provider exports decorated functions that work with CrewAI's @tool decorator. For AutoGen, the provider exports function_map dictionaries. Each provider package handles framework-specific details (tool calling conventions, error handling, async patterns) transparently.","intents":["I want to use Composio tools in LangChain without writing custom tool wrappers","I need my CrewAI agents to call Composio tools with native @tool decorators","I want to integrate Composio into AutoGen without custom function_map boilerplate"],"best_for":["developers using LangChain, CrewAI, or AutoGen","teams wanting native framework integration without custom wrappers","rapid prototyping with minimal boilerplate"],"limitations":["Provider packages must be updated when frameworks release breaking changes","Framework-specific features (e.g., parallel tool calling) may not be supported by all providers","Provider packages add dependency bloat if only using one framework","Custom tool modifiers may not work with all framework-native tool patterns"],"requires":["Composio SDK (Python or TypeScript)","Framework-specific provider package (composio-langchain, composio-crewai, etc.)","Target framework (LangChain, CrewAI, AutoGen, etc.)"],"input_types":["Framework-specific tool configuration"],"output_types":["Framework-native tool objects (StructuredTool, @tool decorated functions, function_map)"],"categories":["tool-use-integration","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"composio__cap_2","uri":"capability://tool.use.integration.session.based.tool.routing.with.stateful.authentication.context","name":"session-based tool routing with stateful authentication context","description":"Composio uses sessions to maintain authentication state and tool availability across multiple agent calls. When an agent creates a session, Composio binds a set of connected accounts (authenticated credentials) to that session. The session-based tool router then ensures that all tool invocations within that session use the correct credentials. Sessions can be scoped to users, conversations, or workflows, enabling multi-tenant isolation and per-user tool access control without re-authenticating on each call.","intents":["I want to isolate tool access per user so Agent A can only use User A's GitHub account","I need to maintain authentication state across multiple agent turns without re-authenticating","I want to revoke a user's tool access by deleting their session without affecting other users"],"best_for":["multi-tenant agent platforms","conversational agents that need persistent user context","workflows requiring per-user tool isolation"],"limitations":["Sessions are ephemeral by default—no built-in persistence across server restarts without external state store","Session creation adds ~100-200ms latency per new user/conversation","No automatic session cleanup—stale sessions accumulate unless explicitly deleted"],"requires":["Composio SDK (Python or TypeScript)","External session store (optional, for persistence across restarts)","User/conversation identifier to bind to session"],"input_types":["User ID or conversation ID","List of connected account IDs to bind to session"],"output_types":["Session ID (string)","Tool list scoped to session's connected accounts"],"categories":["tool-use-integration","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"composio__cap_3","uri":"capability://tool.use.integration.openapi.based.tool.schema.discovery.and.automatic.documentation.generation","name":"openapi-based tool schema discovery and automatic documentation generation","description":"Composio maintains a registry of 500+ pre-built toolkits, each defined as OpenAPI schemas. When an agent requests tools from a toolkit (e.g., GitHub), Composio serves the OpenAPI schema, which includes operation descriptions, parameter types, and response schemas. The SDK automatically converts these schemas into agent-readable documentation (function descriptions, parameter hints) and generates tool discovery endpoints that agents can query to find available actions. Toolkit versions are managed independently, allowing agents to pin specific versions without affecting other toolkits.","intents":["I want my agent to discover what GitHub actions are available without hardcoding a tool list","I need parameter validation before my agent calls a tool to avoid invalid API requests","I want to update a toolkit's schema without redeploying my agent"],"best_for":["agents that need dynamic tool discovery","platforms building tool marketplaces","teams maintaining large numbers of tool integrations"],"limitations":["OpenAPI schema parsing adds ~50-100ms per tool discovery call","Custom tools not in the registry require manual OpenAPI schema definition","Schema versioning is per-toolkit, not per-operation—breaking changes require full toolkit version bump"],"requires":["Network access to Composio's tool registry API","Agent framework that supports dynamic tool discovery (LangChain, CrewAI, AutoGen)"],"input_types":["Toolkit name (string, e.g., 'github')","Optional: toolkit version"],"output_types":["OpenAPI schema (JSON)","Formatted tool descriptions (markdown or plain text)","Parameter validation rules"],"categories":["tool-use-integration","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"composio__cap_4","uri":"capability://automation.workflow.webhook.and.real.time.event.subscription.for.agent.triggers","name":"webhook and real-time event subscription for agent triggers","description":"Composio's trigger engine enables agents to subscribe to real-time events from external services (e.g., 'new GitHub issue', 'Slack message in channel') via webhooks and WebSocket connections (Pusher). When an event occurs, Composio's backend receives the webhook, matches it to subscribed agents, and delivers the event payload to the agent's execution context. Agents can define trigger handlers that automatically invoke tool actions in response to events, enabling reactive workflows without polling.","intents":["I want my agent to automatically respond to GitHub issues without polling the API","I need to trigger an agent workflow when a Slack message is posted in a specific channel","I want to set up a webhook that invokes my agent when a Jira ticket is created"],"best_for":["event-driven agent workflows","real-time automation (Slack bots, GitHub automation)","agents that need to react to external system changes"],"limitations":["Webhook delivery is at-least-once, not exactly-once—agents must handle duplicate events","Event latency depends on Composio's webhook processing queue—typically 100-500ms","WebSocket connections (Pusher) require additional setup and may not work behind restrictive firewalls","Trigger handlers are stateless—no built-in persistence of trigger state across restarts"],"requires":["Composio backend API key","Webhook endpoint URL (publicly accessible or via ngrok for local development)","OAuth credentials for the service emitting events (GitHub, Slack, Jira, etc.)"],"input_types":["Event type (string, e.g., 'github.issue.opened')","Event filter criteria (optional, e.g., repository name, channel ID)","Trigger handler function"],"output_types":["Event payload (JSON)","Trigger execution result (success/failure)"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"composio__cap_5","uri":"capability://tool.use.integration.transparent.file.handling.with.s3.based.upload.download.and.presigned.urls","name":"transparent file handling with s3-based upload/download and presigned urls","description":"Composio's file service abstracts file I/O for tools that require file uploads or downloads (e.g., uploading a document to Google Drive, downloading a GitHub repository). When an agent needs to upload a file, Composio generates a presigned S3 URL, the agent uploads the file directly to S3, and Composio passes the S3 reference to the target service API. For downloads, Composio retrieves files from the service, stores them in S3, and provides presigned download URLs to the agent. This approach avoids loading entire files into agent memory and reduces latency for large file operations.","intents":["I want my agent to upload a large CSV file to Google Drive without loading it into memory","I need my agent to download a GitHub repository and process its files","I want to handle file operations without managing S3 credentials in my agent code"],"best_for":["agents processing large files (>10MB)","workflows involving document uploads/downloads","teams that want to avoid file I/O complexity in agent code"],"limitations":["Presigned URL generation adds ~100-200ms per file operation","File size limits depend on the target service (e.g., Google Drive has 5TB per file, but API may have smaller limits)","S3 storage is temporary—files are not persisted indefinitely (retention policy TBD)","No built-in file format conversion—agents must handle format transformation themselves"],"requires":["Composio API key with file service access","Network access to S3 (via presigned URLs)","File size within service limits"],"input_types":["File path (local or remote URL)","File content (binary or text)","Target service and destination (e.g., 'google_drive', 'folder_id')"],"output_types":["S3 presigned URL (for upload)","S3 presigned download URL (for download)","File metadata (size, type, upload status)"],"categories":["tool-use-integration","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"composio__cap_6","uri":"capability://tool.use.integration.custom.tool.creation.and.modifier.system.for.extending.toolkit.capabilities","name":"custom tool creation and modifier system for extending toolkit capabilities","description":"Composio allows developers to define custom tools beyond the 500+ pre-built integrations using the custom tool API. Custom tools are defined via OpenAPI schemas or Python/TypeScript function signatures, and can be added to a toolkit. The modifier system enables post-processing of tool execution—modifiers can transform tool inputs before execution, intercept outputs, add logging, or implement custom error handling. Modifiers are composable and can be chained together, enabling flexible tool behavior customization without forking the SDK.","intents":["I want to add a proprietary API to Composio without waiting for an official integration","I need to transform tool outputs before passing them to my agent (e.g., filtering, formatting)","I want to add custom error handling or retry logic to a tool"],"best_for":["teams with proprietary APIs or internal tools","developers needing custom tool behavior","platforms building tool marketplaces with user-defined tools"],"limitations":["Custom tools are not automatically discoverable—agents must explicitly reference them","Modifier system only works within Composio's execution context, not in framework-native tool definitions","Custom tool schemas must be manually maintained—no automatic schema generation from code","Modifiers add ~50-100ms per tool invocation due to composition overhead"],"requires":["Composio SDK (Python or TypeScript)","OpenAPI schema or function signature for custom tool","Modifier implementation (if using modifiers)"],"input_types":["OpenAPI schema (JSON)","Python function or TypeScript function signature","Modifier function"],"output_types":["Custom tool object (registered in toolkit)","Modified tool output (from modifiers)"],"categories":["tool-use-integration","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"composio__cap_7","uri":"capability://tool.use.integration.mcp.model.context.protocol.server.integration.for.standardized.tool.exposure","name":"mcp (model context protocol) server integration for standardized tool exposure","description":"Composio provides an MCP server at mcp.composio.dev that exposes all 500+ toolkits via the Model Context Protocol standard. Agents or LLM clients that support MCP can connect to this server and discover tools without using Composio's SDK directly. The MCP server handles authentication, tool routing, and execution, translating MCP requests into Composio's internal tool execution pipeline. This enables integration with MCP-compatible clients (Claude Desktop, custom MCP clients) without SDK dependency.","intents":["I want to use Composio tools in Claude Desktop without writing custom code","I need to expose Composio tools to an MCP-compatible client","I want to standardize on MCP for tool discovery across multiple AI platforms"],"best_for":["Claude Desktop users wanting Composio integrations","teams standardizing on MCP for tool exposure","platforms building MCP-compatible AI clients"],"limitations":["MCP server requires network access to mcp.composio.dev—no local-only option","MCP protocol overhead adds ~100-200ms per tool call vs direct SDK usage","Authentication is handled server-side—clients must provide Composio API key","Tool discovery is read-only via MCP—tool registration requires SDK or web UI"],"requires":["MCP-compatible client (Claude Desktop, custom MCP client)","Composio API key","Network access to mcp.composio.dev"],"input_types":["MCP protocol requests (JSON-RPC 2.0)","Tool name and parameters"],"output_types":["Tool list (MCP resources)","Tool execution results"],"categories":["tool-use-integration","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"composio__cap_8","uri":"capability://tool.use.integration.rate.limiting.and.error.handling.with.automatic.retry.logic","name":"rate limiting and error handling with automatic retry logic","description":"Composio's execution engine implements rate limiting and error handling transparently. When a tool call hits a rate limit (e.g., GitHub API 60 requests/hour), Composio automatically retries with exponential backoff. For transient errors (network timeouts, 5xx responses), Composio retries up to a configurable limit. For permanent errors (4xx responses, invalid parameters), Composio returns the error immediately without retry. Rate limit state is tracked per-session and per-service, enabling fair resource allocation across concurrent agents.","intents":["I want my agent to handle rate limits gracefully without failing","I need automatic retry logic for transient failures","I want to avoid overwhelming external APIs with concurrent requests"],"best_for":["production agents requiring reliability","high-concurrency scenarios with multiple agents","teams without custom error handling infrastructure"],"limitations":["Retry logic adds latency (exponential backoff can take 30+ seconds for max retries)","Rate limit state is not shared across Composio instances—distributed deployments may exceed service limits","Retry configuration is global, not per-tool—fine-grained retry policies require custom modifiers","No built-in circuit breaker—repeated failures don't prevent subsequent attempts"],"requires":["Composio SDK","Network access to external services"],"input_types":["Tool execution request","Retry configuration (optional)"],"output_types":["Tool execution result (success or final error)","Retry metadata (attempt count, backoff duration)"],"categories":["tool-use-integration","safety-moderation"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"composio__cap_9","uri":"capability://tool.use.integration.dual.sdk.support.python.and.typescript.with.framework.specific.provider.packages","name":"dual sdk support (python and typescript) with framework-specific provider packages","description":"Composio provides parallel Python and TypeScript SDKs with identical core functionality but language-specific implementations. The Python SDK uses async/await patterns and integrates with CrewAI, LangChain, and Anthropic's Python clients. The TypeScript SDK uses Promise-based async and integrates with LangChain.js, Vercel AI SDK, and Node.js-based frameworks. Each SDK has provider packages (e.g., @composio/langchain, composio-langchain) that implement framework adapters. This dual-SDK approach enables language-agnostic tool integration without forcing teams to adopt a single language.","intents":["I want to use Composio in my Python agent without rewriting in TypeScript","I need to integrate Composio into a Node.js/TypeScript backend","I want to use the same tools across Python and TypeScript agents"],"best_for":["polyglot teams using both Python and TypeScript","enterprises with existing Python or TypeScript agent infrastructure","developers wanting language flexibility without tool integration overhead"],"limitations":["Feature parity between SDKs is not guaranteed—Python may have features TypeScript lacks and vice versa","SDK updates are released independently—version mismatches can cause compatibility issues","Documentation may be language-specific, requiring developers to understand both Python and TypeScript examples","Performance characteristics differ between SDKs (Python async/await vs TypeScript Promises)"],"requires":["Python 3.9+ (for Python SDK) or Node.js 18+ (for TypeScript SDK)","pip or npm package manager","Composio API key"],"input_types":["Language-specific SDK imports","Framework-specific provider package"],"output_types":["Language-native tool objects (Python functions, TypeScript functions)"],"categories":["tool-use-integration","code-generation-editing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"composio__headline","uri":"capability://tool.use.integration.ai.agent.integration.platform","name":"ai agent integration platform","description":"Composio is an AI agent integration platform that connects 1000+ external tools and APIs, enabling seamless execution of real-world actions across various AI frameworks.","intents":["best AI agent integration platform","AI integration for automation","top tools for AI agents","AI agents with extensive tool support","AI agent frameworks with tool integration"],"best_for":["developers looking to integrate AI agents with multiple tools"],"limitations":[],"requires":[],"input_types":[],"output_types":[],"categories":["tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":55,"verified":false,"data_access_risk":"high","permissions":["Python 3.9+ or Node.js 18+","One of: LangChain 0.1+, CrewAI 0.1+, AutoGen 0.2+, or OpenAI SDK 1.0+","Composio API key from backend.composio.dev","Composio API key for backend authentication","OAuth app credentials (client_id, client_secret) for each OAuth-protected service","Network access to backend.composio.dev for credential retrieval","Node.js 18+ (for TypeScript CLI) or Python 3.9+ (for Python CLI)","Composio API key (for authenticated commands)","Composio SDK","Explicit version specification in agent code or configuration"],"failure_modes":["Framework adapters add ~50-150ms overhead per tool invocation due to schema translation","Custom tool modifiers only work within Composio's modifier system, not directly in framework-native tool definitions","Some framework-specific features (e.g., parallel tool calling in OpenAI) require explicit provider-level support","Credential refresh adds ~200-500ms latency on first tool call after token expiry","Custom auth schemes (non-OAuth, non-API-key) require manual implementation via custom tool modifiers","No local credential caching—all auth checks hit the backend API, creating a hard dependency on Composio's backend availability","CLI is read-only for tool discovery—tool registration requires SDK or web UI","Authentication via CLI is session-based and doesn't persist across restarts without manual setup","CLI testing doesn't support complex workflows (multi-step tool chains, conditional logic)","Error messages may be less detailed than SDK errors due to CLI output constraints","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.7,"quality":0.9,"ecosystem":0.39999999999999997,"match_graph":0.25,"freshness":0.52,"weights":{"adoption":0.3,"quality":0.2,"ecosystem":0.15,"match_graph":0.3,"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:04.690Z","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=composio","compare_url":"https://unfragile.ai/compare?artifact=composio"}},"signature":"wMyQ/nJd/lXWjai34Z8F8CrsUmMn4vWKzlyMyNb0Y91GeygovvAA7RnWQVCBDm9BaNzGEeNrTiEEycgV7FHODA==","signedAt":"2026-06-23T12:34:50.729Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/composio","artifact":"https://unfragile.ai/composio","verify":"https://unfragile.ai/api/v1/verify?slug=composio","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"}}