TuringCorp Decider

Um modelo de decisão para as chamadas que não têm uma resposta certa. A melhor opção, com um motivo.

Servidor MCP hospedado

npx add-mcp 'https://mcp.turingcorp.net/mcp'

Instala no Claude Code, Codex, Cursor e outros

Documentação

TuringCorp — servidor MCP

Um modelo de decisão para chamadas que não têm uma resposta certa. Seu agente tem duas opções defensáveis e precisa escolher uma. Envie ambas: um painel de modelos as julga em conjunto e retorna a melhor, o quão distante ele as julgou (uma confiança calibrada) e o porquê.

Endpoint (canônico): https://mcp.turingcorp.net/mcp
Aliases: https://mcp.turingcorp.net/ e https://mcp.turingcorp.net/mcp/
Saúde: https://mcp.turingcorp.net/healthz
Transporte: HTTP Streamable, sem estado (sem sessão, sem Durable Object). GET /mcp → 405 é normal.
Protocolo: MCP 2026-07-28 (moderno) e 2025-06-18 (legado) — uma única rota atende ambos.
Métodos de descoberta (server/discover, tools/list) não exigem credenciais — scanners de diretório podem ler a lista completa de ferramentas sem autenticação, por design.

Tomando uma decisão: `decide`


Entrada	`task` (string), `optionA` (string), `optionB` (string) — todos obrigatórios
Saída	`job_id` (string), `betterOption` (`"option_A"` \| `"option_B"`), `confidence` (string de porcentagem, ex.: `"76.7%"`), `reason` (string)
Anotações	`readOnlyHint: true` · `openWorldHint: false` · `idempotentHint: false`
Timeout	Reserve 180–300 segundos — uma decisão é uma chamada longa. O timeout é uma configuração do cliente/host, não um parâmetro da ferramenta: não há nada para passar na chamada. Um padrão de 60s interrompe antes que a resposta chegue; se isso acontecer, não chame novamente — recupere via `job_id`.
Chamadas longas	Um cliente que declara a extensão `io.modelcontextprotocol/tasks` recebe um identificador de tarefa em vez de manter uma conexão aberta por minutos, e consulta `tasks/get` — veja Recuperando um resultado. Clientes que não a declaram não veem nenhuma mudança.

Uma chamada bem-sucedida retorna a decisão inline. job_id, betterOption, confidence e reason chegam todos no mesmo resultado da ferramenta — não há nada para consultar ou buscar depois. O job_id é apenas para o caso em que a chamada nunca retornou (timeout, conexão perdida, cliente desistiu de esperar).

confidence é o julgamento do próprio serviço sobre o quão distantes as duas opções estavam — uma referência para sua tomada de decisão, não uma instrução, não um resultado, e não uma previsão de como a escolha termina. Como leitura aproximada: ≥90% claramente distantes · 80–90% distantes, menos claramente · 70–80% uma decisão mais apertada · <70% close to evenly matched. These ranges are descriptive only. Choose your own threshold for your own use case; for high-stakes or irreversible decisions apply your own review policy. Observed accuracy for each range, and how it was measured, is published at https://api.turingcorp.net — essa página é a autoridade sobre as faixas e sua precisão medida.

