Executor.sh: Alternativa Autoalojada y de Código Abierto a Composio

Todo agente de IA necesita herramientas. Ya sea enviar mensajes de Slack, consultar una base de datos o llamar a una API de terceros, el agente tiene que conectarse a servicios externos de alguna forma. Composio construyó un negocio alrededor de esto: más de 1,500 toolkits preconstruidos, OAuth gestionado y un runtime alojado que se encarga de todo por ti. Funciona, y funciona bien para equipos que quieren una plataforma totalmente gestionada.

Pero si quieres autoalojar, inspeccionar el runtime o evitar los precios por llamada a escala, el planteamiento de Composio se desmorona. El runtime es de código cerrado. El autoalojamiento requiere un contrato Enterprise. Y las credenciales pasan por su nube en los planes self-serve.

Ahí es donde entra Executor.sh. Es un gateway MCP totalmente de código abierto. Configura tus integraciones una vez y cada agente compatible con MCP las comparte a través de un solo endpoint. Puedes ejecutarlo en tu propia infraestructura con un único comando de Docker. Sin llamadas comerciales. Sin dependencia del proveedor. Sin tarifas por llamada cuando lo autoalojas.

Este artículo te ofrece una comparación directa entre las dos plataformas, los compromisos honestos y una guía paso a paso para autoalojar Executor.sh con Docker.

¿Qué es Composio?

Composio se lanzó en 2024 y se convirtió en la plataforma por defecto para las llamadas a herramientas de agentes de IA. Levantó una Serie A de $25M de Lightspeed Ventures en julio de 2025 (financiación total: ~$29M) y tiene aproximadamente 30,300 estrellas en GitHub a septiembre de 2026. La propuesta: dale a tu agente de IA acceso a más de 1,500 toolkits SaaS preconstruidos y preautenticados (Gmail, Slack, GitHub, Notion, Jira, Salesforce y cientos más) sin escribir código de integración.

La plataforma gestiona los flujos OAuth de principio a fin, administra la renovación de tokens y limita las credenciales por usuario. Ofrece SDKs para más de 25 frameworks (OpenAI, Anthropic, LangChain, CrewAI, Vercel AI SDK y el framework de agentes de IA Mastra), un Tool Router para el descubrimiento basado en intención, un workbench en sandbox para ejecución remota de Python/JS, triggers para trabajo orientado a eventos y un leaderboard Composio Bench para medir agentes en tareas reales de uso de herramientas. Ahora también se pueden registrar servidores MCP personalizados gratis, así que el catálogo va más allá de la lista preconstruida. Para el recorrido completo por la parte gestionada, consulta mi guía de Composio MCP.

Composio tiene las certificaciones SOC 2 Type II e ISO 27001. Si tu equipo necesita credenciales de cumplimiento desde el primer día, esto es una ventaja real.

En el fondo, Composio es una plataforma gestionada. El backend que almacena las credenciales y ejecuta las llamadas a herramientas es propietario. El repositorio de código abierto en GitHub solo contiene los SDKs y las herramientas del CLI, no el runtime. Tus credenciales y datos de ejecución pasan por la infraestructura en la nube de Composio en todos los planes self-serve.

¿Por qué buscar una alternativa a Composio?

Composio no es mal software. Pero tiene limitaciones estructurales que empujan a los desarrolladores a buscar alternativas:

Si alguna de estas te suena de cerca, las alternativas de código abierto merecen una mirada seria.

¿Qué es Executor.sh?

Executor.sh es un gateway MCP de código abierto creado por Rhys Sullivan, ex ingeniero de OpenCode. Pasó por el batch S26 de Y Combinator y ha crecido hasta las 3,982 estrellas en GitHub a septiembre de 2026 (desde ~2,600 en julio). Toda la plataforma tiene licencia MIT.

La idea central: configura tus integraciones una vez (servidores MCP, especificaciones OpenAPI, endpoints GraphQL, herramientas JS personalizadas) y cada agente compatible con MCP las comparte a través de un solo endpoint. Claude Code, Cursor, Codex, extensiones de VS Code, cualquier cosa que hable MCP (Model Context Protocol) funciona de inmediato. El modelo es integración → conexión → política: una integración puede tener muchas conexiones, y cada herramienta dentro puede estar permitida, requerir aprobación o estar bloqueada.

Diagrama de arquitectura de Executor.sh: los clientes MCP se conectan a través del gateway Executor a APIs externas mediante el sandbox SES con inyección de credenciales del lado del host

