Octomind

---

Octomind é um cliente de agente de IA de código aberto: o modelo chama ferramentas MCP para fazer trabalho real — ler e escrever arquivos, executar shells, pesquisar código, delegar para subagentes. O mesmo runtime suporta vários pontos de entrada: a mesma sessão roda interativamente, via pipe pelo stdin, como um daemon em segundo plano, via WebSocket, ou como um subagente ACP dentro da pilha de outro agente. Modelos, ferramentas, papéis, guardrails, orçamentos — tudo isso é TOML, sem 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"

Sumário

• Início Rápido
• Benchmarks — PRs Reais, Testes Reservados
• Por que Octomind?
• Um Binário, Cinco Superfícies
• Guardrails — Política como Código
• Custo como Plano de Controle
• Sessões que Permanecem Afiadas na Hora 4
• Contexto Orientado por Intenção
• Especialistas e Taps
• Ferramentas MCP Integradas
• Usuários Avançados — Papéis, Fluxos de Trabalho, Camadas
• Instalação
• Configuração
• Arquitetura
• Contribuindo
• Documentação
• Licença

---

Início 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
> _

Você está em uma sessão com um agente que pode ler seu código, executar comandos, editar arquivos e expandir capacidades conforme necessário. Interface de linha simples com renderização de markdown e completação de shell — sem TUI para aprender, funciona via SSH, em tmux, em logs de CI.

octomind login conecta você ao Octomind Cloud — uma assinatura que inclui acesso a modelos através do gateway octohub, então não há nada para configurar. Prefere suas próprias chaves? Pule o login completamente e traga qualquer provedor: OpenRouter, Anthropic, OpenAI, DeepSeek, Ollama e mais. Cloud é a base; BYOK é sempre um caminho de primeira classe.

developer:general (e lawyer:sg, doctor:blood, …) vêm do tap padrão integrado muvon/tap, não da sua configuração local. A tag padrão da configuração é assistant:concierge, então octomind run simples inicia isso. O banner acima é ilustrativo (o real renderiza um ícone de pixel à esquerda do bloco de texto).

Outras instalações: cargo install octomind (Rust 1.95+) ou compilar a partir do código-fonte.

---

Benchmarks — PRs Reais, Testes Reservados

Fazemos benchmark no octobench: 25 tarefas coletadas de pull requests mesclados em python, php, rust, c++ e js. Cada agente trabalha no repositório pré-correção; testes reservados da correção mesclada decidem aprovação ou reprovação. Estes são os resultados publicados em 30 de julho de 2026, não uma medição do checkout atual:

	resolvidos	juiz Σ / 2500	custo	tempo de parede
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

• O harness importa. opencode usou o mesmo modelo e endpoint. octomind resolveu 24 vs 19 com aproximadamente metade do custo. Octomind usou um tap em etapas e uma substituição binária com o pré-gate de handback inacabado; isso mede a configuração completa, não recursos individuais.
• Preço no pior caso, ainda à frente. glm-5.2 rodou sem cache de prompt (cada token a preço de tabela) enquanto Opus cobrou ~97% das releituras de contexto a taxas de cache de 1/10 — e octomind ainda liderou em resoluções, custo e tempo de parede.
• Reprodutível. Tabela completa por caso, artefatos de execução e guia de reprodução: BENCHMARK.md @ 8aa3968. A história por trás do benchmark: postagem no blog.

---

Por que Octomind?

O runtime oferece controles para o trabalho que continua depois que você sai do teclado:

• Autonomia precisa de política. Imponha regras pré-chamada e alimente falhas de script de volta ao agente com Guardrails.
• Compartilhe uma configuração de trabalho. Um tap empacota instruções do agente, dependências e acesso a ferramentas. Inicie um especialista com octomind run developer:general.
• Escolha um especialista. Use diferentes papéis para depuração, pesquisa ou revisão, com suas próprias instruções, substituições de modelo e ferramentas.
• Mantenha tarefas longas em movimento. Compressão reduz o contexto acumulado enquanto retém conhecimento da tarefa e a troca ao vivo.
• Acompanhe gastos. Configure limites de requisição e sessão e inspecione custos com /info. Veja Custo.
• Carregue contexto sob demanda. Skills e capacidades podem ativar a partir da sua entrada.