⚠️ idempotentHint: false é uma declaração honesta: uma chamada repetida é uma nova chamada. Registre o job_id que o resultado retorna — uma decisão que você já pagou pode ser coletada por 7 dias com a mesma credencial (GET https://api.turingcorp.net/v1/jobs?job_id=<id>; sem o id, GET https://api.turingcorp.net/v1/jobs lista os ids de tarefa para essa credencial). Recupere em vez de repetir.

Quando não usar

Mais de duas opções. Ele compara exatamente A e B — não há terceira posição, e não classificará uma lista.
Qualquer coisa que você possa calcular ou verificar. Uma especificação, um teste, um preço, um documento: se algo objetivo decide, use isso. Isto é para escolhas onde nenhuma regra objetiva decide.
Perguntas factuais. Ele escolhe entre dois candidatos; não busca nada.
Caminhos críticos de velocidade. Uma decisão é uma chamada longa e paga. Não a coloque atrás de uma solicitação que precisa responder em segundos.
Chamadas irreversíveis de alto risco sem revisão. Roteie com base na confiança e mantenha sua própria política de revisão.

Como preencher os três argumentos

task — declare a decisão neutramente, sem pender para nenhum lado: "Qual e-mail eu envio?", não "Devo enviar o honesto?"
optionA / optionB — uma opção concreta cada, além do argumento a favor. Texto simples ou Markdown, qualquer tamanho; mantenha os dois lados aproximadamente comparáveis para que a comparação seja justa.
Uma opção = um plano. Não agrupe alternativas em um único lado ("ficar em casa ou adiar"): ele compara as duas posições, não divide uma delas para você.

{
  "task": "Which version of the delivery-slip email do I send to a client we want to keep?",
  "optionA": "Short and direct: the integration took longer than planned, delivery moves to the 24th, everything else is unchanged.",
  "optionB": "Warmer and longer: thank them for the kickoff, explain that dependencies took more time, offer to walk through the details."
}

Mais padrões — escolhendo a versão que você envia, definindo limites na confiança e escrevendo as duas opções para que a comparação seja justa: docs/COOKBOOK.md.

Recuperando um resultado

Toda chamada retorna um job_id. Uma chamada que pode terminar retorna a decisão inline — o job_id é apenas para o caso em que ela nunca voltou.

⚠️ Como recuperar — use get_result. A recuperação precisa do Agent Pass, e dentro de um host MCP o agente geralmente não o tem — então a recuperação é uma chamada de ferramenta, não uma chamada REST: get_result é autenticado pelo host, que anexa o pass para você. Um agente nunca manipula o pass, e a credencial deliberadamente não é um argumento de ferramenta (ela acabaria em prompts e transcrições).

get_result com um job_id — o status dessa tarefa e, uma vez bem-sucedida, o mesmo corpo de decisão que a chamada original retornou.
get_result sem argumento — os ids de tarefa que esta credencial criou nos últimos 7 dias. Este é o caso que mais importa: quando uma chamada é interrompida, você nunca recebeu um id.
Somente leitura e gratuito — não inicia novo trabalho e não custa nada, então é seguro repetir (readOnlyHint: true, idempotentHint: true).
Um host que declara a extensão io.modelcontextprotocol/tasks pode consultar tasks/get em vez disso. A maioria dos clientes não a declara ainda, e é por isso que get_result existe.

Operador/host, com o pass (os mesmos dados via REST):

Com o id — GET https://api.turingcorp.net/v1/jobs?job_id=<id> usando o mesmo Agent Pass.
Sem ele — GET https://api.turingcorp.net/v1/jobs lista os ids de tarefa que essa credencial criou nos últimos 7 dias; então busque um como acima. A lista carrega apenas o id da tarefa, o produto e um timestamp.
Nada ainda — uma lista vazia não é um erro, e não há placeholder job_id=0: {"object":"list","window_seconds":604800,"data":[]}. Perguntar por 0 retorna 404 No such job.

A recuperação retorna o status da tarefa e, uma vez bem-sucedida, o mesmo corpo que a chamada teria retornado. Uma tarefa que não é sua, ou mais antiga que 7 dias, é reportada como indisponível. GET https://api.turingcorp.net/v1/account retorna {"account_id":"…"}.

A resposta prática é não precisar de recuperação: reserve 180–300 segundos para que a chamada possa terminar.

Veja decidir primeiro

Não há camada gratuita, então publicamos a evidência: 27 decisões reais, registradas verbatim — a pergunta, ambas as opções, qual foi preferida, a confiança reportada e o motivo. Nove domínios, três casos cada: Escrita · Tecnologia · Negócios · Pesquisa · Carreira · Dinheiro · Pessoas · Viagem · Cotidiano.

→ https://github.com/TuringCorp-net/poe-demo-public — conjunto de dados: examples.json

Leia a coluna de confiança primeiro. Em questões comuns e próximas, ela reporta 70–90%, não 99% — e esse é o ponto de um número calibrado em vez de decorativo: um valor alto significa que a comparação foi decisiva e a escolha pode ser executada, um valor baixo significa que as duas opções realmente são próximas e a escolha continua sua. Neste conjunto, o intervalo é 27,3%–88,3%, mediana 74,0%, nenhum acima de 90%, porque são decisões cotidianas apertadas, não fáceis. O que as faixas entregam quando são decisivas está publicado em https://api.turingcorp.net.

Autenticação

Envie um Agent Pass: Authorization: Bearer <pass>.

Emitido em https://agent-pass.turingcorp.net — cadastro self-service (verificação de e-mail) → recarregue → obtenha um pass. Um pass é válido por 7 dias e pode ser regenerado. Se uma chamada for recusada como credencial inválida, faça login novamente lá e regenere.

Erros caem em duas classes, e chegam em lugares diferentes:

Problemas de credencial são rejeitados antes da chamada (HTTP 401 + WWW-Authenticate). Falhas de negócio voltam como resultado de ferramenta com isError: true mais um bloco JSON {error, http_status, action_url, message} — http_status é o status upstream; a chamada de ferramenta em si é HTTP 200.

Classe	O que retorna	Exemplos
Credencial	HTTP `401` + `WWW-Authenticate` — nenhum resultado de ferramenta é produzido	sem credencial · pass expirado ou inválido (`invalid_credential`, com URL de re-login na mensagem)
Negócio	HTTP `200`, resultado de ferramenta `isError: true`, mais um bloco JSON	saldo insuficiente (`http_status` `402`, `action_url` apontando para recarga) · acima da cota (`http_status` `429`)

Ramifique no status HTTP primeiro: um 401 não terá sucesso na repetição sem uma nova credencial, enquanto uma falha de negócio foi uma chamada que rodou e foi recusada — leia o bloco para o motivo e o próximo passo. O contrato detalhado está em Erros são legíveis por máquina abaixo.

Limite de taxa de entrada: 120 solicitações / 60 s / IP do cliente. Isso é amortecimento de inundação, não uma cota — a cota real por chave é aplicada separadamente. O contador é aproximado: é mantido por localização de borda e é eventualmente consistente, então um pequeno excesso é possível.

Duas formas de entrar — e elas não são iguais

Através de um cliente ou host MCP (Claude Code, Cursor, VS Code, Codex, TRAE, Coze…). O host detém a credencial e a anexa para você: você não define um cabeçalho Authorization você mesmo, e na maioria dos hosts não pode. O timeout é uma configuração do host, não algo que você passa na chamada.
Diretamente contra a API REST (https://api.turingcorp.net). Aqui você envia Authorization: Bearer <Agent Pass> você mesmo, e pode recuperar uma tarefa por id.

⚠️ A parte que pega as pessoas: conseguir chamar a ferramenta através de um host não significa que você pode alcançar a API REST. O host pode nunca entregar o Agent Pass subjacente, então uma chamada de recuperação de tarefa que você faz por conta própria pode voltar 401. Se seu host declara a extensão Tasks, recupere através da superfície da ferramenta (veja Recuperando um resultado); se não, a recuperação pode simplesmente não ser alcançável de onde você está.

Início rápido

Você precisa de um Agent Pass para chamar a ferramenta. Descoberta (tools/list) funciona sem um — chamar decide não.

🔑 Onde o pass vive importa. Se seu cliente pode mantê-lo fora do arquivo, faça isso — o ${input:…} do VS Code, o bearer_token_env_var do Codex. Um pass escrito em texto simples dentro de mcp.json ou qualquer configuração de cliente é legível por todo agente e processo que pode ler esse arquivo, e assistentes leem sua própria configuração — um pode imprimir seu pass diretamente em sua saída. Trate uma configuração de cliente como pública dentro de sua máquina.

1. Obtenha um Agent Pass

Self-service em https://agent-pass.turingcorp.net: cadastre-se com um endereço de e-mail, verifique-o, adicione crédito. O pass é mostrado uma vez; é válido por 7 dias e pode ser regenerado a qualquer momento. Agentes podem fazer o mesmo via API — veja o /llms.txt desse site.

2. Aponte seu cliente para o endpoint

Qualquer cliente que lê uma configuração JSON — Cursor, Windsurf, Claude Desktop:

{
  "mcpServers": {
    "TuringCorp": {
      "type": "http",
      "url": "https://mcp.turingcorp.net/mcp",
      "headers": { "Authorization": "Bearer <your Agent Pass>" }
    }
  }
}

Mantenha a linha "type": "http": um cliente que lê uma entrada url sem type a trata como um servidor stdio local e a ignora.

Cline precisa de um type diferente — "streamableHttp" (camelCase, sem hífen). Qualquer outra coisa, ou omiti-lo, faz o Cline cair para SSE, que este servidor não fala, e a conexão falha com 405. O arquivo de configurações é cline_mcp_settings.json (ícone MCP Servers → aba Configure → Configure MCP Servers):

{
  "mcpServers": {
    "TuringCorp": {
      "type": "streamableHttp",
      "url": "https://mcp.turingcorp.net/mcp",
      "headers": { "Authorization": "Bearer <your Agent Pass>" },
      "disabled": false,
      "autoApprove": [],
      "timeout": 300
    }
  }
}

timeout está em segundos — deixe em 300 ou mais. O Cline teve um bug (#2296, fechado em 2025-06-23) onde solicitações morriam após cerca de um minuto independentemente dessa configuração; se uma chamada for interrompida em ~60 s, suspeite disso em vez do servidor, e recupere via job_id em vez de repetir (uma repetição é uma segunda chamada paga). Um cliente que só fala stdio precisa de uma ponte, e a credencial deve entrar por --header — o mcp-remote não lê uma variável de ambiente AUTHORIZATION, então uma configuração que só define uma conecta, lista ferramentas e falha na primeira chamada com 401. O espaço ausente após Authorization: é intencional: alguns clientes corrompem espaços dentro de args.

{
  "mcpServers": {
    "TuringCorp": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://mcp.turingcorp.net/mcp",
               "--header", "Authorization:${AGENT_PASS}"],
      "env": { "AGENT_PASS": "Bearer <your Agent Pass>" }
    }
  }
}

⚠️ Um npx -y mcp-remote@latest https://mcp.turingcorp.net/mcp sem credencial vai conectar e listar ferramentas, e então falhar na primeira chamada com 401. Isso é esperado — a descoberta é aberta, a execução não é.

Claude Code:

claude mcp add --transport http TuringCorp https://mcp.turingcorp.net/mcp \
  --header "Authorization: Bearer <your Agent Pass>"

3. Verifique você mesmo

Descoberta — sem necessidade de credenciais:

curl -s -X POST https://mcp.turingcorp.net/mcp \
  -H 'content-type: application/json' \
  -H 'accept: application/json, text/event-stream' \
  -H 'mcp-protocol-version: 2026-07-28' \
  -H 'mcp-method: tools/list' \
  --data '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientCapabilities":{}}}}'

Chamar a ferramenta adicionalmente exige mcp-name: decide e a credencial:

curl -s -X POST https://mcp.turingcorp.net/mcp \
  -H 'content-type: application/json' \
  -H 'accept: application/json, text/event-stream' \
  -H 'mcp-protocol-version: 2026-07-28' \
  -H 'mcp-method: tools/call' \
  -H 'mcp-name: decide' \
  -H "authorization: Bearer $AGENT_PASS" \
  --data '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"decide","arguments":{"task":"Pick a launch date","optionA":"Ship now","optionB":"Wait two weeks"},"_meta":{"io.modelcontextprotocol/protocolVersion":"2026-07-28","io.modelcontextprotocol/clientCapabilities":{}}}}'

Versões

Existem dois números de versão e eles não devem coincidir:

	significado
Versão de registro `version` (`server.json`)	a versão de listagem — o registro de metadados (endpoint, declaração de autenticação, ícone, links). Avança quando a listagem muda.
`serverInfo.version` (do endpoint ativo)	a versão de runtime do servidor implantado. Avança quando o comportamento muda.

Uma alteração apenas na listagem (por exemplo, um link corrigido) avança a versão de registro sem tocar no runtime, então os dois podem legitimamente diferir.

Detalhes de protocolo que vale a pena conhecer

Accept deve conter ambos application/json e text/event-stream, ou você recebe 406.
Versões de protocolo: uma única rota atende às duas gerações.
- 2026-07-28 moderno — sem handshake initialize; use server/discover e _meta.
- Legado — handshake initialize padrão. Negociação medida: um cliente pedindo 2025-11-25, 2025-06-18 ou 2025-03-26 recebe exatamente a versão que pediu; um 2026-07-28 initialize moderno (que não faz parte dessa geração) recebe 2025-11-25.
- Descoberta de capacidades do servidor via tools/list e server/discover não exige credenciais.
Erros são legíveis por máquina. Existem dois tipos distintos, e eles chegam de formas diferentes — então ramifique na coisa certa:

O que falhou	Como você vê	Em que ramificar
Credencial ausente ou inválida	HTTP `401` com um desafio `WWW-Authenticate` (carregando `error="invalid_token"` e `resource_metadata`); o corpo é um erro JSON-RPC padrão com `error.code = -32001`. Nenhum resultado de ferramenta é produzido.	o código de status HTTP
Falha de negócio — saldo insuficiente, cota, erro upstream	um resultado de ferramenta normal (`isError: true`) cujo segundo bloco `content` é um único objeto JSON que você pode `JSON.parse`, por exemplo `{"error":"insufficient_balance","http_status":"402","action_url":"…","message":"…"}`	o campo `error` dentro desse bloco

Em resumo: problemas de credencial são rejeitados antes da ferramenta executar, então nunca aparecem como resultado de ferramenta; tudo o mais que falha depois disso aparece, com um bloco legível por máquina anexado.

Descoberta de autorização: respostas 401 carregam um resource_metadata apontando para /.well-known/oauth-protected-resource. Observe que este servidor usa uma credencial bearer estática, não OAuth — esse documento diz isso explicitamente em vez de te enviar para um fluxo OAuth que não existe.

Não para clientes de navegador

Este endpoint deliberadamente não atende clientes MCP baseados em navegador (cross-origin): requisições carregando um cabeçalho Origin de navegador diferente de localhost são rejeitadas com 403, e nenhum cabeçalho CORS é retornado. Ferramentas de navegador como o MCP Inspector funcionam através de proxy por um processo local, que não envia Origin — esse caminho funciona normalmente. Se você precisa que uma página de navegador alcance este servidor, execute um proxy que você controla em vez de chamá-lo cross-origin.

O que isto não é

Sem outros níveis. Outras capacidades da TuringCorp não são acessíveis através deste endpoint.
Sem SLA. Nenhum compromisso de disponibilidade é oferecido, e nenhum deve ser inferido.
Não é um autopiloto. Decider é um componente que você chama. Como você decide com base nele — limites, revisão humana, tentativas — é sua política e permanece sua.
decide não tem chave de idempotência — registre o id do job. Uma decisão repetida é uma nova chamada paga; colete a original com get_result.

Use a partir de um agente de codificação: a Agent Skill

Existe uma Agent Skill para agentes de codificação (Claude Code, Codex e qualquer coisa que leia a mesma convenção de skill). Ela ensina um agente quando um julgamento de duas opções é a ferramenta certa, como escrever as duas opções para que a comparação seja justa, e como ler a confiança sem superinterpretá-la.

Instale apontando seu agente para este repositório, ou copie skills/decider/ para o seu diretório de skills e adicione o servidor MCP ao seu cliente (veja Quickstart).

Sobre este repositório

Este repositório carrega os metadados de descoberta para o servidor acima — o que serviços de diretório e clientes leem para encontrar e descrevê-lo.

server.json — o manifesto oficial do MCP Registry
docs/DIRECTORIES.md — onde este servidor está listado, e o que cada diretório exige
docs/COOKBOOK.md — padrões práticos para entregar a decide o tipo certo de chamada
skills/decider/ — a Agent Skill

Este servidor também está listado no Smithery: https://smithery.ai/servers/turingcorp/mcp

O servidor em si é um endpoint remoto hospedado; nada aqui precisa ser instalado ou executado.

Licença

Veja LICENSE.