Turn: A Language for Agentic Computation

O artigo apresenta o Turn, uma linguagem de programação compilada e baseada em atores projetada para software autônomo, que introduz garantias de nível de linguagem para segurança de tipos em inferência de LLMs, controle de fluxo baseado em confiança, isolamento de contexto, gestão segura de credenciais e absorção de esquemas em tempo de compilação, superando as limitações das abordagens atuais que tratam esses invariáveis apenas como convenções de aplicação.

O essencial

Imagine que você está tentando construir uma equipe de especialistas robóticos para gerenciar um fundo de investimentos. Você quer que eles pesquisem o mercado, tomem decisões e executem tarefas, mas há um problema: esses robôs são alimentados por Inteligência Artificial (LLMs) que, embora inteligentes, são um pouco... caóticos. Eles podem alucinar, esquecer coisas no meio da conversa ou, pior, vazarem segredos.

A maioria das ferramentas atuais tenta controlar esses robôs com "regras de conduta" escritas em papel (bibliotecas de código). Mas, como sabemos, regras escritas em papel são fáceis de ignorar.

O artigo "Turn: Uma Linguagem para Computação Agêntica" apresenta uma solução radical: em vez de apenas dar regras para os robôs, criamos uma nova linguagem de programação onde as regras são a própria estrutura do robô.

Aqui está uma explicação simples, usando analogias do dia a dia, dos cinco pilares que tornam o Turn especial:

1. O "Guardião de Identidade" (Segurança de Credenciais)

O Problema: Imagine que você dá a um assistente pessoal uma chave mestra da sua casa e diz: "Use isso para abrir a porta, mas não mostre a chave para ninguém". Se o assistente for um pouco desajeitado (ou alucinado), ele pode gritar "Olha a chave!" para a rua. Em programação atual, chaves de API (senhas) são apenas textos que o robô pode ler e vazar.

A Solução do Turn: O Turn trata as chaves como cartões de acesso invisíveis.

• Analogia: Em vez de entregar a chave de metal (o segredo) para o robô, você entrega um crachá de plástico opaco. O robô pode usar o crachá para abrir a porta (fazer a requisição), mas ele nunca consegue ver, copiar ou descrever o que está escrito no crachá. O segredo fica trancado no cofre do sistema, e o robô só segura o "pedaço de plástico" que funciona, mas não revela nada.

2. O "Filtro de Realidade" (Segurança de Tipo Cognitiva)

O Problema: Quando você pede para um robô escrever um relatório financeiro, ele pode devolver um texto bagunçado. O programa precisa tentar adivinhar onde está o número e onde está o texto. Se o robô errar a formatação, o programa quebra.

A Solução do Turn: O Turn exige que o robô preencha um formulário oficial antes de entregar a resposta.

• Analogia: Imagine que você pede a um funcionário para preencher um formulário de despesas. O Turn não aceita um bilhete rabiscado. Ele exige que o robô preencha exatamente os campos "Data", "Valor" e "Descrição". Se o robô tentar entregar algo que não se encaixa no formulário, o sistema não deixa passar. O computador verifica a resposta antes de aceitá-la, garantindo que o robô nunca entregue dados errados ou quebrados.

3. O "Botão de Confiança" (Controle Probabilístico)

O Problema: Às vezes, a IA está muito confiante em sua resposta, e às vezes ela está chutando. Em programas normais, o código trata tudo como se fosse 100% verdade, o que é perigoso.

A Solução do Turn: O Turn dá ao programador um medidor de confiança nativo.

• Analogia: É como se o robô dissesse: "Eu acho que a ação X vai subir, mas tenho apenas 40% de certeza". O Turn permite que você diga: "Se a certeza for menor que 70%, pare e faça um plano B automático". Isso transforma a incerteza da IA em uma decisão lógica e segura do programa.

4. O "Quarto Individual" (Modelo de Ator e Memória)

O Problema: Em sistemas atuais, todos os robôs compartilham a mesma "mesa de conversa". Se um robô esquece o que foi dito há 10 minutos porque a mesa ficou cheia, ele perde o contexto. Pior, um robô pode ouvir o que outro está dizendo, misturando informações.

A Solução do Turn: Cada robô tem seu próprio quarto com paredes à prova de som.

