Octomind

Runtime de agente de IA de código abierto en CLI con Rust — host MCP con registro dinámico de servidores, más de 48 agentes especializados y más de 13 proveedores de LLM.

GitHub

146

Prueba este MCPPatrocinado

Documentación

El runtime de agente de codificación con IA, primero en CLI.
Conéctalo, prográmalo, intégralo. Un solo binario, múltiples proveedores de modelos, nativo de MCP: diseñado para trabajo autónomo, no solo para chat.

Documentación · Registro de Taps · Sitio web

Octomind es un cliente de agente de IA de código abierto: el modelo llama a herramientas MCP para hacer trabajo real — leer y escribir archivos, ejecutar shells, buscar código, delegar a subagentes. El mismo runtime admite varios puntos de entrada: la misma sesión se ejecuta interactivamente, a través de stdin por tubería, como daemon en segundo plano, sobre WebSocket, o como subagente ACP dentro de la pila de otro agente. Modelos, herramientas, roles, salvaguardas, presupuestos — todo es TOML, sin código de framework.

# Interactive
octomind run developer:general

# Piped — CI, scripts, automation
echo "Explain the auth module" | octomind run developer:general --format plain

# Daemon — long-running; send from another terminal on the same machine
echo "watch the build" | octomind run --name watcher --daemon --format jsonl
octomind send --name watcher "run the test suite"

Tabla de Contenidos

Inicio Rápido
Benchmarks — PRs Reales, Pruebas Reservadas
¿Por Qué Octomind?
Un Binario, Cinco Superficies
Salvaguardas — Política como Código
Costo como Plano de Control
Sesiones que Siguen Ágiles a la Hora 4
Contexto Impulsado por Intención
Especialistas y Taps
Herramientas MCP Integradas
Usuarios Avanzados — Roles, Flujos de Trabajo, Capas
Instalación
Configuración
Arquitectura
Contribuciones
Documentación
Licencia

Inicio Rápido

# Install (macOS & Linux) — single Rust binary; taps install their own tool dependencies
curl -fsSL https://raw.githubusercontent.com/muvon/octomind/master/install.sh | bash

# Sign in — models included, no API keys to manage
octomind login

# Start with a specialist — first use may install tools and request credentials
octomind run developer:general

        Octomind v0.50.1
        Role: developer:general · Model: octohub:auto
        ~/your/project
> _

Estás en una sesión con un agente que puede leer tu código, ejecutar comandos, editar archivos y ampliar capacidades según sea necesario. Interfaz de línea simple con renderizado de markdown y completado de shell — sin TUI que aprender, funciona sobre SSH, en tmux, en registros de CI.

octomind login te conecta a Octomind Cloud — una suscripción que incluye acceso a modelos a través de la puerta de enlace octohub, así que no hay nada que configurar. ¿Prefieres tus propias claves? Omite el inicio de sesión por completo y trae cualquier proveedor: OpenRouter, Anthropic, OpenAI, DeepSeek, Ollama y más. Cloud es la base; BYOK siempre es una vía de primera clase.

developer:general (y lawyer:sg, doctor:blood, …) provienen del tap predeterminado integrado muvon/tap, no de tu configuración local. La etiqueta predeterminada de la configuración es assistant:concierge, así que octomind run simple inicia eso. El banner anterior es ilustrativo (el real renderiza un ícono de píxeles a la izquierda del bloque de texto).

Otras instalaciones: cargo install octomind (Rust 1.95+) o compilar desde el código fuente.

Benchmarks — PRs Reales, Pruebas Reservadas

Evaluamos con octobench: 25 tareas extraídas de pull requests fusionados en python, php, rust, c++ y js. Cada agente trabaja en el repositorio previo a la corrección; las pruebas reservadas de la corrección fusionada deciden aprobar o reprobar. Estos son los resultados publicados el 30 de julio de 2026, no una medición del checkout actual:

	resueltas	juez Σ / 2500	costo	tiempo real
octomind + glm-5.2	24/25	2264	$63.43	3.6h
claude code + claude-opus-5	23/25	2262	$81.79	6.7h
codex + gpt-5.6-sol	21/25	2127	$14.86	1.0h
opencode + glm-5.2	19/25	2093	$129.54	3.3h

