Orbit: tareas, docs y chat en tu servidor con MCP

Tus tareas viven en Linear, tus documentos en Notion y las conversaciones del equipo en Slack. Tres suscripciones, tres sitios donde buscar y tres empresas con una copia de todo lo que haces.

Y ahora quieres que un agente de IA te ayude con todo eso. Toca darle acceso a los tres.

Orbit propone juntarlo en una sola aplicación que instalas en tu servidor. Tareas, documentos y chat en el mismo sitio, y un servidor MCP dentro del propio binario para que tu agente lo lea (y lo toque) sin que tus datos salgan de casa.

Lo firma Andras Bacsai, el creador de Coolify. Si ya usas Coolify, la filosofía te sonará: tú lo instalas y tú decides dónde viven tus datos.

Lo hemos instalado de cero con Docker, hemos creado un workspace con tareas, un documento y un canal de chat, y le hemos conectado un agente: Claude Code apuntando a un modelo de Ollama Cloud. El agente ha leído el chat, ha creado una tarea y ha movido otra de columna. Todo con capturas reales. En este post vas a ver:

• Qué es Orbit, quién está detrás y en qué punto de madurez está.
• Cómo se instala con Docker y Caddy, y las tres variables que no puedes olvidar.
• Qué trae de serie: tareas, documentos, chat, administración y backups.
• Cómo funciona su servidor MCP y qué herramientas expone.
• La prueba completa con un agente que usa un modelo de Ollama Cloud.

¿Qué es Orbit y quién lo ha creado? ¶

Orbit es un workspace autoalojado para equipos que junta tareas, documentos, chat y correo en una sola aplicación. Lo instalas en tu servidor, tus datos se quedan allí y los clientes de IA se conectan por MCP para trabajar con todo ese contexto.

El vídeo de lanzamiento que hay en su repositorio lo resume en una línea: “Tasks like Linear. Docs like Notion. One self-hosted workspace.” Tareas al estilo de Linear y documentos al estilo de Notion, en tu servidor.

El proyecto vive en github.com/coollabsio/orbit, en la misma organización que Coolify. Su autor principal es Andras Bacsai, que empezó Coolify en 2021 como proyecto paralelo y acabó dedicándose a él a tiempo completo. Si has leído nuestra guía para instalar Coolify en un VPS, ya conoces su forma de hacer las cosas: software que te instalas tú, con licencia abierta y pensado para que no dependas de nadie.

Algunos datos del repositorio, sacados del propio historial de git:

Es un proyecto de menos de tres meses. Va rápido, pero es una 0.1.

⚠️ Cuidado con el nombre. Si buscas «Orbit self-hosted» te saldrá sobre todo Orbit by Noveum, otro gestor de tareas de código abierto que también tiene servidor MCP. No tiene nada que ver con este. El que te contamos es el de coollabsio.

¿Qué problema resuelve Orbit? ¶

Resuelve dos cosas a la vez: la dispersión de herramientas y el acceso de los agentes a tu contexto de trabajo.

La primera es la de siempre. Cada herramienta SaaS es una isla con su propio buscador, sus permisos y su factura. El vídeo de lanzamiento de Orbit abre con tres frases que describen ese dolor: “Tasks in one app. Docs in another. Data on someone else’s servers.”

La segunda es más reciente.

Un agente de IA rinde mucho más cuando sabe en qué estás trabajando. Qué tareas tienes abiertas, qué decidió el equipo en el chat, qué dice la guía interna. Para dárselo con herramientas SaaS necesitas un MCP por cada servicio, cada uno con su autenticación, y tus datos pasan por servidores de terceros antes de llegar al modelo.

Orbit lo plantea al revés: el MCP es parte de la aplicación. Un endpoint, un login y permisos por proyecto.

🔑 Cuenta cuántos MCP tienes configurados hoy para tus herramientas de trabajo. Con Orbit, tareas, documentos y chat caben en uno.

Curso en vídeo

Antes de darle tu workspace a un agente, dale un flujo de trabajo

En la primera lección ves el flujo completo con un agente y tus prompts, sin frameworks, y en la tercera escribes las reglas de la sesión en un AGENTS.md.

Entra en el curso →