• Analogia: O Turn organiza os robôs como se fossem funcionários em cubículos individuais.
  • Memória Persistente: Cada um tem um diário pessoal que nunca é apagado, mesmo que o computador reinicie.
  • Contexto Limpo: O robô só ouve o que é relevante para ele. Se a conversa ficar muito longa, o Turn joga fora as partes mais antigas de forma inteligente, mantendo sempre o início (o objetivo) e o fim (o que acabou de ser dito) na memória, evitando que o robô se perca no meio da conversa.

5. O "Contrato Automático" (Absorção de Esquema)

O Problema: Conectar um robô a um novo serviço (como o banco ou uma API de clima) exige que o programador escreva manualmente como ler os dados daquele serviço. É chato e propenso a erros.

A Solução do Turn: O Turn pode ler o manual do serviço e criar o robô automaticamente.

• Analogia: Em vez de você ter que desenhar o formulário de um novo banco do zero, você aponta para o site do banco e diz: "Turn, leia o manual deles". O Turn vai lá, entende as regras, cria o formulário perfeito e já deixa pronto para o robô usar. Se o banco mudar o formulário, o Turn atualiza tudo sozinho na próxima vez que o programa for compilado.

Resumo: Por que isso importa?

O Turn muda a mentalidade de "como fazemos um robô seguir regras?" para "como construímos um robô que é impossível de quebrar?".

Em vez de depender da disciplina do programador para não cometer erros (o que falha em grande escala), o Turn coloca a segurança, a memória e a estrutura na própria linguagem. É como passar de um jogo de "quem consegue não cair" para um trem em trilhos: o trem (o agente) pode ir rápido, mas ele não pode sair dos trilhos.

O resultado? Agentes de IA mais seguros, que não vazam segredos, não esquecem o que foi combinado e não entregam respostas quebradas, permitindo que empresas confiem neles para tarefas reais e importantes.

Resumo técnico

Resumo Técnico: Turn – Uma Linguagem para Computação Agêntica

1. O Problema

A emergência de Grandes Modelos de Linguagem (LLMs) como motores de raciocínio geral deu origem a uma nova classe de software: programas agênticos. Diferente do software tradicional determinístico, os agentes delegam decisões críticas a modelos estocásticos, cujas saídas são estruturalmente imprevisíveis.

O artigo identifica uma incompatibilidade fundamental ao tentar construir esses sistemas usando linguagens de uso geral existentes (como Python, TypeScript ou Rust) e frameworks de bibliotecas. As abstrações centrais da computação agêntica (janelas de contexto limitadas, resultados de inferência tipados, estado de execução durável, memória isolada e segurança de credenciais) são tratadas apenas como convenções de nível de aplicação, não como garantias da linguagem.

Isso leva a cinco modos de falha recorrentes na prática:

1. Contexto Ilimitado: O gerenciamento de contexto como listas simples de mensagens leva a overflow silencioso ou truncamento, causando perda de informações críticas.
2. Saída de Inferência Sem Tipagem: O modelo retorna strings/JSON sem garantia de esquema, resultando em erros de tempo de execução desconectados da inferência original.
3. Estado Fragmentado: O estado do agente está espalhado entre variáveis, bancos de dados e internos do framework, sem uma representação serializável única.
4. Ausência de Execução Durável: Agentes de longa duração morrem com o processo; não há mecanismos nativos para checkpoint e retomada.
5. Vazamento de Credenciais: Chaves de API e tokens OAuth são armazenados como strings acessíveis à interface de chamada de ferramentas do LLM, criando vetores de exfiltração se o modelo alucinar instruções de I/O.

2. Metodologia e Design da Linguagem

O Turn é uma linguagem de programação compilada, baseada em atores, com tipagem estática para inferência de esquema e tipagem dinâmica no nível de valor. É executada em uma Máquina Virtual (VM) baseada em Rust.

A abordagem do Turn é tratar as restrições agênticas como primitivas de primeira classe da linguagem, em vez de padrões de biblioteca. O design integra conceitos de:

• Modelo de Atores (Erlang): Para concorrência e isolamento.
• Segurança Baseada em Capacidades: Para isolamento de credenciais.
• Tipos de Sessão: Para estruturar a comunicação com LLMs.
• Persistência Ortogonal: Para estado durável sem código explícito de salvamento.

3. Principais Contribuições

O artigo apresenta cinco construções de linguagem que abordam diretamente os modos de falha citados:

A. Segurança de Tipo Cognitiva (Cognitive Type Safety)