Pilar	O que ele oferece
Zero configuração, flexibilidade total	octomind run lawyer:sg funciona imediatamente. Precisa de um modelo, servidor MCP ou pipe de guardrail diferente? Mesmo TOML, sem código de framework.
Sessões permanecem afiadas na hora 4	Compactação adaptativa: ciente de cache, preservando estrutura. Contexto menor = respostas mais rápidas + custo menor.
Custo como plano de controle	Seleção de modelo por etapa em muitos provedores. Limites de gastos e contabilidade ciente de cache vêm de graça.
Guardrails: política como código	Governa agentes autônomos com scripts determinísticos — guardas pré-chamada, hooks pós-resultado, validadores pós-turno. Sem cliques modais de aprovação. Adequado para CI.
Contexto orientado por intenção	Skills e capacidades podem ativar por regras, correspondência semântica ou solicitações explícitas. Contexto menor por padrão, custo menor, sem ferramentas surpresa.

---

Um Binário, Cinco Superfícies

O mesmo mecanismo de sessão, exposto conforme seu fluxo de trabalho precisar:

Modo	Uso para
CLI interativo	Trabalho diário, qualquer domínio
Pipe octomind run --format plain	Pipelines de CI/CD, scripts de shell, automação
Daemon + send	Agentes em segundo plano, monitoramento contínuo, tarefas de longa duração
Servidor WebSocket (octomind server)	Plugins de IDE, dashboards web, integrações externas
Protocolo ACP (octomind acp)	Orquestração multiagente, ser chamado por outros 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 não tem argumento de mensagem: seu argumento posicional é um papel ou tag de tap. O stdin via pipe roda de forma não interativa, padronizando para plain; --format plain ou --format jsonl seleciona o formato de saída. Em um terminal, --format sem entrada via pipe gera erro, a menos que você também use --daemon. Sem --format, um terminal inicia uma sessão interativa. server e acp não aceitam --format.

--daemon mantém o processo vivo; ele não o desanexa do seu terminal. Use outro terminal para octomind send. Para requisitos de schema e suporte a modelos, veja Saída Estruturada.

Veja Servidor WebSocket, Protocolo ACP e Daemon & Hooks para os modos de integração.

Um binário. Cada fluxo de trabalho.

---

Guardrails — Política como Código

Uma tarefa de longa duração, trabalho de CI ou loop autônomo precisa de regras repetíveis para execução de ferramentas e validação.

A política vive em regras e scripts TOML. Coloque um .agents/guardrails.toml no seu repositório e o runtime o impõe deterministicamente — pré-chamada, pós-resultado, pós-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."

• Guards — regras de negação pré-chamada. Corresponda por capability(arg_name=regex), gate por histórico (+used / -unused), exija capacidades carregadas (has = [...]). Uma chamada correspondente retorna uma negação em vez de executar.
• Hooks — scripts pós-resultado. Executam após resultados de ferramentas correspondentes. Saída não zero injeta stdout na caixa de entrada do agente como uma mensagem de usuário — erros de clippy, falhas de lint, diffs de formatação tornam-se correções automáticas sem reiniciar o turno.
• Validators — scripts pós-turno. Seus filtros de histórico when inspecionam chamadas desde a execução anterior; sem when, eles podem rodar a cada turno. Filtre por papel e texto de resposta. A saída é envolvida em blocos <validation> que o agente lê no próximo turno. É isso que substitui prompts de "aprovar esta alteração?" em loops autônomos.

O DSL combina capacidade+regex de argumento+histórico+papel+regex de resultado em um único arquivo declarativo. Sem código para compilar, sem plugin para instalar. Projetado para automação total: adequado para CI, daemons, execuções agendadas, subagentes ACP. Exemplos completos de scripts de hook e validator: Guardrails.

