Everything is a File: დიზაინის ფილოსოფია Unix-დან AI Agent-ებამდე

ორიგინალი: Ethan 业成

ნახევარი საუკუნის გამოძახილი

ჯერ კიდევ 1970-იანი წლების დასაწყისში ბელის ლაბორატორიაში (Bell Labs), Unix-ის მამებმა კენ ტომპსონმა (Ken Thompson) და დენის რიჩიმ (Dennis Ritchie) პირველად წამოაყენეს თამამი და თითქმის ფანატიკური დიზაინის პრინციპი: Everything is a file - ყველაფერი ფაილია.

ორმოცდაათ წელზე მეტი ხნის შემდეგ, AI Agent-ის ჩარჩოები სწრაფად მრავლდება. Manus, Claude Code, OpenClaw... ისინი სხვადასხვა გუნდიდან არიან, სხვადასხვა ტექნოლოგიური სტეკიდან, სხვადასხვა კომერციული მიზნებიდან, მაგრამ ყველამ ერთხმად გააკეთა ერთი და იგივე არჩევანი: ფაილური სისტემა Agent-ის შემეცნებით ჩონჩხად აქციეს.

Manus Agent-ს ვირტუალურ მანქანას აძლევს, დავალების პროდუქტები ფაილებად ინახება. Claude Code პირდაპირ კითხულობს და წერს მომხმარებლის ლოკალურ ფაილურ სისტემაში, CLAUDE.md ფაილით ატარებს ყველა ინსტრუქციასა და კონტექსტს. OpenClaw და სხვა ღია კოდის ჩარჩოები ასევე იყენებენ დირექტორიების სტრუქტურას ამოცანების დაშლისა და შუალედური მდგომარეობების ორგანიზებისთვის.

როდესაც ნახევარი საუკუნის დაშორებით ინჟინრები, სრულიად განსხვავებული ტექნიკური პრობლემების წინაშე, დამოუკიდებლად იყრიან თავს ერთსა და იმავე გადაწყვეტაში - ეს შემთხვევითი არ არის, ეს დიზაინის ფილოსოფიის რეზონანსია.

Unix-ის ის გადაწყვეტილება

იმის გასაგებად, თუ რამდენად მნიშვნელოვანია ეს, ჯერ უნდა დავუბრუნდეთ იმას, თუ რა გააკეთა Unix-მა.

Unix-ის ფაილური სისტემის დიზაინი აღიარებულია, როგორც ერთ-ერთი ყველაზე ელეგანტური დიზაინი კომპიუტერული მეცნიერების ისტორიაში. მან გადაჭრა უკიდურესად რთული პრობლემა: როგორ გამოვიყენოთ ერთიანი, მარტივი ინტერფეისი მრავალფეროვანი აპარატურული და მონაცემთა რესურსების სამართავად.

1970-იან წლებამდე ოპერაციული სისტემები ასე მუშაობდნენ: დისკის წასაკითხად, დისკის ინტერფეისს იძახებთ; მაგნიტური ლენტის წასაკითხად, მაგნიტური ლენტის ინტერფეისს იძახებთ; ტერმინალზე წვდომისთვის, ტერმინალის ინტერფეისს იძახებთ. თითოეულ მოწყობილობას აქვს საკუთარი API, თითოეულ API-ს აქვს საკუთარი სემანტიკა. თუ თქვენ გაქვთ N ტიპის მოწყობილობა და M ტიპის ოპერაცია, სისტემის სირთულე არის N × M.

ტომპსონმა და რიჩიმ გააკეთეს ერთი შეხედვით მარტივი და სულელური რამ:

ყველაფერი ფაილად აქციეს. ყველაფრის სამართავად გამოიყენეს ოთხი ზმნა: open, read, write, close.

მისი ძირითადი მნიშვნელობაა: ოპერაციული სისტემის ყველა რესურსი - დოკუმენტები, დირექტორიები, მყარი დისკები, მოდემები, კლავიატურები, პრინტერები, ქსელური კავშირები და პროცესის ინფორმაციაც კი - შეიძლება აბსტრაგირებული იყოს როგორც ფაილის ნაკადი (Stream of Bytes).

ეს ნიშნავს, რომ თქვენ მხოლოდ ერთი API-ის სწავლა გჭირდებათ - open(), read(), write(), close() - კომპიუტერის ყველა რესურსის სამართავად.

ამიერიდან, სირთულე N × M-დან 4 × 1-მდე შემცირდა. ოთხი ზმნა, ერთი აბსტრაქცია.

ამ საქმის გენიალურობა არ არის სიტყვა "ფაილი", არამედ უფრო ღრმა დაკვირვებაში:

თქვენ არ გჭირდებათ იცოდეთ რა არის ფაილის დესკრიპტორის უკან. ინტერფეისი არის კონტრაქტი.

