Minden egy fájl: A Unix tervezési filozófiája az AI Agensekhez

Eredeti: Ethan 业成

Egy fél évszázadon átívelő visszhang

Már az 1970-es évek elején a Bell Labs-ben a Unix atyja, Ken Thompson és Dennis Ritchie először fogalmazott meg egy merész, szinte fanatikus tervezési elvet: Everything is a file – Minden egy fájl.

Több mint ötven évvel később az AI Agent keretrendszerek robbanásszerűen terjednek. Manus, Claude Code, OpenClaw... Különböző csapatoktól, különböző technológiai alapokról, különböző üzleti célokkal érkeznek, mégis mindannyian ugyanazt a döntést hozták: a fájlrendszert használják az Agent kognitív vázaként.

A Manus egy virtuális gépet ad az Agentnek, a feladat eredményei fájlokba kerülnek. A Claude Code közvetlenül a felhasználó helyi fájlrendszerén olvas és ír, és egy CLAUDE.md fájlban tárolja az összes utasítást és kontextust. Az OpenClaw és más nyílt forráskódú keretrendszerek hasonlóképpen a könyvtárszerkezetet használják a feladatok lebontásának és a köztes állapotoknak a szervezésére.

Amikor a fél évszázaddal ezelőtti mérnökök teljesen különböző technikai problémákkal szembesülnek, mégis függetlenül ugyanahhoz a megoldáshoz jutnak – ez nem véletlen, ez a tervezési filozófia rezonanciája.

A Unix döntése

Ahhoz, hogy megértsük ennek a dolognak a súlyát, először vissza kell mennünk ahhoz, hogy mit is csinált a Unix.

A Unix fájlrendszerének tervezését a számítástechnika történetének egyik legelegánsabb tervezésének tartják. Egy rendkívül összetett problémát oldott meg: hogyan lehet egy egységes, egyszerű interfésszel kezelni a rendkívül eltérő hardver- és adatforrásokat.

Az 1970-es évek előtt az operációs rendszerek így működtek: ha lemezt akarsz olvasni, a lemez interfészét hívod; ha szalagot akarsz olvasni, a szalag interfészét hívod; ha terminált akarsz elérni, a terminál interfészét hívod. Minden eszköznek megvan a saját API-ja, és minden API-nak megvan a saját szemantikája. Ha N féle eszközöd és M féle műveleted van, a rendszer komplexitása N × M.

Thompson és Ritchie tett egy látszólag egyszerű, már-már ostoba dolgot:

Mindent fájllá alakítottak. Minden művelethez a következő négy igét használták: open, read, write, close.

Ennek a lényege az, hogy az operációs rendszerben lévő összes erőforrás – dokumentumok, könyvtárak, merevlemezek, modemek, billentyűzetek, nyomtatók, sőt a hálózati kapcsolatok és a folyamatinformációk is – egy fájlfolyammá (Stream of Bytes) absztrahálhatók.

Ez azt jelenti, hogy csak egy API-t kell megtanulnod – open(), read(), write(), close() –, és máris kezelheted a számítógép összes erőforrását.

Ezzel a komplexitás N × M-ről 4 × 1-re csökkent. Négy ige, egy absztrakciós réteg.

Ennek a dolognak a zsenialitása nem a "fájl" szóban rejlik, hanem egy mélyebb meglátásban:

Nem kell tudnod, mi van a fájlleíró mögött. Az interfész egy szerződés.

Egy fd (fájlleíró) egy átlátszatlan fogantyú. Ha read()-et hívsz rá, byte-ok jönnek ki. Hogy ezek a byte-ok a merevlemez szektorából, a hálózati kártya pufferéből vagy egy másik folyamat standard kimenetéből származnak-e – az nem érdekel, és nem is kellene érdekelnie.

Ez az egységes interfész ereje: a tudatlanságot előnnyé teszi.

Az Agent ugyanazzal a feladattal néz szembe

Most nézzük meg újra az AI Agent helyzetét.

Ahhoz, hogy egy Agent összetett feladatot hajtson végre, a 1970-es évek operációs rendszereihez hasonló, megdöbbentő nehézségekkel kell szembenéznie:- Perzisztens memória: Az LLM kontextusablaka illékony, a gondolkodási lánc a munkamenettel együtt eltűnik. Mint amikor egy folyamat kilépése után a memória felszabadul – kell egy hely, ahol a köztes állapotokat perzisztensen tárolhatod, különben minden párbeszéd nulláról indul.

• Inkrementális kontextus: A komplex feladatok nem végezhetők el egy lépésben. Az Agentnek többkörös következtetés során fokozatosan fel kell halmoznia a kontextust, mint ahogy egy Unix folyamat fájlok olvasásával és írásával adja át az állapotot több végrehajtás között. A fájlrendszer természetesen biztosítja ezt a „írj egy kicsit, olvass egy kicsit, majd írj még egy kicsit” inkrementális munkamódot.
• Eszközök és képességek egységes ütemezése: Az Agentnek heterogén eszközöket (Tools/Skills) kell meghívnia, mint például keresés, kódvégrehajtás, képgenerálás, mint ahogy a Unixnak heterogén eszközöket kell kezelnie, mint például lemezek, hálózatok, nyomtatók. Szükséged van egy egységes absztrakciós rétegre, különben minden új eszközhöz új integrációs logikát kell írnod.
• A számítógép használatának engedélyhatárai: Amikor az Agent képes a számítógép kezelésére, az „mihez nyúlhat, és mihez nem” kérdés életbevágóvá válik. A Unix fájlhozzáférési rendszere (rwx) éppen egy kész homokozó modellt kínál – a könyvtár a határ, az engedély a szerződés.

