Sancho: Manifesto de uma Inteligência Geral

Antes da máquina, uma recusa

Sancho nasceu de uma recusa: a ideia de que inteligência geral será alcançada apenas aumentando modelos, parâmetros, consumo energético e dependência de grandes centros computacionais.

Modelos de linguagem são extraordinários na interpretação e produção de linguagem, mas continuam sujeitos a alucinações, memória instável e raciocínio lógico pouco auditável. O Projeto Sancho parte de outra hipótese: uma AGI não precisa ser um cérebro neural gigantesco e monolítico. Ela pode ser um ecossistema de partes especializadas, com memória legível, lógica verificável, ação controlada e mecanismos próprios de contestação.

O LLM não é o lugar onde a verdade vive. Ele é a superfície plástica da linguagem — a voz capaz de interpretar uma pergunta, estruturar uma intenção e traduzir uma resposta. A memória e a lógica pertencem a um grafo de conhecimento determinístico, no qual fatos, relações, regras e hipóteses podem ser inspecionados, corrigidos e rastreados.

O princípio neuro-simbólico

A arquitetura separa aquilo que os modelos atuais costumam misturar:

• A rede neural interpreta linguagem. Ela transforma linguagem natural em dados estruturados e converte estruturas internas em comunicação compreensível.
• O grafo preserva conhecimento e relações. A memória é registrada no Neo4j como nós e arestas, em vez de permanecer dissolvida em pesos matemáticos opacos.
• A lógica emerge da estrutura. Decisões intelectuais não devem depender de extensos blocos de if/else escritos no orquestrador. O código consulta o grafo; as relações armazenadas ajudam a formar a resposta.
• A realidade tem poder de veto. Uma hipótese só avança quando resiste a testes, limites de fronteira e falhas encontradas durante a execução.

Essa divisão torna o sistema mais auditável. Um conhecimento pode ser localizado. Uma regra pode ser questionada. Uma decisão pode deixar rastros. Uma falha pode retornar ao sistema como experiência estruturada.

A trindade arquitetônica

Sancho não é um agente único. É um ecossistema dividido em três módulos isolados, cada um com linguagem, responsabilidade e comportamento próprios.

Sancho — o cérebro e o orquestrador

Escrito em Python, Sancho recebe informações, identifica intenções, estrutura linguagem natural em JSON e conversa com o grafo por meio de Cypher. É a parte plástica do sistema: interpreta contexto, roteia problemas e procura relações entre domínios diferentes.

Sua criatividade não depende apenas de improvisação verbal. Ela pode explorar semelhanças estruturais entre regiões do grafo — usando relações e isomorfismos como pontos de partida para saltos interdisciplinares. Sancho formula, conecta e propõe; não recebe autoridade para agir sem mediação.

Rocinante — o corpo e o executor

Escrita em Rust, Rocinante transforma decisões aprovadas em ações no mundo real. É responsável por execução em dispositivos de borda, integração com hardware e sistemas, planejamento orientado a objetivos com GOAP e controle previsível por Máquinas de Estado Finito.

Rocinante é deliberadamente rígida. Ela não inventa objetivos nem reinterpreta livremente uma ordem. Executa payloads estruturados, trata todos os estados de erro e devolve resultados ao orquestrador.

Quando uma ação falha, entra em cena o Sistema Nemesis: o erro deixa de ser descartado como simples log e passa a ser registrado como uma experiência negativa — um “trauma” operacional. Esse retorno permite que Sancho revise a estratégia, atualize relações e evite repetir o mesmo caminho sem reflexão.

Sansão Carrasco — o inquisidor e o sistema imunológico

Também escrito em Rust, Sansão Carrasco existe para desconfiar. Ele recebe novos raciocínios, planos ou alterações destinadas à Rocinante e tenta refutá-los em ambiente isolado.

Sua filosofia vem da falsificabilidade de Karl Popper: uma hipótese não merece confiança por parecer elegante; ela precisa sobreviver a tentativas sérias de quebra. Fuzzing, testes de fronteira, entradas inesperadas e validações em sandbox formam o sistema imunológico do ecossistema.

