Composio

Connect agents to apps, authenticate accounts, discover and execute tools, and run governed workflows with managed execution and controls.

Connect agents to everyday apps and complete cross-app workflows from chat, with multiple accounts and agent choice in one place.

Connect agents to app integrations from the command line to discover tools, execute actions, and access connected accounts.

Give agents governed access to managed tools and custom MCP servers through one endpoint, with centralized controls and activity records.

Deploy agents across company tools with managed execution, controlled access, protected credentials, and traceable activity.

Reduce the cost and time of agent tasks with reusable skills, focused tool calls, and less token usage.

Composio Developer Platform

Composio is an adaptive runtime for building knowledge-work agents and backend applications. Its SDKs connect agents to apps and tools, while Composio handles authentication, tool search, and execution. The platform provides browser and code sandbox environments, event triggers, task playbooks, paid tools, and controls for permissions, prompt-injection checks, and execution tracing. Triggers start background agents from connected-app events, with authentication, event collection, and signed delivery handled by Composio. Paid tools can be used without separate provider accounts, subscriptions, or API keys, with calls billed from a Composio wallet. Firewall controls enforce policies, check actions against task context, and screen tool responses for hidden instructions.

• Connect Agents To 1,700+ Apps
  Give agents access to a broad set of connected applications and execute actions across them through Composio.
• Manage Account Authentication
  Connect accounts for agents while Composio handles authentication and token refresh. Per-user credentials and multiple accounts for an app support distinct account connections.
• Find Tools By Task
  Help agents locate relevant tools and guidance for a task rather than requiring them to select from every available integration.
• Start Agents From App Events
  Start background agent work from connected-app events without waiting for a person to prompt the agent. Consistent signed delivery and event metadata support verification and routing to the relevant account and user.
• Enforce Policies And Screen Tool Results
  Control which tools and accounts agents can use, check actions against policies and task context, and screen incoming tool results for hidden instructions, secrets, or personal data.
• Run Code In Isolation
  Let agents run code and process files in an isolated environment, then bring only the results they need into context.
• Trace Every Tool Call
  See which tools agents called, whose accounts they used, and what happened at each step to investigate failures and support audits.
• Use Paid Tools From One Wallet
  Give agents access to supported paid tools without separate provider setup, and pay per call from one Composio balance at provider prices with 0% markup. Teams can review usage and costs, add funds, or disable access.
• Build With SDKs And Frameworks
  Connect agents to apps using Python or TypeScript SDKs and adapt Composio tools to supported model APIs and frameworks.
• Run Tasks Across The Web
  Enable agents to interact with websites through a browser, including sites without APIs.
• Guide Agents Through Tasks
  Provide agents with task-specific steps, tool order, and cautions through read-only and reusable playbooks that can accompany relevant tool searches.

Composio for you

Composio for you connects AI agents to more than 1,700 apps, letting people perform complex workflows across their applications from one chat. It supports multiple accounts per app and keeps connections with Composio so users can switch agents while bringing their tools along. Role-specific apps, prompts, and playbooks are tuned to different ways of working.

Category: AI Assistant Software

• Connect Agents To 1,700+ Apps
  Give an agent access to a broad range of everyday applications and use them together from one chat, rather than handling each app separately.
• Match Workflows To Your Role
  Use role-oriented apps, prompts, and playbooks for tasks across areas such as sales, marketing, customer support, engineering, and finance.
• Manage Multiple Accounts In One Place
  Work across multiple accounts for the same app without switching between them, including separate work, personal, and team accounts.
• Switch Agents Without Reconnecting Tools
  Keep app connections with Composio instead of tying them to one agent, so users can switch agents and continue using their connected tools.
• Reuse Playbooks For Recurring Work
  Apply reusable playbooks to guide agents through recurring tasks involving connected tools and steps.
• Share Connections And Skills With Teammates
  Make connected apps, accounts, and skills available to teammates.

Composio Universal CLI

A command-line interface that gives AI agents access to more than 1,700 app integrations. Use natural-language search to find tools, execute actions with input validation and authentication checks, connect accounts, make curl-like API requests, and run inline TypeScript or JavaScript scripts. The CLI also supports dry runs, schema inspection, toolkit and tool discovery, developer workflows, and account management.

• Access 1,700+ App Integrations
  Give agents command-line access to tools across more than 1,700 app integrations.
• Run Tools With Built-In Checks
  Execute integration actions with input validation and authentication checks, and receive guidance when authorization is missing.
• Find Tools By Task
  Discover relevant tools by describing the work to be done, with optional toolkit filters and result limits.
• Connect Required Accounts
  Link the relevant toolkit account when an action requires authorization, then retry the execution.
• Access Toolkit APIs
  Make requests to toolkit API endpoints through a linked account, including when a matching tool is unavailable.
• Run Scripts With Injected Helpers
  Use TypeScript or JavaScript scripts with injected Composio helpers for search, tool execution, proxy access, and other supported operations.
• Preview Calls Before Execution
  Validate and preview tool calls or script actions before they run remotely.
• Manage Developer Workflows
  Use CLI commands for developer workflows, type stub generation, and management of Composio organizations, toolkits, connections, triggers, auth configurations, and projects.
• Inspect Tool Schemas
  Retrieve tool schemas and summaries to inspect the inputs available for an integration action.