El entorno importa. opencode usó el mismo modelo y endpoint. octomind resolvió 24 contra 19 a aproximadamente la mitad del costo. Octomind usó un tap por etapas y una anulación binaria con la pre-puerta de devolución incompleta; esto mide la configuración completa, no características individuales.
Precio en el peor caso, aún adelante. glm-5.2 se ejecutó sin caché de prompts (cada token a precio de lista) mientras que Opus facturó ~97% de relecturas de contexto a tasas de caché de 1/10 — y octomind aún lideró en resoluciones, costo y tiempo real.
Reproducible. Tabla completa por caso, artefactos de ejecución y guía de reproducción: BENCHMARK.md @ 8aa3968. La historia detrás del benchmark: publicación de blog.

¿Por Qué Octomind?

El runtime te da controles para el trabajo que continúa después de que dejas el teclado:

La autonomía necesita política. Aplica reglas previas a la llamada y retroalimenta fallos de scripts al agente con Salvaguardas.
Comparte una configuración de trabajo. Un tap empaqueta instrucciones del agente, dependencias y acceso a herramientas. Inicia un especialista con octomind run developer:general.
Elige un especialista. Usa diferentes roles para depuración, investigación o revisión, con sus propias instrucciones, anulaciones de modelo y herramientas.
Mantén tareas largas en movimiento. Compresión reduce el contexto acumulado mientras retiene el conocimiento de la tarea y el intercambio en vivo.
Rastrea gastos. Configura umbrales de solicitud y sesión e inspecciona costos con /info. Consulta Costo.
Carga contexto bajo demanda. Habilidades y capacidades pueden activarse desde tu entrada.

Pilar	Lo que te da
Cero configuración, máxima flexibilidad	`octomind run lawyer:sg` funciona de inmediato. ¿Necesitas un modelo, servidor MCP o tubería de salvaguardas diferente? Mismo TOML, sin código de framework.
Sesiones ágiles a la hora 4	Compactación adaptativa: consciente de caché, preservación estructural. Contexto más pequeño = respuestas más rápidas + menor costo.
Costo como plano de control	Selección de modelo por paso entre muchos proveedores. Umbrales de gasto y contabilidad consciente de caché incluidos.
Salvaguardas: política como código	Gobierna agentes autónomos con scripts deterministas — guardas previas a la llamada, hooks posteriores al resultado, validadores posteriores al turno. Sin clics de aprobación modal. Encaja en CI.
Contexto impulsado por intención	Las habilidades y capacidades pueden activarse mediante reglas, coincidencia semántica o solicitudes explícitas. Contexto más pequeño por defecto, menor costo, sin herramientas sorpresa.

Un Binario, Cinco Superficies

El mismo motor de sesión, expuesto como tu flujo de trabajo lo necesite:

Modo	Úsalo para
CLI interactivo	Trabajo diario, cualquier dominio
Tubería `octomind run --format plain`	Pipelines de CI/CD, scripts de shell, automatización
Daemon + enviar	Agentes en segundo plano, monitoreo continuo, tareas de larga duración
Servidor WebSocket (`octomind server`)	Plugins de IDE, paneles web, integraciones externas
Protocolo ACP (`octomind acp`)	Orquestación multiagente, ser llamado por otros agentes

# ACP — drop into any multi-agent system as a sub-agent
octomind acp developer:general

# Non-interactive — the message is read from stdin (pipe it in), output as plain text
echo "Explain the auth module" | octomind run developer:general --format plain

# Structured JSONL output for pipelines
echo "List TODO items" | octomind run developer:general --format jsonl

# Daemon — keep alive; run send in another terminal on the same machine
echo "first task" | octomind run --name watcher --daemon --format jsonl
octomind send --name watcher "now run the test suite"

# Structured output — create the schema first (requires a supporting model)
cat > todos.schema.json <<'JSON'
{
  "type": "object",
  "properties": {"items": {"type": "array", "items": {"type": "string"}}},
  "required": ["items"],
  "additionalProperties": false
}
JSON
echo "List TODO items as JSON" | octomind run developer:general --format jsonl --schema todos.schema.json

octomind run no tiene argumento de mensaje: su argumento posicional es un rol o etiqueta de tap. El stdin por tubería se ejecuta de forma no interactiva, con plain como predeterminado; --format plain o --format jsonl selecciona el formato de salida. En una terminal, --format sin entrada por tubería genera un error a menos que también uses --daemon. Sin --format, una terminal inicia una sesión interactiva. server y acp no aceptan --format.