¿Qué incluye Orbit de serie? ¶

Incluye cuatro áreas de trabajo (tareas, documentos, chat y correo, este último aún en desarrollo), un panel de administración y backups. Esto es lo que dice su README, contrastado con lo que hemos visto en nuestra instalación:

La parte de tareas recuerda mucho a Linear: identificadores con prefijo por proyecto (GEN-1, BLOG-3), estados personalizables y atajos de teclado para casi todo. Tanto que, si pulsas una letra sin tener el foco en un campo, se te abre el diálogo de nueva tarea. Nos pasó al automatizar las capturas.

Los documentos usan un editor de bloques del estilo de Notion, con página, subpáginas, iconos, portadas y comentarios.

Y el chat es lo que esperas: canales, mensajes directos, hilos, menciones y emojis, al lado de las tareas de las que se habla.

¿Cómo funciona Orbit por dentro? ¶

Es un solo binario. Un servidor en Rust sirve la API y lleva dentro la aplicación web en React, ya compilada. Los datos van en SQLite por defecto o en Postgres si lo configuras, y los archivos en el disco local o en un bucket S3.

Eso tiene consecuencias prácticas que se agradecen:

• No hay Node, Bun ni Rust en el servidor. El README explica cómo sacar el ejecutable de la imagen y lanzarlo sin Docker.
• No hay Redis ni colas aparte. Los trabajos en segundo plano (backups, comprobaciones de integridad, notificaciones) se guardan en la propia base de datos.
• Consume muy poco. En nuestra prueba, la imagen ocupa 130 MB y el contenedor en reposo usaba unos 20 MiB de RAM.
• El MCP no es otro proceso. Vive en /mcp, dentro del mismo servidor.

Con SQLite solo puede haber un servidor, y la documentación lo deja claro: nunca dos procesos sobre la misma base de datos. Con Postgres sí se pueden poner varios servidores detrás de un balanceador. Así es como piensan ofrecer Orbit Cloud: el código ya trae la facturación con Stripe y un periodo de prueba configurable (7 días, 50 tareas, 20 páginas y 3 miembros por defecto).

💡 Que exista Orbit Cloud en el código no significa que esté abierto al público. A día de hoy lo que puedes usar es la versión que te instalas tú.

¿Cómo se instala Orbit con Docker? ¶

Se instala con Docker Compose y un proxy con HTTPS delante. El repositorio trae un deploy/compose.yaml con Orbit y Caddy, que saca el certificado de Let’s Encrypt.

En un servidor con dominio y los puertos 80 y 443 abiertos, son tres comandos:

git clone https://github.com/coollabsio/orbit && cd orbit
cp deploy/.env.example deploy/.env
# Edita deploy/.env: ORBIT_DOMAIN (sin https://) y ORBIT_APP_KEY
docker compose --env-file deploy/.env -f deploy/compose.yaml up -d --build

Ese --build compila la imagen en tu servidor (Rust y Bun incluidos), que tarda un rato. Si prefieres la imagen publicada, cambia el bloque build: del compose por image: ghcr.io/coollabsio/orbit:latest.

Las tres variables que Orbit exige en producción ¶

Orbit es estricto con la configuración: prefiere no arrancar antes que arrancar mal. Se lee solo de variables que empiezan por ORBIT_, y se niega a arrancar si encuentra una que no conoce. En producción, además, no arranca sin estas tres:

1. ORBIT_PUBLIC_ORIGIN: la URL pública exacta, con https://.
2. ORBIT_APP_KEY: la clave que cifra los secretos guardados (SMTP, claves de GitHub, tokens de Notion). Se genera con openssl rand -base64 32.
3. ORBIT_TRUSTED_PROXIES: las IP de tu proxy inverso, más 127.0.0.1/32 para el healthcheck de la imagen.

La tercera es la que más se olvida. Orbit solo se fía de las cabeceras X-Forwarded-* cuando la conexión viene de esas IP, y así sabe si la petición llegó por HTTPS y cuál es la IP real del cliente. Si pones 0.0.0.0/0 para salir del paso, cualquiera que llegue al puerto puede falsear su IP y saltarse los límites de peticiones. Orbit lo detecta y te avisa en el arranque.