Diferenciadores clave

Eficiencia de contexto. En lugar de mostrar a un agente miles de definiciones de herramientas (~278,800 tokens), Executor muestra una herramienta (~1,044 tokens). Los esquemas de las herramientas se cargan dinámicamente solo cuando se necesitan. Esto puede reducir los costes de API de forma notable en sesiones largas de agentes.

Profundidad a nivel de protocolo. Conectores nativos para MCP, OpenAPI, GraphQL y Google Discovery. Apunta Executor a cualquier spec e indexa automáticamente cada endpoint como una herramienta tipada.

Descubrimiento semántico de herramientas. Los agentes buscan herramientas por intención en lugar de memorizar nombres:

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

Sandbox SES. Las llamadas a herramientas se ejecutan en un sandbox QuickJS aislado. Las credenciales se inyectan del lado del host en el momento de la llamada y nunca entran en el heap del sandbox. Es una mejora de seguridad real frente a plataformas donde las credenciales viven en el entorno de ejecución.

Pausa/reanudación. La ejecución se pausa para flujos OAuth o aprobación humana, y luego se reanuda limpiamente con executor resume --execution-id exec_123. Sin soluciones improvisadas.

Motor de políticas. Cada herramienta puede estar permitida, requerir aprobación o estar bloqueada. Las políticas se derivan de la semántica de la spec: GET frente a DELETE para OpenAPI, destructiveHint para MCP.

Cinco opciones de despliegue: Cloud (alojado), app de escritorio (Mac/Windows/Linux), CLI (npm i -g executor, y luego executor install lo ejecuta como un servicio duradero en segundo plano), Docker y Cloudflare Workers. El sistema de plugins está abierto a cualquier tipo de integración, y un SDK de TypeScript (@executor-js/sdk, con APIs nativas de Promise y Effect) incrusta el runtime en tu propio código.

Puedes añadir integraciones de servidores MCP como BrightData o cualquier otro servidor MCP para ampliar lo que tus agentes pueden hacer. Y si necesitas gestionar los comandos esenciales de Docker para tu despliegue, también tenemos una guía para eso.

Executor.sh vs Composio: comparación cara a cara

Las diferencias más importantes son arquitectónicas. Composio te da un catálogo curado de integraciones preconstruidas: eliges lo que necesitas y la plataforma se encarga de la autenticación, la ejecución y el monitoreo. Executor te da un proxy a nivel de protocolo: tú traes tus propias specs y él las indexa, las ejecuta en sandbox y las expone como herramientas MCP.

Composio gana en amplitud de integraciones preconstruidas y cobertura de adaptadores de frameworks. Executor gana en apertura, autoalojamiento, eficiencia de contexto, modelo de seguridad (las credenciales nunca tocan el heap del sandbox) y predictibilidad de precios.

Precios de Executor.sh vs Composio

Executor cambió sus precios en la segunda mitad de 2026 y el nuevo modelo es mucho más amigable: el plan Team bajó de $150/org/mes a $15/miembro/mes con ejecuciones ilimitadas, y el nivel gratuito pasó de 10K a 100K ejecuciones/mes. Composio fue en dirección contraria: $29/mes compra un crédito de uso y luego cada llamada se factura a $0.0003.

Gráfico comparativo de precios: coste de Executor.sh vs Composio a diferentes volúmenes de llamadas

Autoalojar Executor.sh con Docker

Esta es la sección que más importa. Si estás leyendo este artículo, probablemente quieres ejecutarlo en tu propia infraestructura. La buena noticia: es genuinamente sencillo.

