How to integrate Coda MCP with LlamaIndex

This guide walks you through connecting Coda to LlamaIndex using the Composio tool router. By the end, you'll have a working Coda agent that can duplicate your project tracker document, add a new permission for this doc, export the content of the roadmap page through natural language commands. This guide will help you understand how to give your LlamaIndex agent real control over a Coda account through Composio's Coda MCP server. Before we dive in, let's take a quick look at the key ideas and tools involved.

Get started for free Get a demo

Coda

Api Key

Coda is a collaborative workspace that turns documents into powerful tools for teams. It's designed to boost productivity by combining docs, spreadsheets, and apps in a single platform.

109 Tools4 Triggers

Managed auth

Connect Coda without auth hassles

We manage OAuth, API keys, token refresh, and scopes — you just build.

Try for free

Introduction

This guide will help you understand how to give your LlamaIndex agent real control over a Coda account through Composio's Coda MCP server.

Before we dive in, let's take a quick look at the key ideas and tools involved.

Also integrate Coda with

OpenAI Agents SDK Claude Agent SDK Claude Code Claude Cowork Codex OpenClaw Hermes CLI Google ADK LangChain Vercel AI SDK Mastra AI CrewAI

TL;DR

Here's what you'll learn:

Set your OpenAI and Composio API keys
Install LlamaIndex and Composio packages
Create a Composio Tool Router session for Coda
Connect LlamaIndex to the Coda MCP server
Build a Coda-powered agent using LlamaIndex
Interact with Coda through natural language

What is LlamaIndex?

LlamaIndex is a data framework for building LLM applications. It provides tools for connecting LLMs to external data sources and services through agents and tools.

Key features include:

ReAct Agent: Reasoning and acting pattern for tool-using agents
MCP Tools: Native support for Model Context Protocol
Context Management: Maintain conversation context across interactions
Async Support: Built for async/await patterns

What is the Coda MCP server, and what's possible with it?

The Coda MCP server is an implementation of the Model Context Protocol that connects your AI agent and assistants like Claude, Cursor, etc directly to your Coda account. It provides structured and secure access to your workspaces and docs, so your agent can automate Coda document creation, manage permissions, export content, and streamline your team’s productivity tools—all on your behalf.

Automated document and page creation: Instruct your agent to create new Coda documents or pages, duplicate existing docs, and organize content structure with just a prompt.
Flexible permission and sharing management: Have your agent add or modify user, workspace, or global permissions, so you’re always in control of who can view or edit your docs.
Seamless content export and status tracking: Let your agent initiate exports of Coda pages and check the progress, making it easy to share or archive important information.
Custom domain and publishing management: Direct your agent to add custom domains to published docs or manage categories and makers for Coda packs, keeping your workspace organized and discoverable.
Pack release and workspace enhancements: Ask your agent to create new pack releases or manage integrations, helping teams extend Coda’s power without repetitive manual steps.

What is the Composio tool router, and how does it fit here?

What is Composio SDK?

Composio's Composio SDK helps agents find the right tools for a task at runtime. You can plug in multiple toolkits (like Gmail, HubSpot, and GitHub), and the agent will identify the relevant app and action to complete multi-step workflows. This can reduce token usage and improve the reliability of tool calls. Read more here: Getting started with Composio SDK

The tool router generates a secure MCP URL that your agents can access to perform actions.

How the Composio SDK works

The Composio SDK follows a three-phase workflow:

Discovery: Searches for tools matching your task and returns relevant toolkits with their details.
Authentication: Checks for active connections. If missing, creates an auth config and returns a connection URL via Auth Link.
Execution: Executes the action using the authenticated connection.

Step-by-step Guide

Step by step10 STEPS

Prerequisites

Before you begin, make sure you have:

Python 3.8/Node 16 or higher installed
A Composio account with the API key
An OpenAI API key
A Coda account and project
Basic familiarity with async Python/Typescript

Getting API Keys for OpenAI, Composio, and Coda

OpenAI API key (OPENAI_API_KEY)

Go to the OpenAI dashboard
Create an API key if you don't have one
Assign it to OPENAI_API_KEY in .env

Composio API key and user ID

Log into the Composio dashboard
Copy your API key from Settings
- Use this as COMPOSIO_API_KEY
Pick a stable user identifier (email or ID)
- Use this as COMPOSIO_USER_ID

Installing dependencies

npm install @composio/llamaindex @llamaindex/openai @llamaindex/tools @llamaindex/workflow dotenv