🛡️ Guarda una copia de ORBIT_APP_KEY fuera del servidor y fuera de sus backups. Si restauras una base de datos sin la misma clave, Orbit no podrá leer los secretos guardados y quien tenga doble factor tendrá que configurarlo otra vez.

Nuestra instalación de prueba ¶

Para este post no hemos usado un servidor externo. Lo hemos montado en un contenedor de desarrollo, sin dominio público, con la imagen oficial y un Caddy con certificado interno:

docker run -d --name orbit --network host \  -e ORBIT_PUBLIC_ORIGIN=https://localhost:8443 \  -e ORBIT_TRUSTED_PROXIES=127.0.0.1/32,::1/128 \  -e ORBIT_BIND=127.0.0.1 \  -e ORBIT_APP_KEY="$(openssl rand -base64 32)" \  -v orbit-data:/var/lib/orbit -v orbit-backups:/var/backups/orbit \  ghcr.io/coollabsio/orbit:latest

Y el Caddyfile, que con tls internal firma el certificado con su propia autoridad local:

https://localhost:8443 {  tls internal  reverse_proxy 127.0.0.1:8080}

A los pocos segundos, /health/ready contesta con todas sus comprobaciones en verde: base de datos, migraciones, planificador y almacenamiento.

Un tropiezo: Docker Hub nos devolvió un 429 Too Many Requests al descargar la imagen de Caddy. Lo resolvimos con el espejo de Google, mirror.gcr.io/library/caddy:2-alpine. La de Orbit está en GitHub Container Registry y bajó sin problema.

🔑 ¿Y en Coolify? Orbit es una imagen Docker con un puerto, así que en teoría se despliega como cualquier otra. No lo hemos probado. Si lo haces, la pieza delicada es ORBIT_TRUSTED_PROXIES: tiene que llevar la IP de Traefik en la red de Docker.

¿Cómo es la configuración inicial? ¶

Es un asistente de tres pantallas. Orbit no trae usuario por defecto ni contraseña de ejemplo: en el primer arranque escribe en el log una URL de setup de un solo uso.

docker compose --env-file deploy/.env -f deploy/compose.yaml logs orbit
# Initial setup URL: https://tu-dominio/setup?token=...

Trata esa URL como un secreto. Quien la abra primero se queda con la instancia.

La primera pantalla crea la cuenta root: la que gestiona usuarios, backups, email y audit log, y la única que puede nombrar a otros administradores.

Después te pide el nombre del workspace y crea tu primer proyecto. Cada proyecto tiene un prefijo que da nombre a sus tareas (BLOG-1, BLOG-2…) y arranca con un flujo de seis estados: Backlog, Todo, In Progress, Done, Cancelled y Duplicate. Puedes cambiarlo cuando quieras, o saltarte el paso y quedarte con el proyecto General.

Si no configuras un servidor de correo, las invitaciones se comparten como enlace y la recuperación de contraseña la hace un administrador desde el panel. El registro abierto está cerrado por defecto: la gente entra por invitación.

Automatiza sin escribir backend

Si te gusta tenerlo en tu servidor, ponlo también a automatizar

Vas a montar n8n con Docker, construir workflows con RAG y bots con memoria, y verás un MCP que escribe los workflows desde Claude Code.

Entrar a la masterclass →

Masterclass en directo · 1h50min · 14 capítulos

¿Cómo funciona el servidor MCP de Orbit? ¶

Orbit sirve un endpoint MCP en <tu origen>/mcp con transporte Streamable HTTP. No hay que instalar nada aparte: viene en el mismo binario y lo encuentras en Settings → Agentic, con el comando listo para copiar en Claude Code, Codex o Grok.

Si nunca has conectado un MCP a tu agente, tienes los pasos para cada cliente en cómo instalar MCP en Claude Code, Copilot, OpenCode, Codex y Gemini. Orbit admite dos formas de autenticarse.

OAuth, con su propio servidor de autorización ¶

Orbit lleva dentro un servidor de autorización OAuth, sin proveedor de identidad externo. El cliente se registra solo (dynamic client registration), te manda al login de Orbit, eliges workspace, proyectos y permisos, y das acceso. Por debajo usa PKCE con S256.