Si solo quieres Executor en un portátil sin Docker, el CLI mejoró mucho desde julio: npm i -g executor, luego executor install registra un servicio duradero en segundo plano que sobrevive a los reinicios, y executor web abre la consola (en http://127.0.0.1:4788). executor daemon status|stop|restart gestiona el servicio. Para un servidor sí conviene la ruta Docker de abajo, pero para uso local el CLI es la instalación más limpia.

Requisitos previos

Si necesitas un VPS, Hetzner Cloud ofrece servidores europeos asequibles desde unos €4.49/mes, más que suficiente para ejecutar contenedores Docker como este. Hostinger VPS es otra opción económica con almacenamiento NVMe SSD si prefieres un proveedor diferente.

Los precios de los VPS subieron en general en 2026 — si estás reconsiderando un servidor alquilado, mira qué cambió y cuándo gana un mini PC.

Para gestionar tus despliegues Docker, Dokploy o Coolify te dan una experiencia PaaS autoalojada con paneles web y HTTPS automático. También puedes consultar nuestra guía sobre backends autoalojados con Docker para más patrones.

Inicio rápido con docker run

Un solo comando te deja en marcha:

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

Eso es todo. Esto es lo que hace cada flag:

• -p 4788:4788: expone la consola web de Executor y el endpoint MCP en el puerto 4788
• -v executor-data:/data: persiste todos los datos (base de datos SQLite, credenciales, config) en un volumen Docker con nombre
• La imagen incluye todo: API tipada, servidor MCP, autenticación, ejecución de código QuickJS y consola web

Abre http://localhost:4788 en tu navegador. La primera cuenta que crees se convierte en la propietaria. Todos los usuarios siguientes se unen mediante enlaces de invitación de un solo uso.

Para instalaciones sin interfaz (CI/CD, aprovisionamiento automatizado), pasa las credenciales de arranque:

docker run -d \
  --name executor-selfhost \
  -p 4788:4788 \
  -v executor-data:/data \
  -e EXECUTOR_BOOTSTRAP_ADMIN_EMAIL=admin@example.com \
  -e EXECUTOR_BOOTSTRAP_ADMIN_PASSWORD=your-secure-password \
  -e EXECUTOR_WEB_BASE_URL=https://executor.yourdomain.com \
  ghcr.io/rhyssullivan/executor-selfhost:latest

Configuración con Docker Compose

Para una configuración más fácil de mantener, usa 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
      # - EXECUTOR_BOOTSTRAP_ADMIN_EMAIL=admin@example.com
      # - EXECUTOR_BOOTSTRAP_ADMIN_PASSWORD=changeme

volumes:
  executor-data:

Guárdalo como docker-compose.yml y ejecuta:

docker compose up -d

Hacer copias de seguridad es sencillo. Haz una instantánea del archivo data.db dentro del volumen /data. Esa única base de datos SQLite contiene todo: configuración, credenciales, definiciones de herramientas y cuentas de usuario.

Si buscas más despliegues de IA basados en Docker para ejecutar junto a Executor, hay muchas opciones.

Proxy inverso con Caddy

Para HTTPS en un dominio personalizado, pon Caddy delante:

executor.yourdomain.com {
    reverse_proxy localhost:4788
}

Caddy aprovisiona y renueva los certificados TLS automáticamente. No se necesita más configuración que la línea del proxy inverso.

Despliegue con Dokploy

Si quieres una interfaz web para gestionar tu despliegue de Executor.sh en lugar de conectarte por SSH a un servidor y editar archivos compose manualmente, Dokploy es una opción sólida. Es un PaaS de código abierto y autoalojable que corre sobre Docker y Traefik. Obtienes un panel para despliegues, HTTPS automático, monitoreo y copias de seguridad de bases de datos sin tocar la línea de comandos tras la instalación inicial.

Si aún no tienes Dokploy instalado, sigue nuestra guía de instalación de Dokploy para ponerlo en marcha en tu VPS primero.

Paso 1: Crea un proyecto nuevo y un servicio compose

En el panel de Dokploy, crea un proyecto nuevo y luego añade un servicio Docker Compose. Pega el siguiente archivo compose:

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

Sustituye executor.yourdomain.com por tu dominio real. La red dokploy-network se crea automáticamente cuando se instala Dokploy.

Paso 2: Define las variables de entorno

Ve a la pestaña Environment y añade las variables de arranque que necesites:

EXECUTOR_BOOTSTRAP_ADMIN_EMAIL=admin@yourdomain.com
EXECUTOR_BOOTSTRAP_ADMIN_PASSWORD=your-secure-password
EXECUTOR_WEB_BASE_URL=https://executor.yourdomain.com

Paso 3: Apunta tu dominio y despliega

Añade un registro A en tu DNS apuntando executor.yourdomain.com a la IP de tu servidor. Luego ve a la pestaña Domains en Dokploy, añade el dominio y activa HTTPS. Pulsa Deploy y Dokploy se encarga del resto: descargar la imagen, arrancar el contenedor y configurar Traefik con un certificado TLS.

Para un recorrido completo sobre el despliegue de apps Docker Compose en Dokploy, incluida la configuración de dominio y las etiquetas de Traefik, consulta nuestra guía sobre desplegar una app Docker Compose en Dokploy.

Una vez desplegado, abre https://executor.yourdomain.com en tu navegador. La primera cuenta que crees se convierte en la propietaria, igual que en la instalación Docker independiente.

Mantener el despliegue actualizado es sencillo. Dokploy te permite redesplegar desde el panel cada vez que se publica una imagen nueva. Para estrategias de actualización detalladas, incluidas las actualizaciones automatizadas con Tugtainer, consulta nuestra guía sobre actualizar stacks de Docker Compose en Dokploy.

Conectar agentes de IA

Una vez que tu instancia esté en marcha, apunta cualquier cliente MCP hacia ella. El endpoint es HTTP streamable en /mcp. Para Claude Code:

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

O usa el comando genérico npx add-mcp, que detecta el cliente y escribe su configuración por ti:

npx add-mcp https://executor.yourdomain.com/mcp --transport http --name executor

Para Cursor, añade la URL del servidor MCP en Settings → MCP Servers. Cualquier cliente que soporte el protocolo MCP funciona. La tarjeta Connect de la interfaz web muestra el comando exacto para tu instancia con la URL ya rellenada. El endpoint autoalojado se comporta igual que la versión cloud, y la mayoría de los clientes solo cargan los servidores MCP al arrancar, así que reinicia el cliente o abre un chat nuevo si las herramientas de Executor no aparecen.

Autoalojar Executor.sh en Cloudflare Workers

Si no quieres gestionar un VPS, Executor también se despliega en Cloudflare Workers. La arquitectura: un único Cloudflare Worker + almacenamiento D1 + Cloudflare Access para la autenticación.

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

El endpoint MCP vive en /mcp, protegido por Cloudflare Access. No hace falta una app de login separada. Cloudflare gestiona la autenticación.

Esta opción funciona bien para uso personal o equipos pequeños. Para cargas de producción donde necesitas control total sobre el entorno de ejecución, Docker es el mejor camino.

Añadir integraciones a tu Executor autoalojado

Desplegar Executor es el paso uno. Conectarlo a servicios reales es de donde viene el valor.

executor call executor openapi addIntegration '{
  "spec": "https://api.example.com/openapi.json",
  "namespace": "my-api",
  "baseUrl": "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",
  "namespace": "my-graphql-api",
  "headers": {"Authorization": "Bearer $TOKEN"}
}'