Create a new Typescript project and install the necessary dependencies:

@composio/llamaindex: Composio's LlamaIndex integration
@llamaindex/openai: OpenAI LLM integration
@llamaindex/tools: MCP client for LlamaIndex
@llamaindex/workflow: Workflow framework for LlamaIndex
dotenv: Environment variable management

Set environment variables

bash

OPENAI_API_KEY=your-openai-api-key
COMPOSIO_API_KEY=your-composio-api-key
COMPOSIO_USER_ID=your-user-id

Create a .env file in your project root:

These credentials will be used to:

Authenticate with OpenAI's GPT-5 model
Connect to Composio's Tool Router
Identify your Composio user session for Coda access

Import modules

import "dotenv/config";
import readline from "node:readline/promises";
import { stdin as input, stdout as output } from "node:process";

import { Composio } from "@composio/core";

import { mcp } from "@llamaindex/tools";
import { agent as createAgent } from "@llamaindex/workflow";
import { openai } from "@llamaindex/openai";

dotenv.config();

Create a new file called coda_llamaindex_agent.ts and import the required modules:

Key imports:

dotenv.config loads .env at runtime
readline gives us a simple CLI chat loop
Composio is the main Composio SDK client
mcp connects to an MCP endpoint
createAgent builds a LlamaIndex agent
openai configures the LLM backend

Load environment variables and initialize Composio

const OPENAI_API_KEY = process.env.OPENAI_API_KEY;
const COMPOSIO_API_KEY = process.env.COMPOSIO_API_KEY;
const COMPOSIO_USER_ID = process.env.COMPOSIO_USER_ID;

if (!OPENAI_API_KEY) throw new Error("OPENAI_API_KEY is not set");
if (!COMPOSIO_API_KEY) throw new Error("COMPOSIO_API_KEY is not set");
if (!COMPOSIO_USER_ID) throw new Error("COMPOSIO_USER_ID is not set");

What's happening:

This ensures missing credentials cause early, clear errors before the agent attempts to initialise.

Create a Tool Router session and build the agent function

async function buildAgent() {

  console.log(`Initializing Composio client...${COMPOSIO_USER_ID!}...`);
  console.log(`COMPOSIO_USER_ID: ${COMPOSIO_USER_ID!}...`);

  const composio = new Composio({
    apiKey: COMPOSIO_API_KEY,
    provider: new LlamaindexProvider(),
  });

  const session = await composio.create(
    COMPOSIO_USER_ID!,
    {
      toolkits: ["coda"],
    },
  );

  const mcpUrl = session.mcp.url;
  console.log(`Composio Tool Router MCP URL: ${mcpUrl}`);

  const server = mcp({
    url: mcpUrl,
    clientName: "composio_tool_router_with_llamaindex",
    requestInit: {
      headers: {
        "x-api-key": COMPOSIO_API_KEY!,
      },
    },
    // verbose: true,
  });

  const tools = await server.tools();

  const llm = openai({ apiKey: OPENAI_API_KEY, model: "gpt-5" });

  const agent = createAgent({
    name: "composio_tool_router_with_llamaindex",
        description : "An agent that uses Composio Tool Router MCP tools to perform actions.",
    systemPrompt:
      "You are a helpful assistant connected to Composio Tool Router."+
"Use the available tools to answer user queries and perform Coda actions." ,
    llm,
    tools,
  });

  return agent;
}

What's happening here:

We create a Composio client using your API key and configure it with the LlamaIndex provider
We then create a tool router MCP session for your user, specifying the toolkits we want to use (in this case, coda)
The session returns an MCP HTTP endpoint URL that acts as a gateway to all your configured tools
LlamaIndex will connect to this endpoint to dynamically discover and use the available Coda tools.
The MCP tools are mapped to LlamaIndex-compatible tools and plug them into the Agent.

Create an interactive chat loop