Las reglas de seguridad son estrictas:

• Los tokens de acceso duran 15 minutos.
• Los de refresco duran 30 días y rotan en cada uso. Si alguien reutiliza uno ya gastado, Orbit revoca la conexión entera.
• Los proyectos aprobados se guardan en la concesión, no en los argumentos de las herramientas. El agente no puede pedir un proyecto que no le diste.
• En cada petición se comprueba la membresía, la suspensión de la cuenta y la revocación.

Tokens de API, para scripts y clientes con cabeceras ¶

La otra vía es un token de API que creas en Settings → API tokens. Eliges proyectos, caducidad y permisos: lectura, escritura de tareas (que incluye borrar), lectura de documentos y lectura de chat. El token va en la cabecera Authorization: Bearer.

Es la que hemos usado nosotros: nuestro agente se ejecutaba sin navegador y así nos ahorrábamos el baile del OAuth.

⚠️ El token se muestra una sola vez. Y ojo con «Never expires», que es la caducidad por defecto: para una prueba ponle fecha.

Qué herramientas expone ¶

Con un token de solo lectura, el MCP ofrece nueve herramientas. Al activar la escritura de tareas aparecen tres más. Esta es la lista completa que nos devolvió tools/list:

Documentos y chat son de solo lectura: el agente puede leer el canal, pero no escribir en él. El correo y la administración no se exponen.

Antes de meter un agente, puedes comprobar el endpoint con un curl:

curl https://tu-dominio/mcp \  -H "Authorization: Bearer $ORBIT_MCP_TOKEN" \  -H 'Content-Type: application/json' \  -H 'Accept: application/json, text/event-stream' \  -H 'MCP-Protocol-Version: 2025-11-25' \  --data '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"list_tasks","arguments":{"limit":5}}}'

El servidor es stateless: cada petición lleva sus credenciales y no hay sesión compartida. Si te interesa ese modelo, lo contamos en MCP stateless: cómo funciona el protocolo sin sesiones.

¿Cómo conectas un agente con Ollama Cloud a Orbit? ¶

Con dos piezas: un cliente que hable MCP y un modelo que sepa usar herramientas. Nosotros usamos Claude Code como cliente y GLM-5.3 de Ollama Cloud como modelo.

Ollama Cloud tiene una API compatible con la de Anthropic en https://ollama.com, así que Claude Code funciona con un modelo cloud cambiando dos variables de entorno. Antes de nada comprobamos qué modelos admiten herramientas con GET https://ollama.com/api/tags, que devuelve sus capacidades. GLM-5.3 trae tools y thinking.

Si quieres saber cuál elegir, en los modelos de Ollama Cloud en 2026 tienes la comparativa, y también ollama launch, que arranca Claude Code con un modelo cloud sin tocar variables. Nosotros lo hicimos a mano para controlar cada pieza.

El fichero de configuración del MCP ¶

Primero, un mcp.json con Orbit como servidor HTTP y el token en la cabecera:

{  "mcpServers": {    "orbit": {      "type": "http",      "url": "https://tu-dominio/mcp",      "headers": { "Authorization": "Bearer orb_..." }    }  }}

Claude Code apuntando a Ollama Cloud ¶

Después, Claude Code en modo no interactivo con la URL base de Ollama, tu API key y el modelo:

ANTHROPIC_BASE_URL=https://ollama.com \ANTHROPIC_AUTH_TOKEN="$OLLAMA_API_KEY" \ANTHROPIC_MODEL=glm-5.3 \claude -p "Usa orbit para ver mis tareas pendientes y la guía de publicación de los docs. Dime qué tarea debería hacer primero y por qué." \  --model glm-5.3 \  --mcp-config mcp.json --strict-mcp-config \  --allowedTools "mcp__orbit__*"

--strict-mcp-config hace que solo cargue los servidores de ese fichero, y --allowedTools "mcp__orbit__*" autoriza las herramientas de Orbit y nada más. El agente no puede ejecutar comandos en tu máquina ni tocar ficheros.

⚠️ Nuestro primer intento falló con un error de autenticación. La sesión heredaba otras variables ANTHROPIC_* y de configuración de Claude Code del entorno donde la lanzamos. Al ejecutarla con un entorno limpio (env -i y solo las variables necesarias), funcionó. Si te pasa, revisa qué tienes exportado.