--daemon mantiene el proceso vivo; no lo separa de tu terminal. Usa otra terminal para octomind send. Para requisitos de esquema y soporte de modelos, consulta Salida Estructurada.

Consulta Servidor WebSocket, Protocolo ACP y Daemon y Hooks para los modos de integración.

Un binario. Cada flujo de trabajo.

Salvaguardas — Política como Código

Una tarea de larga duración, trabajo de CI o bucle autónomo necesita reglas repetibles para la ejecución de herramientas y la validación.

La política vive en reglas y scripts TOML. Coloca un .agents/guardrails.toml en tu repositorio y el runtime lo aplica de forma determinista — previa a la llamada, posterior al resultado, posterior al turno.

# Pre-call deny — block a class of calls before they execute
[[guard]]
match   = "shell(command=^rm\\s+-rf?)"
message = "rm -rf blocked."

# Conditional rule — only fires after the agent ran git status this session
[[guard]]
match   = "shell(command=git push)"
when    = ["+shell(command=git status)"]
message = "Review changes before pushing."

Guardas — reglas de denegación previas a la llamada. Coinciden por capability(arg_name=regex), condicionan por historial (+used / -unused), requieren capacidades cargadas (has = [...]). Una llamada coincidente devuelve una denegación en lugar de ejecutarse.
Hooks — scripts posteriores al resultado. Se ejecutan después de resultados de herramientas coincidentes. Una salida distinta de cero inyecta stdout en la bandeja de entrada del agente como mensaje de usuario — errores de clippy, fallos de lint, diferencias de formato se convierten en correcciones automáticas sin reiniciar el turno.
Validadores — scripts posteriores al turno. Sus filtros de historial when inspeccionan llamadas desde la ejecución anterior; sin when, pueden ejecutarse cada turno. Filtran por rol y texto de respuesta. La salida se envuelve en bloques <validation> que el agente lee en su próximo turno. Esto es lo que reemplaza los avisos de "¿aprobar este cambio?" en bucles autónomos.

El DSL combina capacidad+regex de argumento+historial+rol+regex de resultado en un solo archivo declarativo. Sin código que compilar, sin plugin que instalar. Diseñado para automatización completa: encaja en CI, daemons, ejecuciones programadas, subagentes ACP. Ejemplos completos de scripts de hook y validador: Salvaguardas.

El mundo se está volviendo autónomo. La elección no es "preguntar vs auto" — es "auto con política determinista" vs "auto con esperanza." Octomind incluye lo primero.

Costo como Plano de Control

Elige el modelo correcto para cada paso. Uno barato para investigación rutinaria, uno de frontera para revisión — por rol, por paso, cambio a mitad de sesión. Rastreo de costos en tiempo real y umbrales de gasto incluidos.

# Example spending thresholds — both default to 0.0 (disabled)
max_request_spending_threshold = 0.50    # USD per user request, including its tool loop
max_session_spending_threshold = 5.00    # USD per session

# Per-role model selection — pay Opus only where it's worth it
[[roles]]
name = "researcher"
system = "Research the supplied material and explain your findings with evidence."
welcome = "Send the material you want researched."
[roles.model]
name = "openrouter:google/gemini-2.5-flash"   # cheap broad context

[[roles]]
name = "reviewer"
system = "Review the supplied changes for correctness and explain concrete defects."
welcome = "Send the changes you want reviewed."
[roles.model]
name = "anthropic:claude-opus-4-7"            # precision where it counts

Selección de modelo por rol y por paso de flujo de trabajo entre muchos proveedores — OpenRouter, OpenAI, Anthropic, Google, DeepSeek, Amazon Bedrock, Cloudflare y más — a través de octolib. Diferentes roles pueden ejecutarse en diferentes proveedores; los proveedores disponibles dependen de la versión de octolib vinculada a tu binario. Consulta Proveedores y Modelos para la lista actual y los modelos compatibles.
Cambio de modelo a mitad de sesión con /model anthropic:claude-haiku-4-5. Mezcla proveedores entre roles — modelo barato para investigación, mejor modelo para ejecución. Los totales de sesión incluyen uso entre cambios de modelo.
Rastreo de costos en tiempo real por solicitud y por sesión.
Contabilidad de tokens consciente de caché (cache_read_tokens, cache_write_tokens separados de entrada/salida).
Los umbrales usan costos ya registrados, así que una llamada a proveedor puede superar el monto configurado. Un umbral de sesión solicita en una terminal interactiva y detiene el trabajo por tubería o ACP/WebSocket; aceptar restablece el punto de control de gasto. Un umbral de solicitud detiene la solicitud actual. Consulta Configuración.

