Tudo é um Arquivo: Uma Filosofia de Design do Unix ao Agente de IA

Original por Ethan 业成

Um Eco Através de Meio Século

No início dos anos 1970, nos Laboratórios Bell (Bell Labs), os pais do Unix, Ken Thompson e Dennis Ritchie, propuseram pela primeira vez um princípio de design ousado, quase fanático: Everything is a file – Tudo é um arquivo.

Mais de cinquenta anos depois, os frameworks de Agentes de IA estão explodindo. Manus, Claude Code, OpenClaw... Eles vêm de diferentes equipes, diferentes pilhas de tecnologia, diferentes objetivos de negócios, mas todos fizeram a mesma escolha: usar o sistema de arquivos como a estrutura cognitiva do Agente.

Manus dá ao Agente uma máquina virtual, e os produtos da tarefa são armazenados como arquivos. Claude Code lê e grava diretamente no sistema de arquivos local do usuário, usando um arquivo CLAUDE.md para transportar todas as instruções e o contexto. Frameworks de código aberto como o OpenClaw também organizam a decomposição de tarefas e os estados intermediários com uma estrutura de diretórios.

Quando engenheiros separados por meio século, enfrentando problemas técnicos completamente diferentes, convergem independentemente para a mesma solução – isso não é coincidência, é uma ressonância da filosofia de design.

A Decisão do Unix

Para entender o peso disso, precisamos primeiro voltar ao que o Unix fez.

O design do sistema de arquivos Unix é amplamente reconhecido como um dos designs mais elegantes da história da ciência da computação. Ele resolveu um problema extremamente complexo: como gerenciar uma ampla gama de recursos de hardware e recursos de dados com uma interface unificada e simples.

Antes da década de 1970, os sistemas operacionais funcionavam assim: para ler um disco, você chamava a interface do disco; para ler uma fita, você chamava a interface da fita; para acessar um terminal, você chamava a interface do terminal. Cada dispositivo tinha sua própria API, e cada API tinha sua própria semântica. Se você tivesse N tipos de dispositivos e M tipos de operações, a complexidade do sistema seria N × M.

Thompson e Ritchie fizeram algo que parecia simples a ponto de ser estúpido:

Transformar tudo em arquivos. Use os quatro verbos open, read, write, close para operar tudo.

Seu significado central é: todos os recursos no sistema operacional – documentos, diretórios, unidades de disco rígido, modems, teclados, impressoras e até conexões de rede e informações de processo – podem ser abstraídos como um fluxo de arquivos (Stream of Bytes).

Isso significa que você só precisa aprender um conjunto de APIs – open(), read(), write(), close() – para operar todos os recursos do computador.

A partir daí, a complexidade entrou em colapso de N × M para 4 × 1. Quatro verbos, uma camada de abstração.

A genialidade disso não está no substantivo "arquivo", mas em um insight mais profundo:

Você não precisa saber o que está por trás do descritor de arquivo. A interface é o contrato.

Um fd (descritor de arquivo) é um identificador opaco. Você faz read() nele e o fluxo de bytes sai. Se esses bytes vêm de setores do disco rígido, buffers de placa de rede ou a saída padrão de outro processo – você não se importa, e você não deveria se importar.

Esse é o poder de uma interface unificada: ela torna a ignorância uma vantagem.

O Mesmo Problema Enfrentado pelo Agente

Agora, vamos dar uma olhada na situação do Agente de IA.

Para completar uma tarefa complexa, um Agente enfrenta um dilema surpreendentemente semelhante ao do sistema operacional da década de 1970:

• Memória persistente: A janela de contexto de um LLM é volátil, e a cadeia de pensamento desaparece com a sessão. Assim como a memória é recuperada após a saída de um processo – você precisa de um lugar para persistir o estado intermediário, caso contrário, cada conversa começará do zero.
• Contexto progressivo: Tarefas complexas não podem ser concluídas em uma única etapa. O Agente precisa acumular contexto gradualmente em várias rodadas de inferência, assim como um processo Unix transmite o estado entre várias execuções lendo e gravando arquivos. O sistema de arquivos fornece naturalmente esse modo de trabalho progressivo de "escrever um pouco, ler um pouco e escrever um pouco mais".
• Agendamento unificado de ferramentas e habilidades: O Agente precisa chamar ferramentas heterogêneas (Tools/Skills) como pesquisa, execução de código e geração de imagens, assim como o Unix precisa gerenciar dispositivos heterogêneos como discos, redes e impressoras. Você precisa de uma camada de abstração unificada, caso contrário, você terá que escrever um novo conjunto de lógica de integração para cada nova ferramenta que conectar.
• Limites de permissão de uso do computador: Quando um Agente tem a capacidade de operar um computador, "o que ele pode tocar e o que não pode tocar" torna-se uma questão de vida ou morte. O sistema de permissões de arquivo do Unix (rwx) fornece exatamente um modelo de sandbox pronto – o diretório é o limite e a permissão é o contrato.