Primera prueba: leer tareas y documentos ¶

Con el token de solo lectura, el agente hizo cuatro llamadas: buscó las herramientas, llamó a list_tasks, luego a list_docs y por último a get_doc para leer la guía. Tardó unos 8 segundos en total y respondió esto:

«Empieza por “Preparar newsletter del jueves”: es la única con fecha real —jueves es mañana (5-nov)— mientras las demás no tienen plazo.»

La tarea no tenía fecha de vencimiento. El modelo dedujo la urgencia del título y de la fecha del día. Acertó, pero ten en cuenta que esa deducción es suya: Orbit no le pasó ninguna fecha.

Segunda prueba: leer el chat y escribir tareas ¶

Luego creamos un token con permiso de escritura y le pedimos algo con más pasos: leer el canal #general, crear una tarea con prioridad alta a partir de lo que dijera y mover otra a In Progress.

El agente encadenó diez turnos en unos 10 segundos. Estas fueron sus llamadas, en orden:

1. list_conversations y list_projects para orientarse.
2. list_messages para leer el canal.
3. list_tasks y list_task_statuses para conocer las tareas y los ID de cada estado.
4. create_task con título, descripción y prioridad alta.
5. update_task para cambiar el estado, pasando expected_version: 0.

Fíjate en ese último paso. update_task exige la versión actual de la tarea: si alguien la ha cambiado entre medias, la escritura falla en vez de pisar el cambio. El agente la leyó antes y la mandó bien.

Al abrir la lista, las dos cosas estaban hechas: GEN-5 con su icono de prioridad alta y GEN-1 en In Progress. Y la descripción que escribió el agente tenía sentido: «Orbit ya está montado en local según el canal general. Hay que conectar el agente vía MCP mañana y verificar que las herramientas funcionan.»

🔑 En la actividad de la tarea, el autor aparece como el dueño del token, no como «el agente». Si quieres distinguir lo que hace la IA de lo que haces tú, crea el token con service account: Orbit lo ofrece para integraciones y le da una identidad propia.

¿Qué puede salir mal con Orbit? ¶

Lo que nos encontramos en la prueba y lo que avisa su documentación:

La última fila marca una diferencia práctica. Un agente que se ejecuta en tu máquina llega a un Orbit local sin problema. Uno que se ejecuta en la nube (un agente en remoto, un flujo programado) necesita que Orbit tenga una dirección HTTPS pública, con su ORBIT_PUBLIC_ORIGIN a juego.

💡 Para uso personal o de un equipo pequeño, Tailscale es un buen término medio: Orbit queda accesible con HTTPS desde tus dispositivos sin abrirlo a internet. La documentación lo contempla.

¿Orbit o seguir con Linear, Notion y Slack? ¶

Depende de qué te pese más: el control de tus datos o la madurez de la herramienta.

Ni Linear ni Notion se van a quedar quietos. Lo que Orbit tiene a favor es la combinación: todo junto, en tu servidor y con el MCP hecho desde el principio, no añadido después.

¿Cuándo merece la pena probar Orbit? ¶

Merece la pena si eres de los que ya se instala sus herramientas y quieres un sitio donde tu agente tenga todo el contexto de trabajo. Mírala con calma si dependes de muchas integraciones o no te apetece mantener un servidor más.

Pruébalo si:

• Ya tienes un VPS o un Coolify y te sobra sitio (consume muy poco).
• Trabajas con agentes y te cansa conectar un MCP distinto para cada herramienta.
• Quieres que las tareas, los documentos y el chat de un proyecto personal o de un equipo pequeño estén en un solo sitio.
• Te importa dónde están tus datos.

Espera un poco si:

• Tu equipo vive de las integraciones de Slack o de Notion.
• Necesitas el correo, que aún no está.
• No quieres encargarte de backups y actualizaciones de una versión 0.1 que cambia cada semana.

En una tarde pasamos de nada a un agente con un modelo de Ollama Cloud que lee nuestro chat y nos ordena las tareas, sin un solo dato fuera de la máquina salvo lo que viaja al modelo.