async function chatLoop(agent: ReturnType<typeof createAgent>) {
  const rl = readline.createInterface({ input, output });

  console.log("Type 'quit' or 'exit' to stop.");

  while (true) {
    let userInput: string;

    try {
      userInput = (await rl.question("\nYou: ")).trim();
    } catch {
      console.log("\nAgent: Bye!");
      break;
    }

    if (!userInput) {
      continue;
    }

    const lower = userInput.toLowerCase();
    if (lower === "quit" || lower === "exit") {
      console.log("Agent: Bye!");
      break;
    }

    try {
      process.stdout.write("Agent: ");

      const stream = agent.runStream(userInput);
      let finalResult: any = null;

      for await (const event of stream) {
        // The event.data contains the streamed content
        const data: any = event.data;

        // Check for streaming delta content
        if (data?.delta) {
          process.stdout.write(data.delta);
        }

        // Store final result for fallback
        if (data?.result || data?.message) {
          finalResult = data;
        }
      }

      // If no streaming happened, show the final result
      if (finalResult) {
        const answer =
          finalResult.result ??
          finalResult.message?.content ??
          finalResult.message ??
          "";
        if (answer && typeof answer === "string" && !answer.includes("[object")) {
          process.stdout.write(answer);
        }
      }

      console.log(); // New line after streaming completes
    } catch (err: any) {
      console.error("\nAgent error:", err?.message ?? err);
    }
  }

  rl.close();
}

What's happening:

We're creating a direct terminal interface to chat with Coda
The LLM's responses are streamed to the CLI for faster interaction.
The agent uses context to maintain conversation history
The agent processes the request, selects appropriate Coda tools, and returns a result
We extract the answer from the result data structure and display it to the user
You can type 'quit' or 'exit' to stop the chat loop gracefully
Agent responses and any errors are streamed in a clear, readable format

Define the main entry point

async function main() {
  try {
    const agent = await buildAgent();
    await chatLoop(agent);
  } catch (err) {
    console.error("Failed to start agent:", err);
    process.exit(1);
  }
}

main();

What's happening here:

We're orchestrating the entire application flow
The agent gets built with proper error handling
Then we kick off the interactive chat loop so you can start talking to Coda

Run the agent

npx ts-node llamaindex-agent.ts

When prompted, authenticate and authorise your agent with Coda, then start asking questions.

Complete Code

Here's the complete code to get you started with Coda and LlamaIndex:

import "dotenv/config";
import readline from "node:readline/promises";
import { stdin as input, stdout as output } from "node:process";

import { Composio } from "@composio/core";
import { LlamaindexProvider } from "@composio/llamaindex";

import { mcp } from "@llamaindex/tools";
import { agent as createAgent } from "@llamaindex/workflow";
import { openai } from "@llamaindex/openai";

dotenv.config();

const OPENAI_API_KEY = process.env.OPENAI_API_KEY;
const COMPOSIO_API_KEY = process.env.COMPOSIO_API_KEY;
const COMPOSIO_USER_ID = process.env.COMPOSIO_USER_ID;

if (!OPENAI_API_KEY) {
    throw new Error("OPENAI_API_KEY is not set in the environment");
  }
if (!COMPOSIO_API_KEY) {
    throw new Error("COMPOSIO_API_KEY is not set in the environment");
  }
if (!COMPOSIO_USER_ID) {
    throw new Error("COMPOSIO_USER_ID is not set in the environment");
  }

async function buildAgent() {

  console.log(`Initializing Composio client...${COMPOSIO_USER_ID!}...`);
  console.log(`COMPOSIO_USER_ID: ${COMPOSIO_USER_ID!}...`);

  const composio = new Composio({
    apiKey: COMPOSIO_API_KEY,
    provider: new LlamaindexProvider(),
  });

  const session = await composio.create(
    COMPOSIO_USER_ID!,
    {
      toolkits: ["coda"],
    },
  );

  const mcpUrl = session.mcp.url;
  console.log(`Composio Tool Router MCP URL: ${mcpUrl}`);

  const server = mcp({
    url: mcpUrl,
    clientName: "composio_tool_router_with_llamaindex",
    requestInit: {
      headers: {
        "x-api-key": COMPOSIO_API_KEY!,
      },
    },
    // verbose: true,
  });

  const tools = await server.tools();

  const llm = openai({ apiKey: OPENAI_API_KEY, model: "gpt-5" });

  const agent = createAgent({
    name: "composio_tool_router_with_llamaindex",
    description:
      "An agent that uses Composio Tool Router MCP tools to perform actions.",
    systemPrompt:
      "You are a helpful assistant connected to Composio Tool Router."+
"Use the available tools to answer user queries and perform Coda actions." ,
    llm,
    tools,
  });

  return agent;
}