Ambos umbrales están desactivados por defecto. Configúralos explícitamente; son verificaciones de continuación, no límites de facturación prepagados.

Sesiones que Siguen Ágiles a la Hora 4

Las tareas largas llenan la ventana de contexto con salida de herramientas, intentos intermedios y decisiones que aún necesitas.

El motor de compactación adaptativa de Octomind se ejecuta automáticamente:

Consciente de caché — calcula si la compactación vale la pena antes de pagar por ella. Considera la invalidación de caché y los costos de reescritura.
Consciente de crecimiento — ajusta el objetivo de compresión usando el crecimiento medido y el techo de contexto.
Preservación estructural — retiene conocimiento crítico, hallazgos de análisis seleccionados y el intercambio en vivo.
Consciente de plan adaptativo — el supervisor rastrea trabajo complejo externamente mientras las tareas enfocadas permanecen sin plan.
Totalmente automático — nunca tienes que pensar en ello.

El beneficio: contexto más pequeño reduce tokens de entrada posteriores. La compresión en sí consume tokens y puede invalidar la caché.

Las sesiones también persisten: octomind run --name my-feature guarda mientras avanzas, octomind run --resume my-feature (o --resume-recent) retoma donde lo dejaste — incluidas tareas de varios días. Detalles: Compresión, Sesiones.

Usa /done en un límite de tarea para forzar la compresión y comenzar el aprendizaje en segundo plano.

Contexto Impulsado por Intención

Tu rol determina las herramientas cargadas al inicio. Habilidades y capacidades adicionales pueden activarse a medida que la tarea se desarrolla. Las habilidades inyectan instrucciones y cargan sus capacidades requeridas; permanecen activas hasta que se olvidan o se limpian en un límite de tarea. El contexto sigue tanto tu rol inicial como el trabajo que solicitas.

Cómo funciona la activación

Reglas semánticas. Un modelo de incrustación interno puntúa tu solicitud contra frases semantic(...) de habilidades y frases de activación para capacidades. Las descripciones de habilidades por sí solas no activan la activación automática.
Reglas escritas a mano donde la precisión importa. Los autores de habilidades pueden fijar la activación a nombres de archivo, contenidos de archivo o frases exactas cuando saben más que una puntuación de similitud.
Abstenerse en empates semánticos cercanos. El candidato semántico principal necesita una ventaja suficiente. Las coincidencias de reglas deterministas aún se activan de forma independiente; varias pueden coincidir con un mensaje.
Calibrado para omitir, no adivinar. Activaciones incorrectas inflan el contexto y desperdician tokens. El sistema se predetermina al silencio cuando hay dudas.

Por qué esto importa

1. Start a session → load the role's configured tools
2. Send a task → evaluate inactive skills' rules and capability triggers
3. A skill matches → load its required capabilities and inject its instructions
4. Work continues → active skills survive automatic compression
5. Forget a skill → release its capability references and request compression

Mantener instrucciones no utilizadas fuera del contexto deja más espacio para la tarea.

Se combina con el resto:

mcp a mitad de sesión. Habilitar un servidor lo conecta y expone sus herramientas. La activación de habilidades también habilita los servidores de capacidades requeridos cuando hay credenciales disponibles; no espera la primera llamada a una herramienta.
Interacción con la compresión. Una habilidad desactivada se elimina durante la compactación: su contenido es recuperable en la próxima activación, no se fija para siempre.
Guardarraíles. Un guardarraíl puede requerir has = ["filesystem-read"] y solo activarse cuando esa capacidad está cargada actualmente. La política y la activación comparten el mismo espacio de nombres de capacidades.

Detalles: Habilidades, Eficiencia de Tokens.

Comienza con un rol enfocado, luego agrega habilidades y capacidades según las necesite la tarea.

Especialistas y Taps

octomind run <tag> resuelve un especialista — un agente empaquetado con su configuración de modelo, prompt de sistema, servidores MCP y permisos de herramientas. No es un archivo de prompt, no es una inyección de habilidad — la pila completa, configurada por la comunidad, lista para ejecutarse.

