Executor.sh: Self-Hosted Open-Source Composio Alternative

Every AI agent needs tools. Whether it is sending Slack messages, querying a database, or calling a third-party API, the agent has to connect to external services somehow. Composio built a business around this: 1,000+ pre-built toolkits, managed OAuth, and a hosted runtime that handles everything for you. It works, and it works well for teams that want a fully managed platform.

But if you want to self-host, inspect the runtime, or avoid per-call pricing at scale, Composio’s story falls apart. The runtime is closed source. Self-hosting requires an Enterprise contract. And credentials flow through their cloud on self-serve plans.

That is where Executor.sh comes in. It is a fully open-source MCP gateway. Configure your integrations once, and every MCP-compatible agent shares them through one endpoint. You can run it on your own infrastructure with a single Docker command. No sales calls. No vendor lock-in. No per-call fees when self-hosted.

This article gives you a direct comparison between the two platforms, honest trade-offs, and a step-by-step guide to self-hosting Executor.sh with Docker.

What is Composio?

Composio launched in 2024 and became the default platform for AI agent tool calling. It raised a $25M Series A from Lightspeed Ventures in July 2025 (total funding: ~$29M) and has roughly 28,700 GitHub stars. The pitch: give your AI agent access to 1,000+ pre-built, pre-authenticated SaaS toolkits (Gmail, Slack, GitHub, Notion, Jira, Salesforce, and hundreds more) without writing integration code.

The platform handles OAuth flows end-to-end, manages token refresh, and scopes credentials per user. It provides SDKs for 25+ frameworks (OpenAI, Anthropic, LangChain, CrewAI, Vercel AI SDK, and the Mastra AI agent framework), a Tool Router for intent-based discovery, a sandboxed workbench for remote Python/JS execution, and bidirectional triggers for real-time communication with connected apps.

Composio is SOC 2 Type II and ISO 27001 certified. If your team needs compliance credentials out of the box, this is a real advantage.

Under the hood, Composio is a managed platform. The backend that stores credentials and executes tool calls is proprietary. The open-source GitHub repository contains SDKs and CLI tooling only, not the runtime. Your credentials and execution data flow through Composio’s cloud infrastructure on all self-serve plans.

Why look for a Composio alternative?

Composio is not bad software. But it has structural limitations that push developers to look elsewhere:

If any of these hit close to home, open-source alternatives deserve a serious look.

What is Executor.sh?

Executor.sh is an open-source MCP gateway built by Rhys Sullivan, a former OpenCode engineer. It went through Y Combinator’s S26 batch and has around 2,600 GitHub stars as of July 2026. The entire platform is MIT licensed.

The core idea: configure your integrations once (MCP servers, OpenAPI specs, GraphQL endpoints, custom JS tools), and every MCP-compatible agent shares them through one endpoint. Claude Code, Cursor, Codex, VS Code extensions, anything that speaks MCP (Model Context Protocol) works out of the box.

Key differentiators

Context efficiency. Instead of showing an agent thousands of tool definitions (~278,800 tokens), Executor shows one tool (~1,044 tokens). Tool schemas load dynamically only when needed. This can cut API costs noticeably on long agent sessions.

Protocol-level depth. Native connectors for MCP, OpenAPI, GraphQL, and Google Discovery. Point Executor at any spec and it auto-indexes every endpoint as a typed tool.

Semantic tool discovery. Agents search for tools by intent rather than memorizing names:

tools.discover({ query: "send a slack message" })

SES sandbox. Tool calls run in an isolated QuickJS sandbox. Credentials are injected host-side at call time and never enter the sandbox heap. This is a real security improvement over platforms where credentials live in the execution environment.

Pause/resume. Execution pauses for OAuth flows or human approval, then resumes cleanly. No hacky workarounds needed.

Policy engine. Each tool can be allowed, gated behind approval, or blocked. Policies are derived from spec semantics: GET vs DELETE for OpenAPI, destructiveHint for MCP.

Five deployment options: Cloud (hosted), Desktop app (Mac/Windows/Linux), CLI (npm i -g executor), Docker, and Cloudflare Workers.

You can add MCP server integrations like BrightData or any other MCP server to extend what your agents can do. And if you need to manage essential Docker commands for your deployment, we have a guide for that too.

Executor.sh vs Composio: head-to-head comparison

The most important differences are architectural. Composio gives you a curated catalog of pre-built integrations: you pick what you need and the platform handles auth, execution, and monitoring. Executor gives you a protocol-level proxy: you bring your own specs and it indexes, sandboxes, and exposes them as MCP tools.