async function chatLoop(agent: ReturnType<typeof createAgent>) {
  const rl = readline.createInterface({ input, output });

  console.log("Type 'quit' or 'exit' to stop.");

  while (true) {
    let userInput: string;

    try {
      userInput = (await rl.question("\nYou: ")).trim();
    } catch {
      console.log("\nAgent: Bye!");
      break;
    }

    if (!userInput) {
      continue;
    }

    const lower = userInput.toLowerCase();
    if (lower === "quit" || lower === "exit") {
      console.log("Agent: Bye!");
      break;
    }

    try {
      process.stdout.write("Agent: ");

      const stream = agent.runStream(userInput);
      let finalResult: any = null;

      for await (const event of stream) {
        // The event.data contains the streamed content
        const data: any = event.data;

        // Check for streaming delta content
        if (data?.delta) {
          process.stdout.write(data.delta);
        }

        // Store final result for fallback
        if (data?.result || data?.message) {
          finalResult = data;
        }
      }

      // If no streaming happened, show the final result
      if (finalResult) {
        const answer =
          finalResult.result ??
          finalResult.message?.content ??
          finalResult.message ??
          "";
        if (answer && typeof answer === "string" && !answer.includes("[object")) {
          process.stdout.write(answer);
        }
      }

      console.log(); // New line after streaming completes
    } catch (err: any) {
      console.error("\nAgent error:", err?.message ?? err);
    }
  }

  rl.close();
}

async function main() {
  try {
    const agent = await buildAgent();
    await chatLoop(agent);
  } catch (err: any) {
    console.error("Failed to start agent:", err?.message ?? err);
    process.exit(1);
  }
}

main();

Conclusion

You've successfully connected Coda to LlamaIndex through Composio's Tool Router MCP layer. Key takeaways:

Tool Router dynamically exposes Coda tools through an MCP endpoint
LlamaIndex's ReActAgent handles reasoning and orchestration; Composio handles integrations
The agent becomes more capable without increasing prompt size
Async Python provides clean, efficient execution of agent workflows

You can easily extend this to other toolkits like Gmail, Notion, Stripe, GitHub, and more by adding them to the toolkits parameter.

TOOLS & TRIGGERS

Supported Tools and Triggers

Every Coda action and event your agent gets out of the box.

Add a category for pack

Add a publishing category for a given pack.

Add a maker for pack

Add a maker to a Pack.

Add a permission for pack

Create or modify permissions for a given Pack.

Add custom domain

Add a custom domain to a published doc.

Add permission

Adds a new permission to the doc.

Begin content export

Initiate an asynchronous export of page content in HTML or Markdown format.

Content export status

Check the status of a page content export operation.

Copy Document

Creates a copy of an existing Coda document.

Create a new pack release

Creates a new Pack release based on an existing Pack version.

Create a page

Create a new page in a doc.

Create doc

Creates a new Coda doc, optionally copying an existing doc.

Create Folder

Creates a new folder in a Coda workspace.

Create Pack

Creates a new Pack in Coda.

Create Pack Invitation

Create an invitation for a user to access a Pack.

Delete a category for pack

Delete a publishing category for a given pack.

Delete a maker for pack

Removes a maker from a Pack's maker list.

Delete a page

Deletes the specified page.

Delete a permission for pack

Delete user, workspace, or global permissions for a given Pack.

Delete doc

Permanently deletes a Coda doc.

Delete Folder

Tool to delete a folder in Coda.

Delete multiple rows

Deletes multiple rows from a Coda table or view.

Delete pack

Delete a given Pack.

Delete Pack listing draft

Delete the listing draft for a Pack, discarding any unsaved changes.

Delete Page Content

Tool to delete content from a Coda page.

Delete permission

Deletes an existing permission from a Coda document.

Delete row

Deletes the specified row from the table or view.

Deletes a custom domain

Deletes a custom domain from a published doc.

Fetch grouped logs by pack org root ingestion id

Retrieve the grouped logs of a Pack ingestion for debugging purposes.

Fetch ingestion executions for pack

Retrieve the ingestion execution ids of a root ingestion for debugging purpose.

Get acl settings

Returns settings associated with ACLs for this Coda doc.

Get a column

Returns detailed information about a specific column in a Coda table.

Get a control

Returns info on a control.

Get a formula

Returns info on a formula.

Get analytics last updated day

Returns days based on Pacific Standard Time when analytics were last updated.

Get a page

Returns details about a page.

Get a row

Retrieves detailed information about a specific row in a Coda table, including all cell values, metadata (creation/update timestamps), and parent table information.

Get Pack details by ID

Retrieves detailed information about a specific Coda Pack by its ID.

Get a table

Returns details about a specific table or view.

Get detailed listing information for a pack

Get comprehensive public listing information for a Coda Pack.

Get doc analytics summary

Returns aggregated analytics summary data across documents, including session counts, installs, copies, reads, and conversions.