fd (ფაილის დესკრიპტორი) არის გაუმჭვირვალე სახელური. თქვენ მას read()-ს უკეთებთ, ბაიტების ნაკადი გამოდის. რაც შეეხება იმას, თუ ეს ბაიტები საიდან მოდის - მყარი დისკის სექტორიდან, ქსელის ბარათის ბუფერიდან თუ სხვა პროცესის სტანდარტული გამომავალიდან - თქვენ არ გაინტერესებთ და არც უნდა გაინტერესებდეთ.

ეს არის ერთიანი ინტერფეისის ძალა: ის უცოდინრობას უპირატესობად აქცევს.

Agent-ის წინაშე მდგარი იგივე ამოცანა

ახლა გადავხედოთ AI Agent-ის მდგომარეობას.

რთული ამოცანის შესასრულებლად, Agent-ი აწყდება საოცრად მსგავს სირთულეებს, რაც 1970-იანი წლების ოპერაციულ სისტემას ჰქონდა:

• მუდმივი მეხსიერება: LLM-ის კონტექსტური ფანჯარა არასტაბილურია და აზროვნების ჯაჭვი სესიასთან ერთად ქრება. ისევე, როგორც პროცესის გამოსვლის შემდეგ მეხსიერება იწმინდება — თქვენ გჭირდებათ ადგილი, სადაც შუალედურ მდგომარეობას შეინახავთ, წინააღმდეგ შემთხვევაში, ყოველი დიალოგი ნულიდან დაიწყება.
• თანდათანობითი კონტექსტი: რთული ამოცანის ერთ ნაბიჯში შესრულება შეუძლებელია. აგენტს სჭირდება კონტექსტის თანდათანობით დაგროვება მრავალჯერადი დასკვნის შედეგად, ისევე როგორც Unix პროცესი კითხულობს და წერს ფაილებს მრავალჯერადი შესრულებისას მდგომარეობის გადასაცემად. ფაილური სისტემა ბუნებრივად უზრუნველყოფს ამ "ცოტა დაწერე, ცოტა წაიკითხე და შემდეგ კიდევ ცოტა დაწერე" თანდათანობით მუშაობის რეჟიმს.
• ინსტრუმენტებისა და უნარების ერთიანი განრიგი: აგენტმა უნდა გამოიძახოს ჰეტეროგენული ინსტრუმენტები (Tools/Skills), როგორიცაა ძებნა, კოდის შესრულება, სურათების გენერირება, ისევე როგორც Unix-მა უნდა მართოს ჰეტეროგენული მოწყობილობები, როგორიცაა დისკები, ქსელები, პრინტერები. თქვენ გჭირდებათ ერთიანი აბსტრაქცია, წინააღმდეგ შემთხვევაში, ყოველი ახალი ინსტრუმენტის დამატებისას ახალი ინტეგრაციის ლოგიკა უნდა დაწეროთ.
• Computer Use-ის ნებართვის საზღვრები: როდესაც აგენტს აქვს კომპიუტერთან მუშაობის შესაძლებლობა, "რისი შეხება შეუძლია და რისი არა" სასიცოცხლოდ მნიშვნელოვანი ხდება. Unix-ის ფაილების ნებართვების სისტემა (rwx) ზუსტად უზრუნველყოფს მზა სენდბოქსის მოდელს — დირექტორია არის საზღვარი, ნებართვა არის კონტრაქტი.

ოთხი მოთხოვნა. ნაცნობად ჟღერს?

ეს ზუსტად ის პრობლემაა, რომელსაც ოპერაციული სისტემა 1970-იან წლებში შეხვდა.

მუდმივი მეხსიერება — ფაილური სისტემა ბუნებრივად აგვარებს, ჩაწერა ნიშნავს გამძლეობას. თანდათანობითი კონტექსტი — დირექტორიის სტრუქტურა თავისთავად ინკრემენტულად აგებულია, mkdir, touch, append, კონტექსტი იზრდება ფაილთან ერთად. ინსტრუმენტების ერთიანი განრიგი — Unix მილსადენის არსი: ერთი პროცესის stdout არის მეორე პროცესის stdin, შუალედური საშუალება არის ბაიტების ნაკადი. აგენტის ინსტრუმენტების ჯაჭვიც ასეა: წინა ნაბიჯის გამომავალი ფაილი არის შემდეგი ნაბიჯის შეყვანა. ნებართვის საზღვრები — ფაილური სისტემის rwx ნებართვები, chroot სენდბოქსი, ბუნებრივად განსაზღვრავს აგენტის "შესაძლებლობების წრეს".

ამიტომ, როდესაც აგენტის ჩარჩოს დიზაინერები აწყდებიან კითხვას "სად განვათავსოთ აგენტის სამუშაო მდგომარეობა", პასუხი თითქმის წინასწარ არის განსაზღვრული: ფაილურ სისტემაში. იმიტომ, რომ არ არსებობს უფრო მარტივი გამოსავალი, რომელსაც შეუძლია ერთდროულად დააკმაყოფილოს ეს ოთხი შეზღუდვა.