octomind run developer:general    # general dev, language skills auto-activate
octomind run doctor:blood         # blood-test interpretation specialist
octomind run doctor:nutrition     # nutrition specialist

Qué sucede cuando ejecutas un especialista:

→ Fetches the agent manifest from the tap registry
→ Installs required binaries automatically (skips if already present)
→ Resolves required credentials; interactive setup can prompt and persist them
→ Spins up the right MCP servers for this domain
→ Loads specialist model config, system prompt, tool permissions
→ Starts the session once setup completes

Los especialistas crecen en tiempo de ejecución

Los roles que tienen los servidores runtime y orchestration pueden adquirir capacidades y delegar trabajo a mitad de sesión:

Herramienta	Qué hace
`tap`	Delegar trabajo en segundo plano a cualquier rol de especialista del registro de taps.
`mcp`	Habilitar o deshabilitar servidores MCP sobre la marcha. El agente elige el servidor que necesita y lo registra a mitad de conversación.
`agent`	Registrar y habilitar agentes dinámicos; llama a la herramienta `agent_<name>` resultante para ejecutar uno.

Por ejemplo, estas son llamadas a herramientas del modelo (no comandos de shell):

agent({"action":"add","name":"log_reader","description":"Summarize supplied logs","system":"Summarize the log text supplied in the task."})
agent({"action":"enable","name":"log_reader"})
agent_log_reader({"task":"Summarize this deployment log: 09:00 deploy started; 09:02 health check passed."})
agent({"action":"disable","name":"log_reader"})

Octomind comienza con el conjunto de herramientas configurado del rol y puede agregar capacidades mientras trabaja. Contexto más pequeño, menor costo, respuestas más rápidas, sin herramientas sorpresa. Consulta Contexto Impulsado por Intención para ver cómo funciona realmente la activación.

Agrega tus propios taps

# Scaffold and register a local tap with a known starter tag
octomind tap init yourteam/tap --agent finance:analyst
octomind run finance:analyst

# On another machine, after publishing github.com/yourteam/octomind-tap:
# octomind tap yourteam/tap

# Or register an existing local tap directory
octomind tap yourteam/internal ./octomind-tap

Cada tap es un repositorio Git. Cada agente es un archivo TOML. Consulta Sistema de Taps para campos de manifiesto, configuración de dependencias y publicación. Las solicitudes de extracción son contribuciones.

¿Quieres publicar tu experiencia? Un doctor:medications, un lawyer:us, un devops:terraform. Un archivo, y todos con ese problema obtienen un especialista al instante. Cómo escribir un agente tap →

Herramientas MCP Integradas

Octomind es un cliente MCP para servidores stdio y Streamable HTTP, con soporte OAuth. También enruta herramientas integradas internamente. Consulta Herramientas MCP para la configuración del servidor y los esquemas de herramientas.

El tiempo de ejecución puede exponer estas según el rol activo y la configuración. La planificación no es una herramienta invocable por el modelo: el supervisor la posee externamente, mientras que /plan sigue siendo un comando de visualización de solo lectura.

Herramienta	Propósito
`mcp`	Habilitar/deshabilitar servidores MCP en tiempo de ejecución
`agent` / `agent_<name>`	Gestionar agentes dinámicos / ejecutar un agente habilitado
`schedule`	Inyectar mensajes en momentos futuros
`monitor`	Reaccionar a scripts de flujo de eventos sin sondeo activo
`skill`	Inyectar paquetes de instrucciones reutilizables desde taps
`tap`	Delegar a cualquier rol de especialista desde un registro de taps
`capability`	Descubrir, habilitar y deshabilitar paquetes de herramientas de dominio
`recall`	Recuperar bloques de contexto archivados cuando la atención o la gobernanza están habilitadas

Herramientas de sistema de archivos (vía octofs)

view, text_editor, batch_edit, extract_lines, shell, workdir — las operaciones de archivos provienen del servidor MCP octofs complementario. view también lista directorios y busca contenido. La exposición de herramientas depende de las capacidades del tap; consulta Herramientas MCP.

Cerebro (vía octobrain)

memorize, remember, forget, knowledge — memoria persistente e indexación de conocimiento. memorize también puede vincular memorias a través de related_to. Los taps suministran octobrain a través de capacidades de memoria y conocimiento. Consulta Herramientas MCP; el aprendizaje del supervisor usa su propio almacén de archivos.

