Alles is een bestand: een ontwerpfilosofie van Unix tot AI Agent

Origineel door Ethan 业成

Een echo die een halve eeuw overbrugt

Al in de vroege jaren 1970 stelden Ken Thompson en Dennis Ritchie, de vaders van Unix, in Bell Labs voor het eerst een gedurfd, bijna obsessief ontwerpprincipe voor: Everything is a file - Alles is een bestand.

Meer dan vijftig jaar later is er een explosie van AI Agent-frameworks. Manus, Claude Code, OpenClaw... Ze komen van verschillende teams, verschillende technologiestacks en verschillende commerciële doelen, maar ze hebben allemaal dezelfde keuze gemaakt: het bestandssysteem gebruiken als het cognitieve skelet van de Agent.

Manus geeft de Agent een virtuele machine, waarbij de taakresultaten als bestanden op schijf worden opgeslagen. Claude Code leest en schrijft rechtstreeks naar het lokale bestandssysteem van de gebruiker, met een CLAUDE.md-bestand dat alle instructies en context bevat. OpenClaw en andere open-source frameworks organiseren taakdecompositie en tussenliggende statussen op dezelfde manier in een directorystructuur.

Wanneer ingenieurs die een halve eeuw van elkaar verwijderd zijn, geconfronteerd worden met totaal verschillende technische problemen, maar onafhankelijk van elkaar convergeren naar dezelfde oplossing - dit is geen toeval, dit is een resonantie van de ontwerpfilosofie.

De beslissing van Unix

Om het gewicht hiervan te begrijpen, moeten we eerst teruggaan naar wat Unix deed.

Het ontwerp van het Unix-bestandssysteem wordt algemeen erkend als een van de meest elegante ontwerpen in de geschiedenis van de computerwetenschap. Het loste een uiterst complex probleem op: hoe een uniforme, eenvoudige interface te gebruiken om een breed scala aan hardware- en databronnen te beheren.

Vóór de jaren 1970 werkten besturingssystemen als volgt: om een schijf te lezen, roep je de schijfinterface aan; om een tape te lezen, roep je de tapeinterface aan; om een terminal te benaderen, roep je de terminalinterface aan. Elk apparaat had zijn eigen API en elke API had zijn eigen semantiek. Als je N apparaten en M bewerkingen hebt, is de systeemcomplexiteit N × M.

Thompson en Ritchie deden iets wat ogenschijnlijk eenvoudig tot dom was:

Maak van alles een bestand. Gebruik de vier werkwoorden open, read, write en close om alles te bedienen.

De kernbetekenis hiervan is: alle bronnen in het besturingssysteem - documenten, mappen, harde schijven, modems, toetsenborden, printers, zelfs netwerkverbindingen en procesinformatie - kunnen worden geabstraheerd tot een bestandsstroom (Stream of Bytes).

Dit betekent dat je slechts één set API's hoeft te leren - open(), read(), write(), close() - om alle bronnen van de computer te bedienen.

Vanaf dat moment stort de complexiteit in van N × M naar 4 × 1. Vier werkwoorden, één abstractielaag.

Het geniale hieraan zit niet in het zelfstandig naamwoord "bestand", maar in een dieper inzicht:

Je hoeft niet te weten wat er achter de bestandsdescriptor zit. De interface is de overeenkomst.

Een fd (file descriptor) is een ondoorzichtige handle. Je read() erop, en er komt een byte stream uit. Of deze bytes nu afkomstig zijn van een harde schijfsector, een netwerkkaartbuffer of de standaarduitvoer van een ander proces - het kan je niet schelen, en het zou je ook niet moeten schelen.

Dat is de kracht van een uniforme interface: het maakt onwetendheid tot een voordeel.

Dezelfde vraag waarmee Agent wordt geconfronteerd

Laten we nu eens kijken naar de situatie van AI Agent.

Een Agent die een complexe taak moet voltooien, staat voor een verbazingwekkend vergelijkbare situatie als het besturingssysteem in de jaren 1970:

• Persistent geheugen: Het contextvenster van een LLM is vluchtig, de gedachteketen verdwijnt met de sessie. Net zoals geheugen wordt vrijgegeven nadat een proces is afgesloten - je hebt een plek nodig om de tussenliggende status persistent op te slaan, anders begint elk gesprek vanaf nul.
• Incrementele context: Complexe taken kunnen niet in één stap worden voltooid. Een Agent moet de context geleidelijk opbouwen in meerdere rondes van redenering, net zoals een Unix-proces de status tussen meerdere uitvoeringen doorgeeft door bestanden te lezen en te schrijven. Het bestandssysteem biedt van nature deze incrementele werkmodus van 'een beetje schrijven, een beetje lezen en dan weer een beetje schrijven'.
• Uniforme planning van tools en vaardigheden: Een Agent moet heterogene tools (Tools/Skills) aanroepen, zoals zoeken, code uitvoeren, afbeeldingen genereren, net zoals Unix heterogene apparaten zoals schijven, netwerken en printers moet beheren. Je hebt een uniforme abstractielaag nodig, anders moet je voor elke nieuwe tool een nieuwe integratielogica schrijven.
• Toegangsrechten voor Computer Use: Wanneer een Agent de mogelijkheid heeft om een computer te bedienen, wordt de vraag 'wat kan hij wel en niet aanraken' een kwestie van leven of dood. Het bestandstoegangsrechten systeem (rwx) van Unix biedt precies een kant-en-klaar sandboxmodel - de directory is de grens, de rechten zijn het contract.