როდესაც სისტემას სჭირდება "უამრავი ჰეტეროგენული რესურსის ურთიერთქმედების მართვა", თქვენ გაქვთ ორი გზა:

მარშრუტი A: შეიმუშავეთ სპეციალური ინტერფეისი თითოეული რესურსისთვის. N ტიპის რესურსი × M ტიპის ოპერაცია = NM ტიპის ინტერფეისი. ზუსტი, მაგრამ ფეთქებადი.

მარშრუტი B: იპოვეთ საკმარისად თხელი აბსტრაქციის ფენა, რათა ყველა რესურსმა ერთი და იგივე ტანსაცმელი ჩაიცვას. 4 ტიპის ოპერაცია × 1 ფენის აბსტრაქცია. უხეში, მაგრამ კომბინირებადი.

Unix-მა აირჩია B. ორმოცდაათ წელზე მეტი ხნის შემდეგ, აგენტის ჩარჩომ კვლავ აირჩია B.

უფრო ღრმა ფენა: ფაილი არის აზროვნების ექსტერნალიზაცია

მაგრამ თუ მხოლოდ "ტექნიკური გადაწყვეტილებების კონვერგენციაზე" გავჩერდებით, უფრო არსებითს გამოვტოვებთ.

გაიხსენეთ, როგორ უმკლავდება კაცობრიობა რთულ ამოცანებს.

თქვენ იღებთ დიდ პროექტს, პირველი რაც უნდა გააკეთოთ არის: საქაღალდის შექმნა. პროექტის ძირეული დირექტორია, ქვედავალებების დირექტორია, საცნობარო მასალების დირექტორია, გამომავალი დირექტორია. თქვენ იყენებთ დირექტორიის სტრუქტურას ქაოტური ამოცანის მართვად ერთეულებად დასაშლელად. თქვენ ასახელებთ თითოეულ ერთეულს ფაილის სახელით. თქვენ იყენებთ ფაილის შინაარსს აზროვნების პროცესისა და შუალედური პროდუქტების ჩასაწერად.

ფაილური სისტემა არ არის მხოლოდ შენახვის გადაწყვეტა. ეს არის ადამიანის მიერ აზროვნების ექსტერნალიზაციისთვის გამოგონილი ორიგინალური ინსტრუმენტი.

ეს დაკვირვება ხსნის, თუ რატომ კონვერგირდება აგენტის ჩარჩო ფაილურ სისტემაზე: LLM-ის "აზროვნებას" სჭირდება ექსტერნალიზაცია — მისი კონტექსტური ფანჯარა შეზღუდულია და გრძელვადიანი დასკვნა უნდა ეყრდნობოდეს გარე მეხსიერებას. ფაილური სისტემა კი ზუსტად ის ყველაზე გავრცელებული "გარე მეხსიერების" ფორმატია, რომელიც ადამიანმა გამოიგონა.

ამ თვალსაზრისით, Claude Code-ის CLAUDE.md არ არის კონფიგურაციის ფაილი. ეს არის შემეცნებითი კონტრაქტის ექსტერნალიზაცია — ადამიანი წერს განზრახვას ფაილში, აგენტი კითხულობს ფაილს, როგორც განზრახვას. ფაილი ხდება ინტერფეისის ფენა ადამიანის გონებასა და ხელოვნურ ინტელექტს შორის.

ეს საოცრად შეესაბამება Unix მილსადენის ფილოსოფიას:

დაწერეთ პროგრამები ტექსტური ნაკადების დასამუშავებლად, რადგან ეს არის უნივერსალური ინტერფეისი.## პირველადი პრინციპების დაბრუნება

დიდებული აბსტრაქციები არასდროს ძველდება, ის მხოლოდ ახალ სფეროებში პოულობს ახალ მაგალითებს.

"ერთიანი ინტერფეისი ხსნის სირთულეს" Unix-ის გამოგონება არ არის, ეს სისტემის დიზაინის მარადიული კანონია. Unix-მა შემთხვევით გამოიყენა სახელი "ფაილი" მის განსახორციელებლად. AI Agent-მა შემთხვევით გამოიყენა ფორმა "სამუშაო დირექტორია" მის ხელახლა განსახორციელებლად.

მომავალი თაობის სისტემებიც კვლავ შეხვდებიან იგივე არჩევანს: თითოეული რამისთვის სპეციალური ინტერფეისის შექმნა, თუ თხელი, ზოგადი, კომბინირებადი აბსტრაქციის პოვნა?

თუ ისტორიას რაიმე გაკვეთილი აქვს, პასუხი უკვე /dev/null-ის გვერდით წერია:

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