core, orchestration, runtime y agent son los cuatro servidores MCP integrados incluidos en la configuración predeterminada. Los servidores filesystem (octofs) y brain (octobrain) son suministrados por fórmulas de tap — una configuración recién generada no los listará.

Herramientas de proyecto local

Coloca scripts ejecutables con un encabezado # @description en <workdir>/.agents/tools/; se descubren automáticamente como herramientas MCP para ese proyecto. Incluye un shebang para ejecución directa. Consulta Herramientas Locales.

Usuarios Avanzados — Roles, Flujos de Trabajo, Capas

Para la mayoría de los usuarios, los taps son suficientes. Para equipos y usuarios avanzados, el sistema de configuración es profundo — todo TOML, sin código.

Este rol personalizado usa octofs. Instálalo a través de una capacidad de sistema de archivos o sigue la configuración de Herramientas MCP, luego agrega el rol y el servidor a tu configuración:

# Sandbox — OS write restrictions with state/system exceptions; see the config reference
sandbox = true

# Per-role: independent model, temperature, MCP servers, tools, system prompt
[[roles]]
name = "senior-reviewer"
system = "Read the project files and report concrete correctness defects with file references."
welcome = "Describe the change you want reviewed."
[roles.model]
name = "anthropic:claude-opus-4-7"
temperature = 0.2
[roles.mcp]
server_refs = ["filesystem"]
allowed_tools = ["view"]

# Requires octofs on PATH. Edit an existing filesystem entry if you already have one.
[[mcp.servers]]
name = "filesystem"
type = "stdio"
command = "octofs"
args = ["mcp"]
timeout_seconds = 30
tools = []

octomind run senior-reviewer

# Workflows — multi-step, each step its own model and toolset
# After creating deep_review.toml using the Workflows guide:
echo "Review the auth module" | octomind workflow deep_review.toml

Roles — anulaciones de modelo, prompt de sistema, servidores MCP, permisos de herramientas por rol.
Capas — etapas de subprocesos ACP, también usadas por comandos /run; no se ejecutan automáticamente después de cada respuesta.
Guardarraíles — política determinista (guardarraíles, hooks, validadores) y tuberías de entrada.
Flujos de Trabajo — ejecutores de tareas con pasos secuenciales, paralelos, condicionales y de bucle.
Supervisor — planificación fuera de banda, detección de bucle/sin progreso, verificación de finalización, condensación de salida de herramientas y aprendizaje entre sesiones. Consulta Supervisor.

Consulta Referencia de Configuración para todo.

Instalación

Instalación de una línea

curl -fsSL https://raw.githubusercontent.com/muvon/octomind/master/install.sh | bash

Detecta el sistema operativo y la arquitectura e instala en ~/.local/bin/ por defecto. macOS y Linux son compatibles. El agente es un binario Rust; las herramientas MCP externas tienen sus propias dependencias. Consulta Instalación.

Cargo

cargo install octomind

Requiere Rust 1.95+. Consulta Compilación desde el Código Fuente.

Compilar desde el código fuente

git clone https://github.com/muvon/octomind.git
cd octomind
cargo build --release

Acceso al modelo

Opción A — Octomind Cloud. Inicia sesión para obtener acceso al modelo de puerta de enlace:

octomind login

Inicio de sesión con código de dispositivo (como gh auth login). Esto almacena una clave de puerta de enlace octohub emitida por el servidor localmente — la configuración predeterminada ya establece name = "octohub:auto" bajo [model], así que estás listo. Más información: octomind.run/cloud.

Opción B — trae tus propias claves. Octomind es completamente de código abierto y funciona de forma independiente con proveedores compatibles:

# OpenRouter — access to many providers with one key
export OPENROUTER_API_KEY="your_key"

# Or any specific provider
export OPENAI_API_KEY="your_key"
export ANTHROPIC_API_KEY="your_key"
export DEEPSEEK_API_KEY="your_key"

Agrega tu clave elegida a ~/.bashrc o ~/.zshrc para persistencia. Para ejecutar sin Octomind Cloud, edita las tablas de modelo existentes en config.toml; los perfiles de supervisor y compresión también se predeterminan a octohub:auto:

[model]
name = "openrouter:google/gemini-2.5-flash"