O mundo está se tornando autônomo. A escolha não é "perguntar vs automático" — é "automático com política determinística" vs "automático com esperança." Octomind entrega o primeiro.

---

Custo como Plano de Controle

Escolha o modelo certo para cada etapa. Um barato para pesquisa rotineira, um de fronteira para revisão — por papel, por etapa, troca no meio da sessão. Rastreamento de custo em tempo real e limites de gastos vêm de graça.

# 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

• Seleção de modelo por papel e por etapa de fluxo de trabalho em muitos provedores — OpenRouter, OpenAI, Anthropic, Google, DeepSeek, Amazon Bedrock, Cloudflare e mais — via octolib. Papéis diferentes podem rodar em fornecedores diferentes; provedores disponíveis dependem da versão do octolib vinculada ao seu binário. Veja Provedores & Modelos para a lista atual e modelos suportados.
• Troca de modelo no meio da sessão com /model anthropic:claude-haiku-4-5. Misture provedores entre papéis — modelo barato para pesquisa, melhor modelo para execução. Totais de sessão incluem uso entre trocas de modelo.
• Rastreamento de custo em tempo real por requisição e por sessão.
• Contabilidade de tokens ciente de cache (cache_read_tokens, cache_write_tokens separados de entrada/saída).
• Limites usam custos já registrados, então uma chamada de provedor pode ultrapassar o valor configurado. Um limite de sessão solicita em um terminal interativo e interrompe trabalho via pipe ou ACP/WebSocket; aceitar redefine o ponto de verificação de gastos. Um limite de requisição interrompe a requisição atual. Veja Configuração.

Ambos os limites estão desativados por padrão. Defina-os explicitamente; são verificações de continuação, não limites de faturamento pré-pago.

---

Sessões que Permanecem Afiadas na Hora 4

Tarefas longas enchem a janela de contexto com saída de ferramentas, tentativas intermediárias e decisões que você ainda precisa.

O mecanismo de compactação adaptativa do Octomind roda automaticamente:

• Ciente de cache — calcula se a compactação vale a pena antes de pagar por ela. Considera invalidação de cache e custos de reescrita.
• Ciente de crescimento — ajusta o alvo de compressão usando crescimento medido e o teto de contexto.
• Preservando estrutura — retém conhecimento crítico, descobertas de análise selecionadas e a troca ao vivo.
• Ciente de plano adaptativo — o supervisor rastreia trabalho complexo externamente enquanto tarefas focadas permanecem sem plano.
• Totalmente automático — você nunca pensa nisso.

O benefício: contexto menor reduz tokens de entrada posteriores. A própria compressão consome tokens e pode invalidar o cache.

Sessões também persistem: octomind run --name my-feature salva conforme você avança, octomind run --resume my-feature (ou --resume-recent) retoma de onde você parou — incluindo tarefas de vários dias. Detalhes: Compressão, Sessões.

Use /done em um limite de tarefa para forçar a compactação e iniciar o aprendizado em segundo plano.

---

Contexto Orientado por Intenção

Seu papel determina as ferramentas carregadas na inicialização. Habilidades e capacidades adicionais podem ser ativadas conforme a tarefa se desenvolve. As habilidades injetam instruções e carregam suas capacidades necessárias; elas permanecem ativas até serem esquecidas ou limpas em um limite de tarefa. O contexto segue tanto o seu papel inicial quanto o trabalho que você solicita.

Como a ativação funciona