Quatro requisitos. Parece familiar?

Este é exatamente o problema que o sistema operacional enfrentou na década de 1970.

Memória persistente – o sistema de arquivos resolve naturalmente, a gravação é persistente. Contexto progressivo – a estrutura de diretórios em si é construída incrementalmente, mkdir, touch, append, o contexto cresce com o arquivo. Agendamento unificado de ferramentas – a essência do pipeline Unix: o stdout de um processo é o stdin de outro processo, e o meio intermediário é o fluxo de bytes. A cadeia de ferramentas do Agente é a mesma: o arquivo de saída da etapa anterior é a entrada da próxima etapa. Limites de permissão – as permissões rwx do sistema de arquivos e o sandbox chroot definem naturalmente um "círculo de capacidade" para o Agente.

Portanto, quando o designer da estrutura do Agente enfrenta a questão de "onde colocar o estado de trabalho do Agente", a resposta é quase predeterminada: coloque-o no sistema de arquivos. Porque não há solução mais simples que possa atender a essas quatro restrições ao mesmo tempo.

Quando o sistema precisa "gerenciar a interação de um grande número de recursos heterogêneos", você tem dois caminhos:

Rota A: Projetar interfaces dedicadas para cada recurso. N recursos × M operações = NM interfaces. Preciso, mas explosivo.

Rota B: Encontrar uma camada de abstração fina o suficiente para que todos os recursos usem as mesmas roupas. 4 operações × 1 camada de abstração. Bruto, mas combinável.

Unix escolheu B. Mais de cinquenta anos depois, a estrutura do Agente escolheu B novamente.

Uma camada mais profunda: Arquivos são a externalização do pensamento

Mas se pararmos apenas na "convergência da solução técnica", perderemos algo mais essencial.

Lembre-se de como os próprios humanos lidam com tarefas complexas.

Você recebe um grande projeto, a primeira coisa que você faz não é começar a trabalhar, mas: criar pastas. Diretório raiz do projeto, diretórios de subtarefas, diretórios de materiais de referência, diretórios de saída. Você usa a estrutura de diretórios para decompor tarefas caóticas em unidades gerenciáveis. Você usa nomes de arquivos para nomear cada unidade. Você usa o conteúdo do arquivo para registrar o processo de pensamento e os produtos intermediários.

O sistema de arquivos não é apenas uma solução de armazenamento. É a ferramenta original para externalizar o pensamento humano.

Essa percepção explica por que a estrutura do Agente converge para o sistema de arquivos: o "pensamento" do LLM precisa ser externalizado – sua janela de contexto é limitada e o raciocínio de longo alcance deve depender da memória externa. E o sistema de arquivos é precisamente o formato de "memória externa" mais universal que os humanos inventaram.

Desse ponto de vista, CLAUDE.md do Claude Code não é um arquivo de configuração. É um contrato cognitivo externalizado – os humanos escrevem a intenção em um arquivo e o Agente lê o arquivo como intenção. O arquivo se torna a camada de interface entre a mente humana e a inteligência artificial.

Isso é incrivelmente consistente com a filosofia do pipeline Unix:

Write programs to handle text streams, because that is a universal interface. (Escreva programas para lidar com fluxos de texto, porque essa é uma interface universal.)Substituir "programs" por "agents" e "text streams" por "files", essa frase em 2026 ainda será verdade.

Voltando aos Primeiros Princípios

Abstrações grandiosas não envelhecem, elas apenas encontram novas instâncias em novos domínios.

"Interfaces unificadas resolvem complexidade" não é uma invenção do Unix, é uma lei eterna do design de sistemas. O Unix por acaso a implementou com o nome "arquivo". O AI Agent por acaso a implementou novamente na forma de "diretório de trabalho".

A próxima geração de sistemas também enfrentará a mesma escolha: projetar interfaces dedicadas para cada coisa ou encontrar uma abstração fina, genérica e combinável?

Se a história nos ensinou alguma coisa, a resposta já está escrita ao lado de /dev/null:

Keep it simple. Make it compose. Everything is a file. (Mantenha simples. Faça com que se combine. Tudo é um arquivo.)