Se Carrasco encontra uma falha, a proposta é reprovada e retorna para revisão. Sancho pode imaginar. Rocinante pode agir. Mas Sansão Carrasco preserva o vínculo entre imaginação e realidade.

Como o conhecimento percorre o sistema

O fluxo ideal começa com linguagem e termina em experiência verificável:

1. Sancho recebe uma pergunta, observação ou objetivo em linguagem natural.
2. O LLM traduz a entrada para um payload JSON estruturado.
3. O orquestrador consulta ou atualiza o grafo no Neo4j por meio de Cypher.
4. O grafo fornece relações, regras e contexto para a formulação de um plano.
5. Sansão Carrasco tenta quebrar ou falsificar a proposta em sandbox.
6. Uma proposta aprovada é enviada à Rocinante por API ou payload estruturado.
7. Rocinante executa a tarefa e devolve sucesso, falha ou “trauma” operacional.
8. Sancho registra a experiência no grafo, ampliando uma memória que permanece legível e corrigível.

Os módulos não compartilham acesso irrestrito entre si. Rocinante não consulta diretamente a memória de Sancho, e Carrasco não é uma etapa decorativa. O isolamento de domínio reduz acoplamento, limita danos e obriga cada módulo a respeitar contratos explícitos.

Uma AGI para hardware modesto

O projeto adota a “filosofia Raspberry Pi Zero”: cada decisão deve considerar memória, processamento, consumo energético e possibilidade de execução em VPS pequenas ou dispositivos de borda.

Isso implica rejeitar bloatware quando drivers nativos e bibliotecas menores resolvem o problema. Frameworks como LangChain ou LlamaIndex não fazem parte da base por padrão. O objetivo não é reconstruir a complexidade do ecossistema de IA dentro do projeto, mas manter interfaces claras entre Python, Rust, Neo4j e os modelos de linguagem utilizados como tradutores.

Em Rocinante e Sansão Carrasco, o Rust é também uma decisão de segurança. A arquitetura evita blocos unsafe, exige tratamento explícito de Result e Option e usa o borrow checker como parte do desenho, não como obstáculo a ser contornado.

O que já está definido

O avanço mais importante do projeto até aqui é arquitetônico. Já estão definidos:

• a separação entre linguagem neural, memória simbólica, execução e validação;
• os três módulos e suas responsabilidades;
• o Neo4j como núcleo de memória e lógica auditável;
• Python para o orquestrador e Rust para execução e segurança;
• contratos de comunicação baseados em APIs e JSON estruturado;
• o Sistema Nemesis para transformar falhas físicas em experiência;
• a falsificação sistemática como condição para novas ações e atualizações.

Essa definição não equivale a declarar uma AGI concluída. Sancho é uma arquitetura de AGI em construção: uma tese técnica transformada em módulos, restrições e caminhos concretos de implementação.

O que o projeto demonstra

Sancho reúne várias linhas do meu trabalho: planejamento de sistemas, uso de agentes de IA, grafos de conhecimento, automação, infraestrutura modesta e preocupação com segurança e auditabilidade.

Mais do que escrever código isolado, o projeto demonstra capacidade de decompor um problema muito grande em domínios menores, definir responsabilidades, limitar privilégios e criar um ciclo no qual linguagem, lógica, ação e erro possam conversar sem se confundir.

É também um exercício de independência tecnológica. A ambição não é competir em força bruta com laboratórios bilionários, mas investigar se uma inteligência geral pode nascer de outra combinação: menos opacidade, mais estrutura; menos escala indiscriminada, mais memória legível; menos confiança cega, mais possibilidade de refutação.

Estado atual e próximos passos

O Projeto Sancho está em desenvolvimento, com sua arquitetura central definida e os módulos em processo de especificação e prototipagem. Ainda não há demonstração pública nem link de execução disponível.

Os próximos passos são consolidar o esquema inicial do grafo, formalizar os contratos JSON entre os módulos e construir uma prova de conceito de ponta a ponta: uma entrada interpretada por Sancho, validada pelo Carrasco, executada pela Rocinante e registrada novamente como experiência no Neo4j.

Sancho começa como arquitetura, mas foi concebido para aprender apenas quando pensamento, teste e realidade conseguem permanecer na mesma conversa.