• Regras semânticas. Um modelo de incorporação interno pontua sua solicitação em relação às frases semantic(...) criadas para habilidades e frases de gatilho para capacidades. Descrições de habilidades sozinhas não acionam a ativação automática.
• Regras escritas à mão onde a precisão importa. Os autores de habilidades podem fixar a ativação a nomes de arquivos, conteúdos de arquivos ou frases exatas quando souberem melhor do que uma pontuação de similaridade.
• Abster-se em empates semânticos próximos. O principal candidato semântico precisa de uma liderança suficiente. Correspondências de regras determinísticas ainda ativam de forma independente; várias podem corresponder a uma mensagem.
• Calibrado para pular, não adivinhar. Ativações erradas incham o contexto e desperdiçam tokens. O sistema padroniza para o silêncio em caso de dúvida.

Por que isso 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

Manter instruções não utilizadas fora do contexto deixa mais espaço para a tarefa.

Isso se combina com o resto:

• mcp no meio da sessão. Habilitar um servidor o conecta e expõe suas ferramentas. A ativação de habilidades também habilita servidores de capacidade necessários quando as credenciais estão disponíveis; ela não espera pela primeira chamada de ferramenta.
• Interação de compactação. Uma habilidade desativada é descartada durante a compactação — seu conteúdo é recuperável na próxima ativação, não fixado para sempre.
• Salvaguardas. Uma salvaguarda pode exigir has = ["filesystem-read"] e só disparar quando essa capacidade estiver carregada no momento. Política e ativação compartilham o mesmo namespace de capacidades.

Detalhes: Habilidades, Eficiência de Tokens.

Comece com um papel focado e adicione habilidades e capacidades conforme a tarefa precisar.

---

Especialistas e Taps

octomind run <tag> resolve um especialista — um agente empacotado com sua configuração de modelo, prompt de sistema, servidores MCP e permissões de ferramentas. Não é um arquivo de prompt, não é uma injeção de habilidade — a pilha completa, configurada pela comunidade, pronta para executar.

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

O que acontece quando você executa um 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

Especialistas crescem em tempo de execução

Papéis que recebem os servidores runtime e orchestration podem adquirir capacidades e delegar trabalho no meio da sessão:

Ferramenta	O que faz
tap	Delegar trabalho em segundo plano para qualquer papel de especialista do registro de taps.
mcp	Habilitar ou desabilitar servidores MCP em tempo real. O agente escolhe o servidor que precisa e o registra no meio da conversa.
agent	Registrar e habilitar agentes dinâmicos; chamar a ferramenta agent_<name> resultante para executar um.

