ആപ്പിളിന്റെ പുതിയ കണ്ടെയ്നർ സിസ്റ്റത്തെ Docker-മായി താരതമ്യം ചെയ്താൽ അത് തകരാറിലായതുപോലെ തോന്നും. ഓരോ ഇൻസ്റ്റൻസും ഉപയോഗപ്രദമായ എന്തെങ്കിലും ചെയ്യുന്നതിന് മുമ്പ് തന്നെ 270 മുതൽ 400 MB വരെ റാം (RAM) ഉപയോഗിക്കുന്നു. സ്റ്റാർട്ടപ്പ് ഒരു ലിനക്സ് കണ്ടെയ്നറിനേക്കാൾ നാല് മുതൽ പത്ത് മടങ്ങ് വരെ സാവധാനത്തിലാണ്. ഒന്നിലധികം കണ്ടെയ്നറുകൾക്കിടയിൽ ഒരു വോളിയം പങ്കിടാൻ ശ്രമിച്ചാൽ നിങ്ങൾക്ക് ഒരു വലിയ തടസ്സം നേരിടും: ഒരു അറ്റാച്ച്മെന്റ്, ഒരു ബോക്സ്. മൈക്രോ സർവീസുകൾ (microservices) പ്രവർത്തിപ്പിക്കാൻ കുറഞ്ഞ ഭാരമുള്ള ഒരു മാർഗ്ഗം തേടുന്നവർക്ക് ഈ കണക്കുകൾ വലിയൊരു തിരിച്ചടിയായി തോന്നും.
എന്നാൽ ആപ്പിൾ നിങ്ങളുടെ ഡെവ് സ്റ്റാക്കിന് (dev stack) പകരക്കാരനായല്ല ഇത് നിർമ്മിക്കുന്നത്. പകരം, നിങ്ങൾക്ക് വിശ്വസിക്കാൻ കഴിയാത്ത കോഡുകൾക്കായി ഒരു ജയിൽ നിർമ്മിക്കുകയാണ്.
കാഴ്ചപ്പാടിലുണ്ടാകുന്ന ഈ ഒരു മാറ്റം ഓരോ പരാതിയെയും ബോധപൂർവ്വമായ ഒരു വിട്ടുവീഴ്ചയായി (intentional trade) മാറ്റുന്നു.
തെറ്റായ ബെഞ്ച്മാർക്ക്
കഴിഞ്ഞ പതിറ്റാണ്ടായി നമ്മുടെ ഇൻഡസ്ട്രി കണ്ടെയ്നറുകളെ കൂടുതൽ സാന്ദ്രതയുള്ളതാക്കാൻ (density) ശ്രമിച്ചുകൊണ്ടിരിക്കുകയാണ്. ഒരൊറ്റ കേർണലിൽ (kernel) ഡസൻ കണക്കിന് ആപ്പുകൾ പ്രവർത്തിപ്പിക്കാനും, മെമ്മറി പേജുകൾ പങ്കിടാനും, ഒരേ വോളിയങ്ങൾ ഉപയോഗിക്കാനും, മില്ലിസെക്കൻഡുകൾക്കുള്ളിൽ ബൂട്ട് ചെയ്യാനും നമ്മൾ ആഗ്രഹിച്ചു. Docker ആ പ്രശ്നം ഗംഭീരമായി പരിഹരിച്ചു. സോഫ്റ്റ്വെയറും ഹാർഡ്വെയറും തമ്മിലുള്ള വേർതിരിവ് (abstraction) പരമാവധി കുറയ്ക്കുക എന്നതായിരുന്നു ഇതിന്റെ പ്രധാന ലക്ഷ്യം.
ആപ്പിളിന്റെ ഡിസൈൻ നേരെ തിരിച്ചാണ് പ്രവർത്തിക്കുന്നത്. അത് സാന്ദ്രതയ്ക്ക് പകരം വേർതിരിവിനായി (separation) വിട്ടുവീഴ്ച ചെയ്യുന്നു. പങ്കിട്ട വിഭവങ്ങൾക്ക് (shared resources) പകരം കർശനമായ മതിലുകൾ അത് ഉപയോഗിക്കുന്നു. ഒരു Kubernetes ക്ലസ്റ്ററിനായുള്ള ഇൻഫ്രാസ്ട്രസ്ട്ര olarak ഇതിനെ കണ്ടാൽ, കണക്കുകൾ അവിശ്വസനീയമായി തോന്നും. ഓരോ കണ്ടെയ്നറും കാൽ ജിബി ഓവർഹെഡ് (overhead) ഉപയോഗിക്കുകയും അതിന്റേതായ കേർണൽ ഉണ്ടായിരിക്കുകയും ചെയ്യുന്ന ഒരു നോഡ് ശൃംഖല നിങ്ങൾ ഒരിക്കലും പാക്ക് ചെയ്യില്ല. ഇതിന്റെ സാമ്പത്തിക ലാഭം (economics) ഒട്ടും പ്രായോഗികമല്ല.
നിങ്ങളുടെ ലാപ്ടോപ്പിലേക്ക് നിങ്ങൾ ക്ഷണിച്ചുവിട്ട ഒരു AI ഏജന്റ് (AI agent) ആണെങ്കിൽ മാത്രം ഇത് മാറും.
വാടകക്കാരൻ മാറി
2026-ൽ, നിങ്ങളുടെ മെഷീനിൽ പ്രവർത്തിക്കുന്ന ഏറ്റവും അപകടകരമായ കോഡ് ഒരു വിഷലിപ്തമായ npm പാക്കേജോ അല്ലെങ്കിൽ സംശയാസ്പദമായ ഒരു ബ്രൗസർ എക്സ്റ്റൻഷോ അല്ല. അത് സ്വയം പ്രവർത്തിക്കുന്ന കോഡിംഗ് ഏജന്റുകളാണ് (autonomous coding agent). ഈ ടൂളുകൾ നിങ്ങളുടെ കോഡ്ബേസ് വായിക്കുകയും, ഫംഗ്ഷനുകൾ മാറ്റിയെഴുതുകയും, ഷെൽ കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കുകയും, എക്സ്റ്റേണൽ API-കൾ വിളിക്കുകയും ചെയ്യുന്നു. നിങ്ങളുടെ SSH കീകളും എൻവയോൺമെന്റ് ഫയലുകളും ബ്രൗസർ കുക്കികളും ഉള്ള അതേ ഡയറക്ടറി ട്രീക്കുള്ളിൽ തന്നെ ഇവ ഓരോ മിനിറ്റിലും ആയിരക്കണക്കിന് തീരുമാനങ്ങൾ എടുക്കുന്നു.
പരമ്പരാഗത പെർമിഷൻ മോഡലുകൾക്ക് (permission models) ഈ വേഗതയെ തടയാനാവില്ല. ഓരോ ഫയൽ റീഡും, ഓരോ സബ്പ്രോസസ്സ് സ്പോണിംഗും (subprocess spawn), ഓരോ നെറ്റ്വർക്ക് റിക്വസ്റ്റും ഒരു മനുഷ്യൻ അംഗീകരിക്കണമെന്ന് നിങ്ങൾക്ക് നിർബന്ധമില്ല. ആ അംഗീകാര പ്രക്രിയ അഞ്ച് മിനിറ്റ് കൊണ്ട് തീരുന്ന ഒരു റീഫാക്റ്ററിംഗ് ജോലിയെ ഒരു മണിക്കൂർ നീളുന്ന മേൽനോട്ടമാക്കി മാറ്റും. എന്നിരുന്നാലും, ഒരു ഏജന്റിന് നിങ്ങളുടെ ഹോം ഡയറക്ടറിയിലേക്ക് പൂർണ്ണമായ അനുമതി നൽകുന്നത് നിങ്ങളുടെ ലാപ്ടോപ്പ് ഒരു അപരിചിതന് നൽകുന്നതിനേക്കാൾ സുരക്ഷിതമല്ല.
ഏജന്റിനെ ഡിഫോൾട്ട് ആയി ഒരു ശത്രുവായി കാണുക എന്നതാണ് ഏക യുക്തിസഹമായ വഴി; തുടർന്ന് പ്രതീക്ഷകൾക്ക് പകരം ഘടനയിലൂടെ (structure) അതിന്റെ സുരക്ഷ തെളിയിക്കുക.
ആപ്പിളിന്റെ കണ്ടെയ്നർ സിസ്റ്റം കൃത്യമായി ആ ചിന്താഗതിക്ക് വേണ്ടിയാണ് രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്.
ഐസൊലേഷൻ (Isolation) പ്രധാനമാകുമ്പോൾ
ഓരോ ആപ്പിൾ കണ്ടെയ്നറും അതിന്റേതായ കേർണലോട് കൂടിയ ഒരു ലഘുവായ VM-നുള്ളിലാണ് പ്രവർത്തിക്കുന്നത്. Docker ലോകത്ത് ഇത് അസാധാരണമായ ഒരു കാര്യമാണ്. നിങ്ങൾക്ക് മെമ്മറി ഡ്യൂപ്ലിക്കേഷൻ (memory deduplication) നഷ്ടപ്പെടുന്നു. പങ്കിട്ട കേർണലിന്റെ വേഗത നിങ്ങൾക്ക് ലഭിക്കില്ല. ഒരൊറ്റ ഹോസ്റ്റിൽ നൂറുകണക്കിന് വർക്ക്ലോഡുകൾ പാക്ക് ചെയ്യാനുള്ള കഴിവും നിങ്ങൾക്ക് നഷ്ടപ്പെടുന്നു.
എന്നാൽ, വിശ്വസിക്കാൻ കഴിയാത്ത ഒരു ഏജന്റിനെ സംബന്ധിച്ചിടത്തോളം, ഒരു സ്വകാര്യ കേർണൽ ഒരു കോട്ട പോലെയാണ്. ഏജന്റ് അതിന്റെ യൂസർ സ്പേസിൽ (user space) നിന്ന് പുറത്തുകടന്നാലും, അത് നിങ്ങളുടെ ഹോസ്റ്റ് കേർണലല്ലാത്ത ഒരു അതിർവരമ്പിൽ തട്ടി നിൽക്കും. അത് പാഴാക്കലല്ല. ആ അധിക മെഗാബൈറ്റുകൾക്കായി നിങ്ങൾ നൽകുന്ന പണം നൽകുന്ന ഫീച്ചറാണത്.
ആപ്പിൾ ഈ അതിർവരമ്പ് mcpbridge വഴി വിപുലീകരിക്കുന്നു. പല കോഡിംഗ് ഏജന്റുകളും Model Context Protocol അല്ലെങ്കിൽ MCP ഉപയോഗിച്ചാണ് ടൂളുകളോട് സംസാരിക്കുന്നത്. ആപ്പിൾ ആ കമാൻഡുകളെ തടയുകയും അവയെ XPC-ലേക്ക് മാറ്റുകയും ചെയ്യുന്നു; macOS, iOS എന്നിവയിൽ സൂക്ഷ്മമായ പെർമിഷനുകൾ നടപ്പിലാക്കുന്ന അതേ ക്രോസ്-പ്രോസസ് ഫ്രെയിംവർക്കാണിത്. ഏജന്റിന് നിങ്ങളുടെ ഫയൽ സിസ്റ്റത്തിലോ നെറ്റ്വർക്കിലോ എളുപ്പത്തിൽ ഇടപെടാൻ കഴിയില്ല. ഓരോ ടൂൾ കോളും ആദ്യം ആപ്പിളിന്റെ കർശനമായ പെർമിഷൻ മോഡലിലൂടെ കടന്നുപോകണം.
പിന്നെ കമ്പ്യൂട്ടിംഗിലെ വിഭജനമുണ്ട്. ഭാരമേറിയ AI മോഡലുകൾ തന്നെ ഹോസ്റ്റ് Mac-ൽ തന്നെ നിലനിൽക്കുകയും Neural Engine-ൽ പ്രവർത്തിക്കുകയും ചെയ്യുന്നു. കണ്ടെയ്നർ മോഡൽ വെയ്റ്റുകൾക്കോ (model weights) ഇൻഫറൻസ് എഞ്ചിനുകൾക്കോ വേണ്ടി റാം (RAM) പാഴാക്കുന്നില്ല. അത് ഏജന്റിന്റെ ടൂളുകൾക്കും സ്ക്രാച്ച് സ്പേസിനും (scratch space) വേണ്ടി മാത്രമാണ് ഉപയോഗിക്കുന്നത്. ഹാർഡ്വെയർ ഏറ്റവും ശക്തമായ ഇടത്ത് കഠിനമായ ജോലികളും, അപകടസാധ്യതയുള്ള ജോലികൾ ആ കൂടപ്പിറപ്പിനുള്ളിലും (cage) നടക്കുന്നു.
ഈ ആർക്കിടെക്ചർ ആപ്പിളിന്റെ Private Cloud Compute സംരംഭത്തിന് പിന്നിലെ തത്വശാസ്ത്രത്തെ അനുസ്മരിപ്പിക്കുന്നു. ഉപയോക്താവിനോട് നിങ്ങളെ അന്ധമായി വിശ്വസിക്കാൻ ആവശ്യപ്പെടരുത്. സിസ്റ്റത്തിന്റെ ഘടനയിലൂടെ തന്നെ ആ അതിർവരമ്പ് തെളിയിക്കുക.