Composio wins on breadth of pre-built integrations and framework adapter coverage. Executor wins on openness, self-hosting, context efficiency, and security model (credentials never touching the sandbox heap).

Executor.sh pricing vs Composio

At low volumes, Composio’s $29/month plan is cheaper than Executor’s $150/org/month Team plan. But the math flips as you scale:

Self-hosting Executor.sh with Docker

This is the section that matters most. If you are reading this article, you probably want to run this on your own infrastructure. The good news: it is genuinely simple.

Prerequisites

If you need a VPS, Hetzner Cloud offers affordable European servers starting at around €4.49/month, more than enough for running Docker containers like this. Hostinger VPS is another budget-friendly option with NVMe SSD storage if you prefer a different provider.

For managing your Docker deployments, Dokploy or Coolify give you a self-hosted PaaS experience with web dashboards and automatic HTTPS. You can also check our guide on self-hosted backends with Docker for more patterns.

Quick start with Docker run

One command gets you running:

docker run -d \
  --name executor-selfhost \
  -p 4788:4788 \
  -v executor-data:/data \
  ghcr.io/rhyssullivan/executor-selfhost:latest

That is it. Here is what each flag does:

• -p 4788:4788: exposes the Executor web console and MCP endpoint on port 4788
• -v executor-data:/data: persists all data (SQLite database, credentials, config) in a named Docker volume
• The image bundles everything: typed API, MCP server, authentication, QuickJS code execution, and web console

Open http://localhost:4788 in your browser. The first account you create becomes the owner. All subsequent users join via single-use invite links.

For headless setups (CI/CD, automated provisioning), pass bootstrap credentials:

docker run -d \
  --name executor-selfhost \
  -p 4788:4788 \
  -v executor-data:/data \
  -e [email protected] \
  -e EXECUTOR_BOOTSTRAP_ADMIN_PASSWORD=your-secure-password \
  -e EXECUTOR_WEB_BASE_URL=https://executor.yourdomain.com \
  ghcr.io/rhyssullivan/executor-selfhost:latest

Docker Compose setup

For a more maintainable setup, use Docker Compose:

services:
  executor:
    image: ghcr.io/rhyssullivan/executor-selfhost:latest
    container_name: executor-selfhost
    restart: unless-stopped
    ports:
      - "4788:4788"
    volumes:
      - executor-data:/data
    environment:
      - PORT=4788
      - EXECUTOR_DATA_DIR=/data
      # Optional: set your public URL
      # - EXECUTOR_WEB_BASE_URL=https://executor.yourdomain.com
      # Optional: headless bootstrap
      # - [email protected]
      # - EXECUTOR_BOOTSTRAP_ADMIN_PASSWORD=changeme

volumes:
  executor-data:

Save this as docker-compose.yml and run:

docker compose up -d

Backing up is straightforward. Snapshot the data.db file inside the /data volume. That single SQLite database contains everything: config, credentials, tool definitions, and user accounts.

If you are looking for more Docker-based AI deployments to run alongside Executor, there are plenty of options.

Reverse proxy with Caddy

For HTTPS on a custom domain, put Caddy in front:

executor.yourdomain.com {
    reverse_proxy localhost:4788
}

Caddy automatically provisions and renews TLS certificates. No config needed beyond the reverse proxy line.

Deploying with Dokploy

If you want a web UI to manage your Executor.sh deployment instead of SSH-ing into a server and editing compose files manually, Dokploy is a solid option. It is an open-source, self-hostable PaaS that runs on top of Docker and Traefik. You get a dashboard for deployments, automatic HTTPS, monitoring, and database backups without touching the command line after initial setup.

If you do not have Dokploy installed yet, follow our Dokploy installation guide to get it running on your VPS first.

Step 1: Create a new project and compose service

In the Dokploy dashboard, create a new project, then add a Docker Compose service. Paste the following compose file:

services:
  executor:
    image: ghcr.io/rhyssullivan/executor-selfhost:latest
    container_name: executor-selfhost
    networks:
      - dokploy-network
    restart: unless-stopped
    volumes:
      - executor-data:/data
    environment:
      - PORT=4788
      - EXECUTOR_DATA_DIR=/data
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.executor.rule=Host(`executor.yourdomain.com`)"
      - "traefik.http.routers.executor.entrypoints=websecure"
      - "traefik.http.routers.executor.tls.certresolver=letsencrypt"
      - "traefik.http.services.executor.loadbalancer.server.port=4788"