[supervisor.model]
name = "openrouter:google/gemini-2.5-flash"

[compression.model]
name = "openrouter:google/gemini-2.5-flash"

Usa la clave para el proveedor que selecciones. Consulta Proveedores y Modelos para anulaciones de rol y tap.

Verificar

octomind --version
octomind config       # generate default config
octomind run          # start your first session

Preguntas comunes

¿Comando no encontrado después de instalar? Agrega el directorio de instalación predeterminado al PATH de tu shell:

export PATH="$HOME/.local/bin:$PATH"
octomind --version

¿Falta la clave de puerta de enlace con tu propia clave de proveedor configurada? Actualiza las tres tablas de modelo mostradas arriba y verifica las anulaciones de rol. Más soluciones: Problemas Comunes.

Configuración

En macOS/Linux, la configuración vive en ~/.local/share/octomind/config/config.toml; en Windows, vive bajo %LOCALAPPDATA%/octomind/config/. OCTOMIND_DATA_DIR anula la raíz de datos. Consulta Variables de Entorno.

octomind config --show          # view current config
octomind config --validate      # validate config

Áreas clave:

Roles — modelo, temperatura, prompt de sistema, servidores MCP, permisos de herramientas
Flujos de Trabajo — procesamiento de IA de múltiples pasos con bucles de validación
Guardarraíles — política determinista (guardarraíles, hooks, validadores) y tuberías de entrada
Servidores MCP — herramientas y capacidades externas
Límites de Gasto — umbrales por solicitud y por sesión
Telemetría — estadísticas de uso anónimas, activadas por defecto

Referencia completa: Referencia de Configuración.

Telemetría

Octomind informa uso anónimo — qué comandos, herramientas y modelos se usan, además de tiempos, recuentos de tokens y tipos de errores. Nunca tu código, prompts, rutas de archivos, argumentos de herramientas o valores de entorno. Desactívalo de cualquiera de tres maneras:

export DO_NOT_TRACK=1           # the cross-tool standard, honoured first
export OCTOMIND_TELEMETRY=0     # for subsequent commands in this shell
# or set `telemetry = false` in config.toml

Lista exacta de campos: Telemetría.

Comandos de sesión

Comando	Descripción
`/help`	Mostrar todos los comandos
`/info`	Uso de tokens y costos
`/status [agents\|monitors\|jobs]`	Agentes actuales y actividad en segundo plano
`/model anthropic:claude-haiku-4-5`	Cambiar modelo a mitad de sesión
`/effort high`	Establecer esfuerzo de razonamiento (ninguno/bajo/medio/alto/xalto/máximo)
`/role developer:general`	Cambiar a un rol configurado o etiqueta de tap
`/new Review auth`	Iniciar una sesión nueva; el título es opcional
`/done`	Forzar compresión de contexto y comenzar extracción de aprendizaje en segundo plano cuando esté habilitada
`/exit`	Salir de la sesión

Lista completa: Comandos de Sesión.

Arquitectura

Un binario. La sesión es la unidad de trabajo. Alrededor de ella: roles (quién habla), capas y flujos de trabajo (orquestación de múltiples pasos), guardarraíles con tuberías (preprocesamiento y política deterministas), compactación adaptativa (calidad de sesiones largas) y servidores MCP (herramientas). Configurado a través de una configuración TOML resuelta; los algoritmos internos también usan reglas de tiempo de ejecución fijas.

Los integradores eligen su superficie: CLI interactiva, ACP para orquestación multiagente, WebSocket para IDEs y paneles, modo daemon para agentes en segundo plano de larga duración. Consulta Integración con Editores.

Consulta Arquitectura para detalles internos.

Contribuciones

La contribución más impactante no es código — son agentes especialistas.

Cada experto de dominio que publica un especialista hace que Octomind sea útil para una audiencia completamente nueva. Un cardiólogo publicando doctor:medications. Un abogado fiscal publicando lawyer:us. Un investigador de seguridad publicando security:owasp. Un archivo TOML — y todos con ese problema obtienen una IA de nivel especialista al instante.

Documentación

Los enlaces anteriores apuntan a la documentación en este repositorio. El sitio de documentación alojado también está disponible. Índice completo: doc/README.md.

Licencia

Licencia Apache 2.0 — ver LICENSE.

Octomind por Muvon | Sitio web | Documentación