El descubrimiento semántico de herramientas significa que los agentes no necesitan conocer los nombres de las herramientas. Describen lo que quieren hacer y Executor encuentra la herramienta adecuada:

executor tools search "send email"        # find tools by intent
executor tools describe github issues     # show a tool's schema
executor resume --execution-id exec_123   # resume a paused execution

Si estás creando tu propio agente de IA o construyendo con el framework Mastra, Executor te da un único endpoint MCP que agrupa todas tus integraciones. Para enrutar entre varios agentes de codificación con IA como Claude Code y Codex, Agent Router ofrece acceso unificado junto a tu gateway Executor. Y para integraciones de datos web, Bright Data ofrece APIs de datos estructurados que puedes conectar vía MCP.

Cuándo elegir Executor.sh (y cuándo quedarse con Composio)

Este no es un artículo de «Composio malo, Executor bueno». Ambas plataformas sirven a necesidades diferentes. Aquí va un desglose honesto:

Para equipos que exploran infraestructura de IA autoalojada, las guías sobre ejecutar agentes de IA en tu propio servidor pueden ayudarte a construir una visión más amplia.

Preguntas frecuentes

¿Es Executor.sh la alternativa a Composio adecuada para ti?

Si eres un entusiasta del autoalojamiento, un defensor del código abierto o un desarrollador consciente de los costes que ejecuta flujos de trabajo multiagente, Executor.sh merece una mirada seria. Resuelve los problemas centrales que alejan a los desarrolladores de Composio: runtime cerrado, sin autoalojamiento y precios por llamada que escalan mal.

El despliegue Docker autoalojado lleva menos de un minuto. Obtienes un gateway MCP con licencia MIT completa, carga dinámica de herramientas, ejecución en sandbox y aislamiento de credenciales, corriendo enteramente en tu infraestructura.

Composio sigue siendo la opción más fuerte si necesitas más de 1,500 integraciones preconstruidas y OAuth gestionado sin tocar infraestructura. Es una necesidad válida, y Composio la cubre bien.

Pero si quieres control, transparencia y cero costes por llamada a escala, Executor.sh es la alternativa de código abierto que vale la pena probar.