Get doc categories

Retrieves the list of all available doc categories in Coda.

Get folder

Tool to get metadata about a Coda folder.

Get info about a doc

Retrieves comprehensive metadata for a specific Coda document.

Get mutation status

Checks whether an asynchronous mutation operation has been applied to a Coda document.

Get pack analytics summary

Returns summarized analytics data for Packs the user can edit.

Gets custom doc domains providers

Identifies the domain registrar/provider for a given domain name by performing a DNS lookup.

Get sharing metadata

Returns metadata associated with sharing for this Coda doc.

Gets the json schema for pack configuration

Retrieves the JSON Schema that defines the configuration options available for a specific Coda Pack.

Get the difference between two pack versions

Gets information about the difference between the specified previous version and next version of a Pack.

Get the next valid version for a pack

Get the next valid version number for a Pack based on the proposed metadata.

Get the source code for a pack version

Retrieves temporary download URLs for the source code files of a specific Pack version.

Get user info

Returns basic info about the current user.

List available docs

Returns a list of Coda docs accessible by the user, and which they have opened at least once.

List categories for pack

List all publishing categories associated with a specific Coda Pack.

List columns

Returns a list of columns in a table.

List controls

Returns a list of controls in a Coda doc.

List custom doc domains

List all custom domains configured for a published Coda doc.

List doc analytics

Returns analytics data for accessible documents.

List featured docs for a pack

Returns a list of featured docs for a Pack.

List Folders

Tool to list folders accessible by the user.

List formulas

Returns a list of named formulas in a Coda doc.

List makers for pack

List makers for a given pack.

List pack analytics

Returns analytics data for Packs the user can edit.

List pack formula analytics

Returns analytics data for Pack formulas.

List packs

Get the list of accessible Packs.

List page analytics

Returns page-level analytics data for pages within a document.

List Page Content

Tool to list page content.

List pages

Returns a list of pages in a Coda doc.

List permissions

Returns a list of permissions for this Coda doc.

List permissions for a pack

Get user, workspace, and/or global permissions for a given Pack.

List table rows

Retrieves rows from a specific table within a Coda document.

List tables

Returns a list of tables in a Coda doc.

List the pack listings accessible to a user

Get listings of public Packs and Packs created by you.

List the releases for a pack

Get the list of releases of a Pack.

List the versions for a pack

Get the list of versions of a Pack.

List User Pack Invitations

Tool to get pending Pack invitations for the authenticated user.

List workspace roles

Returns a list of the counts of users over time by role for the workspace.

List workspace users

Returns a list of members in the given workspace.

Pack asset upload complete

Notify Coda that the Pack asset upload to S3 is complete.

Pack source code upload complete

Notify Coda that the Pack source code upload to S3 is complete.

Pack version upload complete

Mark a Pack version upload as complete to finalize the Pack version creation.

Patch the system connection credentials of the pack

Patch the system connection credentials of the Pack.

Publish doc

Update publish settings for a doc.

Push a button

Pushes a button on a row in a table.

Registers a new Pack version and obtains a signed upload URL.

Resolve browser link

Given a browser link to a Coda object, attempts to find it and return metadata that can be used to get more info on it.

Retrieve the grouped logs of a pack

Retrieve grouped execution logs for a Pack in a specific Coda document.

Retrieve the information for a specific log

Retrieve detailed information for a specific log entry from a Pack ingestion.

Retrieve the logs of a ingestion

Retrieve the logs of a Ingestion for debugging purpose.

Retrieve the logs of a pack

Retrieve the execution logs of a Pack within a specific document for debugging purposes.

Retrieve the oauth configuration of the pack

Retrieve the OAuth configuration of the Pack for display purpose.

Retrieve the system connection metadata of the pack

Retrieve the system connection metadata of a Pack.

Search principals

Search for users and groups (principals) that a Coda document can be shared with.

Set the oauth configurations of the pack

Set OAuth2 client credentials (client ID, secret, redirect URI) for a Pack.

Set the system connection credentials of the pack

Set the system connection credentials of the Pack.

Trigger automation

Triggers a webhook-invoked automation in a Coda doc.

Unpublish doc

Unpublishes a Coda document, removing it from public access.

Update acl settings

Update access control list (ACL) settings for a Coda document.

Update an existing Pack release

Update the release notes of an existing Pack release.

Update a page

Update properties for a page.

Update doc

Updates metadata for a Coda document, including its title and icon.

Update featured docs for a pack