• List Toolkit Tools
  See which tools are available within a toolkit from the command line.
• Inspect Session Artifacts
  Locate and inspect the session artifacts associated with the current working directory.
• Manage CLI Access And Updates
  Log in or out, check account information and the installed version, and upgrade the CLI.

Composio MCP Gateway

Composio MCP Gateway is a centralized security and control layer between AI agents and the MCP servers they use. It provides one governed endpoint for Composio-managed tools and custom MCP servers, with centralized access policies, managed credentials, and an audit trail. Teams can scope tools and actions by organization, team, user, and role; manage OAuth connections and service accounts; and inspect agent activity in a shared view. The gateway also resolves natural-language requests to matching tools, helping keep agent context focused across catalogs with thousands of tools.

• Manage Every MCP Server Centrally
  Manage Composio-managed toolkits and your own MCP servers through one governed endpoint, with centralized enablement and team ownership.
• Enforce Role-Based Tool Access
  Give each agent only the tools and actions its role requires, apply policies consistently across servers, and revoke access centrally.
• Trace And Review Agent Activity
  Use one activity view to see who acted, which tools were called, and what happened. Review failures and policy denials, and export records for investigation and audits.
• Keep Credentials Out Of Agent Configuration
  Centralize OAuth connections and service accounts, refresh tokens automatically, and revoke access during offboarding without exposing credentials in agent configuration.
• Return Only Relevant Tools
  Resolve an agent’s request at runtime and return matching tools from managed and custom servers, helping keep context small even when many tools are available.

Composio Enterprise

Composio Enterprise provides an adaptive runtime for deploying AI agents across an organization. Agents can use tools across 1,700+ apps, browsers, and sandboxes, with managed authentication, token refresh, and server-side execution. Organizations can define which tools and connected accounts each session may use, enforce policies when agents act, and trace tool calls, accounts, actions, and outcomes. The offering includes protections for keeping managed credentials out of model context, SOC 2 Type II attestation, ISO 27001:2022 certification, and deployment arrangements through Composio Cloud, a private VPC, or self-hosted infrastructure. Enterprise plans also include SSO and SCIM, with customer-managed key arrangements available.

• Connect Agents To 1,700+ Apps
  Agents can use tools across a broad catalog of apps, while Composio handles authentication and token refresh for connected accounts.
• Enforce Policies On Agent Actions
  Organizations can restrict agent sessions to approved tools, accounts, and actions, helping keep execution within defined access policies.
• Keep Managed Credentials Out Of Model Context
  Composio stores and uses managed credentials to authenticate provider requests, while the application and model receive results without needing provider tokens. Customer-managed keys are available through a separate deployment arrangement for customer-owned auth configurations.
• Detect Injections And Check Actions
  The firewall helps identify prompt injection attempts in tool responses and applies access-policy checks to agent actions.
• Trace Every Tool Call
  A shared activity view records which tools agents called, whose accounts they used, and what happened at each step, helping teams investigate failures and support audits.
• Choose Your Deployment Model
  Organizations can use the default Composio Cloud deployment or discuss private VPC and self-hosted arrangements. A separate customer-managed-key arrangement is also described for eligible deployment designs.
• Run Code And Use Browsers
  Agents can interact with websites that lack APIs, run code, and process files using browsers and sandboxes included in the runtime.
• Sync And Manage Organization Access
  SSO and SCIM support organization sign-in and directory-synced provisioning, including access revocation during offboarding.
• Govern MCP Access Through One Layer
  MCP clients and internal MCP servers can use the same control layer, policies, and audit trail as other agent tool activity.
• Meet Certified Security Standards
  The enterprise offering documents SOC 2 Type II attestation and ISO 27001:2022 certification.
• Inspect Failed Execution Results
  Managed authentication and token refresh support connected tool execution, while inspectable results help teams review failed calls.
• Use Your Chosen Models And Frameworks
  Organizations can use their selected models and agent frameworks while relying on Composio-managed tools and connections.

Composio Optimization

Composio Optimization lowers the cost of agent tasks by reducing tool calls, retries, and token usage. It gives agents reusable skills refined through successful runs and known failures, focused tool interfaces, and sandboxed code execution for processing multiple records. The runtime can provide only task-relevant fields from tool responses and route familiar steps to smaller models. Skills and execution steps can be reused across runs while keeping task data and results separate.

• Reduce Cost Per Completed Task
  Cut unnecessary calls, retries, and repeated processing so agents can complete tasks with less time and model spend.
• Reuse Proven Task Steps
  Carry successful approaches and known fixes into later runs, helping agents handle familiar tasks with fewer exploratory calls and repeated mistakes.
• Focus Tools On The Task
  Give agents clearer, more relevant tools and instructions so they can avoid unnecessary exploration and process less irrelevant context.
• Send Only Relevant Fields
  Limit the information passed to the model to fields needed for the task, reducing the amount of response data it must process.
• Keep Data Separate Across Runs
  Carry reusable execution knowledge forward without sharing task data or results between runs.
• Process Records In One Run
  Use sandboxed code execution to handle multiple records together instead of requiring repeated model interactions for each record.
• Route Familiar Steps To Smaller Models
  Apply smaller models to familiar steps as the runtime learns from past runs, while retaining the skills refined through those runs.