Négy követelmény. Ismerősen hangzik?

Pontosan ezekkel a problémákkal szembesült az operációs rendszer az 1970-es években.

Perzisztens memória – a fájlrendszer természetesen megoldja, az írás perzisztenssé teszi. Inkrementális kontextus – a könyvtárszerkezet önmagában is inkrementálisan épül fel, mkdir, touch, append, a kontextus a fájlokkal együtt növekszik. Eszközök egységes ütemezése – a Unix csővezetékek lényege: az egyik folyamat stdout-ja a másik folyamat stdin-je, a köztes közeg pedig a bájtfolyam. Az Agent eszközkészlete is ilyen: az előző lépés kimeneti fájlja a következő lépés bemenete. Engedélyhatárok – a fájlrendszer rwx engedélyei, a chroot homokozó természetesen kijelöli az Agent „kompetenciakörét”.

Tehát amikor az Agent keretrendszer tervezői szembesülnek azzal a kérdéssel, hogy „hova tegyük az Agent munkamenetét”, a válasz szinte előre meg van határozva: a fájlrendszerbe. Mert nincs egyszerűbb megoldás, amely egyszerre teljesíti ezt a négy feltételt.

Amikor a rendszernek „nagyszámú heterogén erőforrás interakcióját” kell kezelnie, két út áll előtted:

A útvonal: Tervezz dedikált interfészeket minden erőforráshoz. N erőforrás × M művelet = NM interfész. Pontos, de robbanásszerű.

B útvonal: Találj egy elég vékony absztrakciós réteget, hogy minden erőforrás ugyanazt a ruhát viselje. 4 művelet × 1 absztrakciós réteg. Durva, de kombinálható.

A Unix a B-t választotta. Több mint ötven évvel később az Agent keretrendszer ismét a B-t választotta.

Mélyebben: A fájl a gondolkodás külső megjelenése

De ha csak a „technikai megoldások konvergenciájánál” állunk meg, akkor lemaradunk a lényegről.

Gondoljunk vissza, hogyan kezeljük mi, emberek a komplex feladatokat.

Kapsz egy nagy projektet, az első dolog, amit teszel, nem az, hogy elkezdesz dolgozni, hanem: mappákat hozol létre. Projekt gyökérkönyvtár, alfeladat könyvtárak, referenciaanyag könyvtárak, kimeneti könyvtárak. A könyvtárszerkezettel a kaotikus feladatot kezelhető egységekre bontod. A fájlnevekkel elnevezed az egyes egységeket. A fájlok tartalmával rögzíted a gondolkodási folyamatot és a köztes termékeket.

A fájlrendszer nem csak egy tárolási megoldás. Ez az emberi gondolkodás külsővé tételének eredeti eszköze.

Ez a meglátás magyarázza meg, hogy miért konvergál az Agent keretrendszer a fájlrendszerhez: az LLM „gondolkodását” külsővé kell tenni – a kontextusablaka korlátozott, a hosszú távú következtetésnek külső memóriára kell támaszkodnia. A fájlrendszer pedig éppen az ember által feltalált legáltalánosabb „külső memória” formátum.

Ebből a szempontból a Claude Code CLAUDE.md nem egy konfigurációs fájl. Ez egy külsővé tett kognitív szerződés – az ember szándékot ír a fájlba, az Agent pedig szándékot olvas a fájlból. A fájl az emberi elme és a mesterséges intelligencia közötti interfészréteg lesz.

Ez meglepően összhangban van a Unix csővezetékek filozófiájával:

Írj programokat szöveges adatfolyamok kezelésére, mert ez egy univerzális interfész.A "programok" helyett "ügynökök", a "szövegfolyamok" helyett "fájlok" – ez az állítás 2026-ban is igaz lesz.

Vissza az első elvekhez

A nagyszerű absztrakciók nem avulnak el, csupán új területeken találnak új példákat.

A "egységes interfész feloldja a komplexitást" nem a Unix találmánya, hanem a rendszertervezés örök törvénye. A Unix véletlenül a "fájl" névvel valósította meg. Az AI Agent véletlenül a "munkakönyvtár" formájában valósította meg újra.

A következő generációs rendszerek ismét ugyanazzal a választással szembesülnek majd: mindenhez dedikált interfészt tervezni, vagy találni egy vékony, általános, kombinálható absztrakciót?

Ha a történelem tanított valamit, akkor a válasz már régóta ott van a /dev/null mellett:

Tartsd egyszerűen. Tedd kombinálhatóvá. Minden fájl.