volumes:
  executor-data:

networks:
  dokploy-network:
    external: true

Replace executor.yourdomain.com with your actual domain. The dokploy-network is created automatically when Dokploy is installed.

Step 2: Set environment variables

Switch to the Environment tab and add any bootstrap variables you need:

[email protected]
EXECUTOR_BOOTSTRAP_ADMIN_PASSWORD=your-secure-password
EXECUTOR_WEB_BASE_URL=https://executor.yourdomain.com

Step 3: Point your domain and deploy

Add an A record in your DNS pointing executor.yourdomain.com to your server IP. Then go to the Domains tab in Dokploy, add the domain, and enable HTTPS. Hit Deploy and Dokploy handles the rest: pulling the image, starting the container, and configuring Traefik with a TLS certificate.

For a full walkthrough on deploying Docker Compose apps in Dokploy, including domain setup and Traefik label configuration, see our guide on deploying a Docker Compose app in Dokploy.

Once deployed, open https://executor.yourdomain.com in your browser. The first account you create becomes the owner, just like the standalone Docker setup.

Keeping the deployment up to date is simple. Dokploy lets you redeploy from the dashboard whenever a new image is pushed. For detailed update strategies including automated updates with Tugtainer, see our guide on updating Docker Compose stacks in Dokploy.

Connecting AI agents

Once your instance is running, point any MCP client at it. For Claude Code:

claude mcp add executor --transport sse https://executor.yourdomain.com/mcp

Or use the generic npx add-mcp command:

npx add-mcp https://executor.yourdomain.com/mcp

For Cursor, add the MCP server URL in Settings → MCP Servers. Any client that supports the MCP protocol works. The self-hosted endpoint behaves identically to the cloud version.

Self-hosting Executor.sh on Cloudflare Workers

If you do not want to manage a VPS, Executor also deploys to Cloudflare Workers. The architecture: a single Cloudflare Worker + D1 storage + Cloudflare Access for authentication.

git clone https://github.com/UsefulSoftwareCo/executor.git
cd executor/apps/host-cloudflare
bun run deploy:setup

The MCP endpoint lives at /mcp, gated by Cloudflare Access. No separate login app needed. Cloudflare handles authentication.

This option works well for personal use or small teams. For production workloads where you need full control over the runtime environment, Docker is the better path.

Adding integrations to your self-hosted Executor

Deploying Executor is step one. Connecting it to actual services is where the value comes from.

executor call executor openapi addIntegration \
  --spec-url https://api.example.com/openapi.json \
  --name "my-api" \
  --base-url https://api.example.com

executor call executor mcp addServer \
  --name "my-mcp-server" \
  --command "npx" \
  --args '["@my-org/mcp-server"]'

executor call executor graphql addIntegration \
  --endpoint https://api.example.com/graphql \
  --name "my-graphql-api" \
  --headers '{"Authorization": "Bearer $TOKEN"}'

Semantic tool discovery means agents do not need to know tool names. They describe what they want to do and Executor finds the right tool:

executor tools search "send email"

If you are creating your own AI agent or building with the Mastra framework, Executor gives you a single MCP endpoint that bundles all your integrations. For routing between multiple AI coding agents like Claude Code and Codex, Agent Router provides unified access alongside your Executor gateway. And for web data integrations, Bright Data offers structured data APIs you can connect via MCP.

When to choose Executor.sh (and when to stick with Composio)

This is not a “Composio bad, Executor good” article. Both platforms serve different needs. Here is an honest breakdown:

For teams exploring self-hosted AI infrastructure, guides on running AI agents on your own server can help you build the broader picture.

Frequently asked questions

Is Executor.sh the right Composio alternative for you?

If you are a self-hosting enthusiast, an open-source advocate, or a cost-conscious developer running multi-agent workflows, Executor.sh is worth a serious look. It solves the core pain points that push developers away from Composio: closed runtime, no self-hosting, and per-call pricing that scales poorly.

The self-hosted Docker deployment takes under a minute. You get a fully MIT-licensed MCP gateway with dynamic tool loading, sandboxed execution, and credential isolation, running entirely on your infrastructure.

Composio remains the stronger choice if you need 1,000+ pre-built integrations and managed OAuth without touching infrastructure. That is a valid need, and Composio fills it well.

But if you want control, transparency, and zero per-call costs at scale, Executor.sh is the open-source alternative worth trying.