¿Le vas a dar las llaves de tu workspace a un agente?

TL;DR ¶

• 🪐 Orbit es un workspace autoalojado con tareas al estilo de Linear, documentos al estilo de Notion y chat, de Andras Bacsai, el creador de Coolify.
• 📦 Es un solo binario en Rust con la web dentro, SQLite o Postgres, y en reposo usa unos 20 MiB de RAM.
• 🔐 En producción exige HTTPS, ORBIT_APP_KEY y ORBIT_TRUSTED_PROXIES, y no arranca si falta alguna.
• 🤖 Trae un servidor MCP en /mcp con OAuth propio o tokens de API: 12 herramientas, con escritura solo para tareas.
• ⚡ Claude Code con GLM-5.3 de Ollama Cloud leyó el chat, creó una tarea y movió otra en unos 10 segundos.

Preguntas frecuentes ¶

¿Qué es Orbit de coollabsio? ¶

Orbit es un workspace de código abierto para equipos que juntas tareas, documentos, chat y, más adelante, correo en una aplicación que instalas en tu servidor. Incluye un servidor MCP para que los agentes de IA trabajen con ese contexto. Tiene licencia Apache 2.0.

¿Quién ha creado Orbit? ¶

Orbit está en la organización coollabsio de GitHub, la misma de Coolify, y su autor principal es Andras Bacsai, creador de Coolify. Firma 354 de los 558 commits que tenía el repositorio a 4 de noviembre de 2026.

¿Orbit es gratis? ¶

El código es abierto con licencia Apache 2.0 y puedes instalarlo gratis en tu servidor. El repositorio también incluye la facturación de un futuro Orbit Cloud con Stripe, pensado como versión alojada de pago.

¿Qué necesito para instalar Orbit? ¶

Docker, un dominio que apunte al servidor y los puertos 80 y 443 abiertos para el certificado. El repositorio trae un compose.yaml con Orbit y Caddy. Necesitas generar una ORBIT_APP_KEY con openssl rand -base64 32.

¿Orbit usa SQLite o Postgres? ¶

Los dos. SQLite es la opción por defecto y sirve para un solo servidor. Con ORBIT_DATABASE_URL puedes usar Postgres, que permite varios servidores de Orbit sobre la misma base de datos detrás de un balanceador.

¿Cómo conecto Claude Code al MCP de Orbit? ¶

Con claude mcp add --scope user --transport http orbit https://tu-dominio/mcp y luego /mcp dentro de Claude Code para autenticarte por OAuth. Si prefieres un token de API, pásalo en la cabecera Authorization: Bearer desde un mcp.json.

¿El MCP de Orbit puede escribir datos? ¶

Solo en tareas, y solo si el token o la concesión OAuth incluye el permiso de escritura. Entonces aparecen create_task, update_task y delete_task. Documentos y chat son de solo lectura, y el correo y la administración no se exponen.

¿Puedo usar Orbit con un modelo de Ollama Cloud? ¶

Sí. Orbit no depende del modelo: lo que se conecta es el cliente MCP. Nosotros usamos Claude Code con ANTHROPIC_BASE_URL=https://ollama.com y el modelo GLM-5.3, y funcionó con lectura y escritura de tareas.

¿Orbit tiene app móvil? ¶

Sí, para iOS y Android, según el README. Algunas funciones solo están en la web: vistas guardadas, cronograma, papelera de tareas, ajustes de GitHub, exportación, tokens de API e importación de Notion.

¿Es lo mismo Orbit que Orbit by Noveum? ¶

No. Orbit by Noveum es otro gestor de tareas de código abierto con servidor MCP, de otros autores. El Orbit de este post es el de coollabsio, el equipo de Coolify.

Fuentes ¶

• Repositorio de Orbit en GitHub
• Orbit: guía de despliegue (deploy/README.md)
• Orbit: operaciones y configuración (docs/operations.md)
• Orbit: servidor MCP (docs/mcp.md)
• Andras Bacsai en GitHub
• Especificación de MCP: transporte Streamable HTTP

🧨 Última oprtunidad para recibir la dinamita que mereces sobre programación con IA el próximo domingo: Suscríbete gratis a Web Reactiva en https://webreactiva.com/newsletter