Por exemplo, estas são chamadas de ferramentas do modelo (não 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 começa com o conjunto de ferramentas configurado do papel e pode adicionar capacidades enquanto trabalha. Contexto menor, custo mais baixo, respostas mais rápidas, sem ferramentas surpresa. Veja Contexto Orientado por Intenção para saber como a ativação realmente funciona.

Adicione seus próprios 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 é um repositório Git. Cada agente é um arquivo TOML. Veja Sistema de Taps para campos de manifesto, configuração de dependências e publicação. Pull requests são contribuições.

Quer publicar sua expertise? Um doctor:medications, um lawyer:us, um devops:terraform. Um arquivo, e todos com esse problema ganham um especialista instantaneamente. Como escrever um agente de tap →

---

Ferramentas MCP Integradas

Octomind é um cliente MCP para servidores stdio e Streamable HTTP, com suporte a OAuth. Ele também roteia ferramentas integradas internamente. Veja Ferramentas MCP para configuração de servidores e esquemas de ferramentas.

O runtime pode expor estas de acordo com o papel ativo e a configuração. O planejamento não é uma ferramenta chamável pelo modelo: o supervisor o possui externamente, enquanto /plan permanece um comando de exibição somente leitura.

Ferramenta	Propósito
mcp	Habilitar/desabilitar servidores MCP em tempo de execução
agent / agent_<name>	Gerenciar agentes dinâmicos / executar um agente habilitado
schedule	Injetar mensagens em horários futuros
monitor	Reagir a scripts de fluxo de eventos sem polling ativo
skill	Injetar pacotes de instruções reutilizáveis de taps
tap	Delegar a qualquer papel de especialista de um registro de taps
capability	Descobrir, habilitar e desabilitar pacotes de ferramentas de domínio
recall	Recuperar blocos de contexto arquivados quando atenção ou governança está habilitada

Ferramentas de sistema de arquivos (via octofs)

view, text_editor, batch_edit, extract_lines, shell, workdir — as operações de arquivo vêm do servidor MCP companheiro octofs. view também lista diretórios e pesquisa conteúdo. A exposição de ferramentas depende das capacidades do tap; veja Ferramentas MCP.

Cérebro (via octobrain)

memorize, remember, forget, knowledge — memória persistente e indexação de conhecimento. memorize também pode vincular memórias através de related_to. Taps fornecem octobrain através de capacidades de memória e conhecimento. Veja Ferramentas MCP; o aprendizado do supervisor usa seu próprio armazenamento de arquivos.

core, orchestration, runtime e agent são os quatro servidores MCP integrados enviados na configuração padrão. Os servidores filesystem (octofs) e brain (octobrain) são fornecidos por fórmulas de tap — uma configuração recém-gerada não os listará.

Ferramentas locais de projeto

Coloque scripts executáveis com um cabeçalho # @description em <workdir>/.agents/tools/; eles são descobertos automaticamente como ferramentas MCP para aquele projeto. Inclua um shebang para execução direta. Veja Ferramentas Locais.

---

Usuários Avançados — Papéis, Fluxos de Trabalho, Camadas

Para a maioria dos usuários, taps são suficientes. Para equipes e usuários avançados, o sistema de configuração é profundo — tudo TOML, sem código.

Este papel personalizado usa octofs. Instale-o através de uma capacidade de sistema de arquivos ou siga a configuração de Ferramentas MCP, depois adicione o papel e o servidor à sua configuração:

# 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

• Papéis — substituições de modelo, prompt de sistema, servidores MCP, permissões de ferramentas por papel.
• Camadas — estágios de subprocesso ACP, também usados por comandos /run; eles não são executados automaticamente após cada resposta.
• Salvaguardas — política determinística (salvaguardas, ganchos, validadores) e pipes de entrada.
• Fluxos de Trabalho — executores de tarefas com etapas sequenciais, paralelas, condicionais e de loop.
• Supervisor — planejamento fora de banda, detecção de loop/sem progresso, verificação de conclusão, condensação de saída de ferramentas e aprendizado entre sessões. Veja Supervisor.

Veja Referência de Configuração para tudo.

---

Instalação

Instalação em uma linha

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

Detecta o sistema operacional e a arquitetura e instala em ~/.local/bin/ por padrão. macOS e Linux são suportados. O agente é um único binário Rust; ferramentas MCP externas têm suas próprias dependências. Veja Instalação.

Cargo

cargo install octomind

Requer Rust 1.95+. Veja Compilando a partir do Código Fonte.

Compilar a partir do código fonte

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

Acesso ao modelo

Opção A — Octomind Cloud. Entre para obter acesso ao modelo de gateway:

octomind login

Entrada com código de dispositivo (como gh auth login). Isso armazena uma chave de gateway octohub emitida pelo servidor localmente — a configuração padrão já define name = "octohub:auto" sob [model], então você está pronto. Saiba mais: octomind.run/cloud.

Opção B — traga suas próprias chaves. Octomind é totalmente open source e funciona de forma autônoma com provedores suportados:

# 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"

Adicione sua chave escolhida a ~/.bashrc ou ~/.zshrc para persistência. Para executar sem Octomind Cloud, edite as tabelas de modelo existentes em config.toml; os perfis de supervisor e compactação também usam octohub:auto por padrão:

[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"

Use a chave para o provedor que você selecionar. Veja Provedores e Modelos para substituições de papel e tap.

Verificar

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

Perguntas comuns

Comando não encontrado após a instalação? Adicione o diretório de instalação padrão ao PATH do seu shell:

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

Chave de gateway ausente com sua própria chave de provedor definida? Atualize todas as três tabelas de modelo mostradas acima e verifique as substituições de papel. Mais correções: Problemas Comuns.

---

Configuração

No macOS/Linux, a configuração fica em ~/.local/share/octomind/config/config.toml; no Windows, fica em %LOCALAPPDATA%/octomind/config/. OCTOMIND_DATA_DIR substitui a raiz de dados. Veja Variáveis de Ambiente.

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

Áreas principais:

• Papéis — modelo, temperatura, prompt de sistema, servidores MCP, permissões de ferramentas
• Fluxos de Trabalho — processamento de IA em várias etapas com loops de validação
• Salvaguardas — política determinística (salvaguardas, ganchos, validadores) e pipes de entrada
• Servidores MCP — ferramentas e capacidades externas
• Limites de Gastos — limites por solicitação e por sessão
• Telemetria — estatísticas de uso anônimas, ativadas por padrão

Referência completa: Referência de Configuração.

Telemetria

Octomind relata uso anônimo — quais comandos, ferramentas e modelos são usados, além de tempos, contagens de tokens e tipos de erro. Nunca seu código, prompts, caminhos de arquivos, argumentos de ferramentas ou valores de ambiente. Desative de qualquer uma das três maneiras:

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 exata de campos: Telemetria.

Comandos de sessão

Comando	Descrição
/help	Mostrar todos os comandos
/info	Uso de tokens e custos
/status [agents|monitors|jobs]	Agentes atuais e atividade em segundo plano
/model anthropic:claude-haiku-4-5	Trocar de modelo no meio da sessão
/effort high	Definir esforço de raciocínio (none/low/medium/high/xhigh/max)
/role developer:general	Alternar para um papel configurado ou tag de tap
/new Review auth	Iniciar uma nova sessão; o título é opcional
/done	Forçar compactação de contexto e iniciar extração de aprendizado em segundo plano quando habilitado
/exit	Sair da sessão

Lista completa: Comandos de Sessão.

---

Arquitetura

Um binário. A sessão é a unidade de trabalho. Ao redor dela: papéis (quem está falando), camadas e fluxos de trabalho (orquestração em várias etapas), salvaguardas com pipes (pré-processamento determinístico e política), compactação adaptativa (qualidade de sessão longa) e servidores MCP (ferramentas). Configurado através de uma configuração TOML resolvida; algoritmos internos também usam regras de runtime fixas.

Os incorporadores escolhem sua superfície: CLI interativa, ACP para orquestração multiagente, WebSocket para IDEs e painéis, modo daemon para agentes de longa duração em segundo plano. Veja Integração com Editores.

Veja Arquitetura para detalhes internos.

---

Contribuindo

A contribuição mais impactante não é código — são agentes especialistas.

Todo especialista de domínio que publica um especialista torna Octomind útil para um público totalmente novo. Um cardiologista publicando doctor:medications. Um advogado tributário publicando lawyer:us. Um pesquisador de segurança publicando security:owasp. Um arquivo TOML — e todos com esse problema ganham uma IA de nível especialista instantaneamente.

• Como escrever um agente de tap
• Problemas em aberto
• Compilando a partir do código fonte
• Guia de contribuição

---

Documentação

• Instalação e Configuração
• Início Rápido
• Configuração
• Provedores e Modelos
• Sessões
• Compressão
• Funções
• Ferramentas MCP
• Fluxos de Trabalho
• Comandos e Camadas
• Saída Estruturada
• Integração com Editores
• Eficiência de Tokens
• Ferramentas Locais
• Proteções
• Habilidades
• Supervisor
• Aprendizado
• Servidor WebSocket
• Protocolo ACP
• Daemon e Ganchos
• Sistema de Toque
• Referência da CLI
• Referência de Configuração

Os links acima apontam para a documentação neste checkout. O site de documentação hospedado também está disponível. Índice completo: doc/README.md.

---

Licença

Apache License 2.0 — veja LICENSE.

---

Octomind por Muvon | Site | Documentação