Create or replace the featured docs for a Pack.

Update Folder

Tool to update folder metadata in Coda.

Update pack

Update an existing Pack for non-versioned fields.

Updates a custom domain

Updates properties of a document's custom domain.

Updates user role

Updates the workspace user role of a user that matches the parameters.

Upload a pack asset

Request a signed s3 URL to upload your Pack asset.

Upload pack source code

Request a signed s3 URL to upload your Pack source code.

Insert/Update Rows in Coda Table

This tool allows you to insert new rows into a Coda table or update existing ones based on specified key columns.

FRAMEWORKS

How to build Coda MCP Agent with another framework

OpenAI Agents SDK

Use Coda MCP with OpenAI Agents SDK

Claude Agent SDK

Use Coda MCP with Claude Agent SDK

Claude Code

Use Coda MCP with Claude Code

Claude Cowork

Use Coda MCP with Claude Cowork

Codex

Use Coda MCP with Codex

OpenClaw

Use Coda MCP with OpenClaw

Hermes

Use Coda MCP with Hermes

CLI

Use Coda MCP with CLI

Google ADK

Use Coda MCP with Google ADK

LangChain

Use Coda MCP with LangChain

Vercel AI SDK

Use Coda MCP with Vercel AI SDK

Mastra AI

Use Coda MCP with Mastra AI

CrewAI

Use Coda MCP with CrewAI

MORE TOOLKITS

Explore Other Toolkits

Toolkit marketplace

Google Sheets

Oauth2

Google Sheets is a cloud-based spreadsheet tool for real-time collaboration and data analysis. It lets teams work together from anywhere, updating information instantly.

Notion

Oauth2Api Key

Notion is a collaborative workspace for notes, docs, wikis, and tasks. It streamlines team knowledge, project tracking, and workflow customization in one place.

Airtable

Oauth2Api Key

Airtable combines the flexibility of spreadsheets with the power of a database for easy project and data management. Teams use Airtable to organize, track, and collaborate with custom views and automations.

Asana

Oauth2

Asana is a collaborative work management platform for teams to organize and track projects. It streamlines teamwork, boosts productivity, and keeps everyone aligned on goals.

FAQ

Frequently asked questions

With a standalone Coda MCP server, the agents and LLMs can only access a fixed set of Coda tools tied to that server. However, with the Composio Tool Router, agents can dynamically load tools from Coda and many other apps based on the task at hand, all through a single MCP endpoint.

Yes, you can. LlamaIndex fully supports MCP integration. You get structured tool calling, message history handling, and model orchestration while Tool Router takes care of discovering and serving the right Coda tools.

Yes, absolutely. You can configure which Coda scopes and actions are allowed when connecting your account to Composio. You can also bring your own OAuth credentials or API configuration so you keep full control over what the agent can do.

All sensitive data such as tokens, keys, and configuration is fully encrypted at rest and in transit. Composio is SOC 2 Type 2 compliant and follows strict security practices so your Coda data and credentials are handled as safely as possible.

Start with Coda.It takes 30 seconds.

Managed auth, hosted MCP servers, and every Coda tool your agent needs.Free to start.

Start building

Customer stories

Teams ship real agents on Composio

GET STARTED FOR FREE BOOK A DEMO

Karan skipped his own birthday party to fix our critical issue. It was 10pm and he diverted his Waymo to help us instead. This really sets the bar — it shows the commitment you need when users rely on your software.

Harsha Gaddipati

Co-founder, Slashy

A lot of students tell us that the moment their connected tools start talking to each other inside Opennote feels almost magical. The agent just knows them, and it's immensely helped keep new users on the platform.

Abhi Arya

Co-founder, Opennote

We chose Composio over Pipedream because it delivered depth where it mattered — niche tools and tricky edge cases other platforms simply ignored. That gave us confidence to scale without compromising.

Nirman Dave

CEO, Zams

As a solo builder, shipping fast is life or death. The only way I can outcompete incumbents is by outmanoeuvring them. Getting bogged down managing agent auth would have been a death sentence.

Ryan Yu

Founder, Extra Thursday

Before Composio, adding tool integrations was slow and resource-intensive. Each one could take weeks of engineering time, and maintaining them meant constantly keeping up with API changes.

Tomisin Jenrola

Founder & CEO, SwarmZero

With hands-on help from their founder, we integrated Gmail and Google Drive in just 30 minutes. This level of personal support and commitment is exactly what startups should strive for.

Jerome Leclanche

Co-Founder, Ingram Technologies