• Primitiva: infer Struct { prompt }
• Mecanismo: O compilador gera um JSON Schema a partir da definição de uma estrutura (struct) em tempo de compilação. Na execução, a VM envia esse esquema ao driver de inferência (LLM) e valida a resposta do modelo antes de vincular o valor à variável.
• Garantia: Se a expressão infer completa sem erro, o valor vinculado conforma-se estruturalmente ao tipo declarado. O compilador prova que o acesso aos campos retornará o tipo correto.

B. Fluxo de Controle Probabilístico

• Primitiva: Operador confidence
• Mecanismo: Extrai a certeza relatada pelo modelo (ex: log-probabilidades) de um resultado de inferência.
• Uso: Permite ramificação determinística baseada na incerteza estocástica (ex: se confidence < 0.7, executar um fallback determinístico). O valor retornado é encapsulado em um tipo Uncertain<T>.

C. Modelo de Processo Agêntico (Baseado em Atores)

• Estrutura: Cada agente é um processo isolado com:
  • Contexto Tripartite: Uma arquitetura de três camadas (Sistema, Trabalho, Episódico) projetada para maximizar a atenção do modelo (explorando as posições de primazia e recência, evitando o fenômeno "Lost in the Middle").
  • Memória Persistente: Armazenamento chave-valor isolado por processo.
  • Caixa de Correio (Mailbox): Comunicação assíncrona.
• Isolamento: Contextos não são compartilhados; um agente filho começa com contexto vazio, prevenindo contaminação.

D. Identidade Baseada em Capacidades

• Primitiva: grant identity::σ("name")
• Mecanismo: Retorna um handle de capacidade opaco (Identity) do host da VM.
• Segurança: O handle não pode ser convertido em string, serializado para JSON ou passado para ferramentas de saída. As credenciais reais nunca entram na memória do agente; a VM injeta o token no cabeçalho HTTP no nível do kernel (Rust) apenas quando a chamada de sistema ocorre.

E. Absorção de Esquema em Tempo de Compilação

• Primitiva: use schema::<protocol>("url")
• Mecanismo: Um macro que busca especificações de API (OpenAPI, GraphQL, etc.) em tempo de compilação, gera structs nativos do Turn e closures tipadas.
• Benefício: Fecha a lacuna entre a saída do LLM e o consumo de APIs externas, garantindo que os dados estejam corretos antes da execução.

4. Resultados e Avaliação

O Turn foi implementado em Rust e avaliado através de 105 testes de integração e benchmarks em hardware Apple M4.

• Opacidade de Credenciais (E1): Testes confirmaram que tokens brutos nunca aparecem no heap de valores do Turn ou na interface de ferramentas do LLM.
• Semântica de Confiança (E2): O operador confidence segue álgebra probabilística correta (ex: propagação de incerteza via produto de probabilidades).
• Arquitetura de Contexto (E3): A arquitetura tripartite (P0/P1/P2) mantém invariavelmente as posições de primazia e recência, independentemente do volume de contexto, validando a teoria de atenção U-shaped.
• Isolamento e Escala de Memória (E4): A memória por processo (remember/recall) oferece acesso médio O(1) e isolamento total entre agentes, mesmo com 100k entradas.
• Execução Durável (E5): O checkpoint (suspend) e retomada (resume) preservam fidelidade exata do estado (PC, pilha, memória, contexto) com latência sub-milissegundo para agentes pequenos e <7ms para agentes com 5.000 entradas.
• Complexidade vs. Frameworks: Um exemplo de "Comitê de Investimento" que exigiria ~350 linhas em frameworks como LangChain (com Redis, filas de mensagens e lógica de retry manual) foi implementado em apenas 89 linhas em Turn, reduzindo drasticamente a complexidade do estado distribuído.

5. Significado e Conclusão

O artigo conclui que o Turn demonstra que uma linguagem focada e pequena, com as primitivas corretas, oferece garantias mais fortes para software agêntico do que qualquer biblioteca construída sobre uma linguagem de uso geral.

A principal mudança de paradigma proposta é: "Um agente é um processo, não um loop." Ao codificar as restrições de contexto, memória, caixa de correio e ciclo de vida diretamente na linguagem, o compilador e o runtime podem impor mecanicamente invariantes críticos, eliminando toda uma classe de falhas que atualmente dependem da disciplina do desenvolvedor.

O Turn é de código aberto (licença MIT) e visa estabelecer a fundação para o desenvolvimento de software agêntico em escala de produção, com planos futuros para suporte a adaptadores de esquema adicionais (FHIR, MCP), agendamento de atores distribuídos e verificação formal.