Vier vereisten. Klinkt bekend, nietwaar?

Dit is precies het probleem waar het besturingssysteem in de jaren 70 mee te maken had.

Persistent geheugen - het bestandssysteem lost dit van nature op, schrijven is persistent. Incrementele context - de directorystructuur zelf is incrementeel opgebouwd, mkdir, touch, append, de context groeit met het bestand mee. Uniforme planning van tools - de essentie van Unix-pijpen: de stdout van het ene proces is de stdin van het andere proces, het tussenliggende medium is de byte stream. Hetzelfde geldt voor de toolketen van een Agent: het uitvoerbestand van de vorige stap is de invoer van de volgende stap. Toegangsrechten - de rwx-rechten van het bestandssysteem, de chroot-sandbox, bepalen van nature de 'competentie cirkel' voor de Agent.

Dus wanneer de ontwerpers van het Agent-framework geconfronteerd worden met de vraag 'waar de werkstatus van de Agent te plaatsen', is het antwoord bijna vanzelfsprekend: in het bestandssysteem. Omdat er geen eenvoudigere oplossing is die tegelijkertijd aan deze vier beperkingen voldoet.

Wanneer het systeem 'de interactie van een groot aantal heterogene resources moet beheren', heb je twee opties:

Route A: Ontwerp een speciale interface voor elke resource. N resources × M operaties = NM interfaces. Nauwkeurig maar explosief.

Route B: Vind een abstractielaag die dun genoeg is, zodat alle resources dezelfde 'kleding' dragen. 4 operaties × 1 abstractielaag. Ruw maar combineerbaar.

Unix koos B. Meer dan vijftig jaar later koos het Agent-framework opnieuw voor B.

Een laag dieper: het bestand is de externalisatie van denken

Maar als we alleen stoppen bij de 'convergentie van technische oplossingen', missen we iets essentieels.

Bedenk hoe mensen zelf complexe taken aanpakken.

Je krijgt een groot project, het eerste wat je doet is niet beginnen met werken, maar: mappen aanmaken. Project root directory, subtaak directory, referentie materiaal directory, output directory. Je gebruikt de directorystructuur om de chaotische taak op te splitsen in beheersbare eenheden. Je gebruikt de bestandsnaam om elke eenheid te benoemen. Je gebruikt de bestandsinhoud om het denkproces en de tussenproducten vast te leggen.

Het bestandssysteem is niet alleen een opslagoplossing. Het is het originele hulpmiddel voor de externalisatie van menselijk denken.

Dit inzicht verklaart waarom het Agent-framework convergeert naar het bestandssysteem: het 'denken' van de LLM moet worden geëxternaliseerd - het contextvenster is beperkt, lange termijn redenering moet afhankelijk zijn van extern geheugen. En het bestandssysteem is toevallig het meest universele 'externe geheugen' formaat dat de mens heeft uitgevonden.

Vanuit dit perspectief is CLAUDE.md van Claude Code geen configuratiebestand. Het is een soort geëxternaliseerd cognitief contract - mensen schrijven de intentie in een bestand, de Agent leest het bestand als intentie. Het bestand is de interfacelaag geworden tussen de menselijke geest en kunstmatige intelligentie.

Dit is opmerkelijk consistent met de filosofie van de Unix-pijplijn:

Write programs to handle text streams, because that is a universal interface.De zin "vervang 'programma's' door 'agents', vervang 'text streams' door 'files'" zal in 2026 nog steeds waar zijn.

Terug naar de eerste principes

Grote abstracties raken niet verouderd, ze vinden alleen nieuwe instanties in nieuwe domeinen.

"Uniforme interfaces lossen complexiteit op" is geen uitvinding van Unix, het is een eeuwige wet van systeemontwerp. Unix heeft het toevallig geïmplementeerd met de naam "bestand". AI Agent heeft het toevallig opnieuw geïmplementeerd in de vorm van een "werkdirectory".

De volgende generatie systemen zal ook weer voor dezelfde keuze staan: een speciale interface ontwerpen voor elk ding, of een dunne, algemene, combineerbare abstractie vinden?

Als de geschiedenis ons iets leert, staat het antwoord al naast /dev/null geschreven:

Keep it simple. Make it compose. Everything is a file.