ഒരു AI ഏജന്റ് നിർമ്മിക്കുന്നത് ഒരു ചാറ്റ്ബോട്ടിനോട് സംസാരിക്കുന്നതിന് (prompting) തുല്യമാണെന്നാണ് ഞാൻ കരുതിയിരുന്നത്. നിങ്ങൾ ചോദ്യം കൃത്യമായി ചോദിക്കുന്നു, മോഡൽ മറുപടി നൽകുന്നു, സംഗതി അവിടെ തീരുന്നു. എന്നാൽ കുറച്ച് ആപ്ലിക്കേഷനുകൾ പുറത്തിറക്കിയപ്പോൾ യാഥാർത്ഥ്യം മനസ്സിലായി. ഒരു LLM ഒരു ഏജന്റല്ല. ഒരു LLM അടുത്ത ടോക്കൺ പ്രവചിക്കുക മാത്രമാണ് ചെയ്യുന്നത്. ആ ലൂപ്പ് (loop) ആണ് ഒരു ഏജന്റിനെ സൃഷ്ടിക്കുന്നത്.

ചായ ഉണ്ടാക്കുന്നത് ഒന്ന് ആലോചിച്ചു നോക്കൂ. നിങ്ങൾ make_tea() എന്നൊരു കമാൻഡ് നൽകി അവിടെ നിന്ന് നടന്നുപോകുന്നില്ല. നിങ്ങൾ കെറ്റിൽ നിറയ്ക്കുന്നു, ടാപ്പിലെ വെള്ളത്തിന്റെ പ്രഷർ കുറവാണെന്ന് മനസ്സിലാക്കുന്നു, കാത്തിരിക്കുന്നു, അത് ഓൺ ചെയ്യുന്നു, സ്വിച്ച് കേടാണെന്ന് കാണുന്നു, മറ്റൊരു ബർണറിലേക്ക് മാറുന്നു, ആവി ഉണ്ടോ എന്ന് പരിശോധിക്കുന്നു, ചായ ഒഴിക്കുന്നു, രുചിച്ചു നോക്കുന്നു, ഇലകൾ അധികനേരം വെള്ളത്തിൽ ഇരുന്നതുകൊണ്ട് ഒരുപക്ഷേ തേൻ ചേർക്കുന്നുണ്ടാകാം. ലക്ഷ്യം മാറുന്നില്ല, പക്ഷേ ഘട്ടങ്ങൾ മാറുന്നു. നിങ്ങൾ നിരീക്ഷിക്കുന്നു, ക്രമീകരിക്കുന്നു, വീണ്ടും ശ്രമിക്കുന്നു. AI ഏജന്റുകളും കൃത്യം ഇതുപോലെയാണ് പ്രവർത്തിക്കുന്നത്.

ഏജൻസി (Agency) സൃഷ്ടിക്കുന്ന ചക്രം

ഈ ലൂപ്പ് വെറുമൊരു സിദ്ധാന്തമല്ല. നിങ്ങളുടെ പേരിൽ പ്രവർത്തിക്കുന്ന ഏതൊരു സിസ്റ്റത്തിന്റെയും പ്രവർത്തനത്തിന്റെ ഹൃദയമിടിപ്പാണ് ഇത്. പ്രായോഗികമായി ഇത് എങ്ങനെയാണെന്ന് നോക്കാം:

  • Think: മോഡൽ ലക്ഷ്യത്തെക്കുറിച്ച് ചിന്തിക്കുകയും അതിന് എന്തൊക്കെ വേണമെന്ന് തീരുമാനിക്കുകയും ചെയ്യുന്നു. ഒരു ഉപയോക്താവ് ചോദിക്കുന്നു, "നാളെ പോർട്ട്‌ലാൻഡിലേക്ക് ഞാൻ കുട കൊണ്ടുപോകണോ?" കാലാവസ്ഥാ പ്രവചനവും ഒരു സ്ഥലവും ആവശ്യമാണെന്ന് മോഡൽ തിരിച്ചറിയുന്നു.
  • Act: മോഡൽ ഒരു ടൂൾ ഉപയോഗിക്കുന്നു. "Portland" എന്ന് കൃത്യമാക്കാൻ ഒരു geocoding API ഉപയോഗിച്ചേക്കാം, തുടർന്ന് ആ കോർഡിനേറ്റുകൾ ഉപയോഗിച്ച് ഒരു weather endpoint-ലേക്ക് റിക്വസ്റ്റ് അയച്ചേക്കാം.
  • Observe: മോഡൽ ടൂളിന്റെ ഔട്ട്‌പുട്ട് വായിക്കുന്നു. API ഒരു JSON പ്രവചനമാണോ, അതോ 403 error ആണോ, അതോ ഒരു HTML മെയിന്റനൻസ് പേജാണോ നൽകിയത്?
  • Update: കണ്ട കാര്യങ്ങൾക്കനുസരിച്ച് മോഡൽ അതിന്റെ പ്ലാൻ പരിഷ്കരിക്കുന്നു. Geocoder നൽകിയത് Portland, Oregon എന്നതിന് പകരം Portland, Maine ആണെങ്കിൽ, മോഡൽ അത് തിരുത്തേണ്ടതുണ്ട്. API പ്രവർത്തിക്കുന്നില്ലെങ്കിൽ, മറ്റൊരു സ്രോതസ്സ് ഉപയോഗിക്കുകയോ ഉപയോക്താവിനോട് ചോദിക്കുകയോ ചെയ്തേക്കാം.
  • Think Again: പുതിയ സാഹചര്യങ്ങളുമായി ചക്രം വീണ്ടും ആരംഭിക്കുന്നു.

ഇത് ഒരിക്കൽ എഴുതി വെച്ച് മറന്നുപോകാവുന്ന അഞ്ച് വ്യത്യസ്ത ഫംഗ്ഷനുകളല്ല. ലക്ഷ്യം കൈവരിക്കുന്നത് വരെ അല്ലെങ്കിൽ ഒരു നിർത്തൽ (hard stop) ഉണ്ടാകുന്നത് വരെ പ്രവർത്തിക്കുന്ന ഒരു തുടർച്ചയായ എൻജിനാണിത്. മോഡൽ ഒരു സ്ക്രിപ്റ്റ് പോലെ കോഡ് പ്രവർത്തിപ്പിക്കുകയല്ല ചെയ്യുന്നത്. അത് ലോകത്തിന്റെ അവസ്ഥയെക്കുറിച്ച് ചിന്തിക്കുകയും, ഒരു പ്രവർത്തി തിരഞ്ഞെടുക്കുകയും, അതിന്റെ ഫലം വായിക്കുകയും, അടുത്തത് എന്താണെന്ന് തീരുമാനിക്കുകയും ചെയ്യുന്നു. ഒരു മികച്ച autocomplete-ഉം ജോലി പൂർത്തിയാക്കുന്ന ഒരു ഏജന്റും തമ്മിലുള്ള വ്യത്യാസം ഇതാണ്.

ഫ്രെയിംവർക്കുകളെല്ലാം ഒരേപോലെ തോന്നുന്നത് എന്തുകൊണ്ട്?

നിങ്ങൾ LangGraph, CrewAI അല്ലെങ്കിൽ AutoGen എന്നിവ ഉപയോഗിച്ചിട്ടുണ്ടെങ്കിൽ, അവ തമ്മിലുള്ള വ്യത്യാസം തിരിച്ചറിയാൻ പ്രയാസമാണെന്ന് നിങ്ങൾ ശ്രദ്ധിച്ചിട്ടുണ്ടാകും. LangGraph പ്രവാഹത്തെ നോഡുകളുടെയും എഡ്ജുകളുടെയും (nodes and edges) ഒരു ഗ്രാഫ് ആയി കാണുന്നു. CrewAI ഏജന്റുകളെ റോളുകളായും ക്രൂകളായും (crews) സംഘടിപ്പിക്കുന്നു. AutoGen മൾട്ടി-ഏജന്റ് സംഭാഷണങ്ങളെ ഏകോപിപ്പിക്കുന്നു. പാക്കേജിംഗ് വ്യത്യസ്തമാണെങ്കിലും അടിസ്ഥാന ഘടന ഒന്നാണ്.

ഈ ലൂപ്പിംഗ് തത്വത്തെ അടിസ്ഥാനമാക്കിയാണ് ഇവയെല്ലാം നിർമ്മിച്ചിരിക്കുന്നത് എന്നതുകൊണ്ടാണ് അവ സമാനമായി തോന്നുന്നത്. ടൂൾ കോളുകൾക്കും മോഡൽ ഇൻഫറൻസിനും ഇടയിലുള്ള സ്റ്റേറ്റ് ട്രാൻസിഷനുകളായി (state transitions) LangGraph ഈ ചക്രത്തെ ഘടനപ്പെടുത്തുന്നു. CrewAI ഈ ലൂപ്പിനെ റോളുകൾ അടിസ്ഥാനമാക്കിയുള്ള ഏജന്റുകൾക്കുള്ളിൽ ഉൾക്കൊള്ളുന്നു, എങ്കിലും ഓരോ അംഗവും പ്ലാനിംഗ്, ആക്ഷൻ, ഒബ്സർവേഷൻ എന്നിവയിലൂടെ കടന്നുപോകുന്നു. AutoGen വിവിധ കക്ഷികൾക്കിടയിൽ സന്ദേശങ്ങൾ കൈമാറുന്നുണ്ടെങ്കിലും, ഓരോ ഘട്ടവും generate, execute, reflect, route എന്നിവയുടെ ഒരു രൂപമാണ്.

ഏജൻസി നിലനിൽക്കുന്നത് ഈ ലൂപ്പിൽ ആയതുകൊണ്ടാണ് ഈ ഫ്രെയിംവർക്കുകൾ ഇതിന് പ്രാധാന്യം നൽകുന്നത്. ഇതിന് പിന്നിലെ മോഡൽ GPT-4, Claude അല്ലെങ്കിൽ ഒരു fine-tuned open-weight model ആകാം. ലൂപ്പ് ഇല്ലെങ്കിൽ, അത് വളരെ വിലകൂടിയ ഒരു സെന്റൻസ് കംപ്ലീറ്റർ (sentence completer) മാത്രമാണ്. എന്നാൽ ലൂപ്പ് ഉണ്ടെങ്കിൽ, ലക്ഷ്യത്തിലേക്കുള്ള യാത്രയിൽ പലതവണ ശ്രമിക്കാനും പരാജയപ്പെട്ടാൽ തിരുത്തി മുന്നോട്ട് പോകാനും കഴിയുന്ന ഒരു സിസ്റ്റമായി അത് മാറുന്നു.

യഥാർത്ഥ ജോലി എപ്പോൾ തുടങ്ങുന്നു?

ലോക്കൽ ഡെമോകൾ കാണാൻ അത്ഭുതകരമായി തോന്നും. എന്നാൽ പ്രൊഡക്ഷൻ ഘട്ടത്തിൽ ആ അത്ഭുതം വെല്ലുവിളികളായി മാറും. പ്രോട്ടോടൈപ്പിംഗ് കഴിഞ്ഞാൽ, നിങ്ങൾ AI പ്രശ്നങ്ങളല്ല, മറിച്ച് സിസ്റ്റംസ് എൻജിനീയറിംഗ് പ്രശ്നങ്ങളാണ് പരിഹരിക്കാൻ തുടങ്ങുന്നത്.

ടൂൾ പരാജയങ്ങൾ ഒഴിവാക്കാനാവില്ല. API-കൾ ടൈം ഔട്ട് ആകാം. അവ തെറ്റായ JSON നൽകിയേക്കാം. HTML-ൽ പൊതിഞ്ഞ 500 എററുകൾ വന്നേക്കാം. നിങ്ങളുടെ ലൂപ്പ് ഓരോ ടൂൾ ഔട്ട്‌പുട്ടിനെയും അന്ധമായി വിശ്വസിക്കുകയാണെങ്കിൽ, ഏജന്റ് വിജയമുണ്ടെന്ന് തെറ്റായി കരുതുകയോ (hallucinate) അല്ലെങ്കിൽ ആശയക്കുഴപ്പത്തിലാവുകയോ ചെയ്യും. ഓരോ റിട്ടേൺ പേലോഡിലും (return payload) നിങ്ങൾക്ക് റീട്രൈ ലോജിക് (retry logic), സർക്യൂട്ട് ബ്രേക്കറുകൾ (circuit breakers), സ്കീമ വാലിഡേഷൻ (schema validation) എന്നിവ ആവശ്യമാണ്.

മെമ്മറി കാലഹരണപ്പെടാം. ഉപയോക്താവിന്റെ പ്രിയപ്പെട്ട ഡാറ്റാബേസ് PostgreSQL ആണെന്ന് ഏജന്റിന് ഓർമ്മയുണ്ടാകാം, എന്നാൽ ഇൻഫ്രാസ്ട്രക്ചർ ടീം ഇന്നലെ രാത്രി പുതിയൊരു ക്ലസ്റ്ററിലേക്ക് മാറിയിട്ടുണ്ടാകാം. കോൺടെക്സ്റ്റ് പുതുക്കാനോ കാലഹരണപ്പെടുത്താനോ ഉള്ള സംവിധാനമില്ലെങ്കിൽ, നിലവിലില്ലാത്ത എൻഡ് പോയിന്റുകളിലേക്ക് (dead endpoints) ഏജന്റ് ആത്മവിശ്വാസത്തോടെ കമാൻഡുകൾ അയച്ചുകൊണ്ടേയിരിക്കും. മെമ്മറിക്ക് ടൈംസ്റ്റാമ്പുകൾ (timestamps), കോൺഫിഡൻസ് സ്കോറുകൾ (confidence scores), സ്വയം റദ്ദാക്കാനുള്ള ശേഷി എന്നിവ ആവശ്യമാണ്.

ഇൻഫിനിറ്റ് ലൂപ്പുകൾ (Infinite loops) നിശബ്ദ കൊലയാളികളാണ്. ഒരു ഏജന്റ് വെബിൽ തിരയുന്നു, ഉപയോഗപ്രദമായ ഒന്നും കണ്ടെത്തുന്നില്ല, ക്വറി അല്പം മാറ്റുന്നു, വീണ്ടും തിരയുന്നു, ഒന്നും കണ്ടെത്തുന്നില്ല, ഇതേപോലെ ആവർത്തിക്കുന്നു. പരമാവധി ആവർത്തന പരിധിയോ (maximum iteration ceiling) സെമാന്റിക് ഡ്യൂപ്ലിക്കേറ്റ് ഡിറ്റക്ഷനോ ഇല്ലെങ്കിൽ, ഉപയോക്താവ് കാത്തിരിക്കുമ്പോൾ അത് ടോക്കണുകളും പണവും പാഴാക്കും. നിങ്ങൾ ഗാർഡ്‌റൈലുകൾ (guardrails) നിർമ്മിക്കണം: റീട്രൈകളിൽ പരിധി നിശ്ചയിക്കുക, വ്യതിയാനങ്ങൾ പരിശോധിക്കുക (divergence checks), മനുഷ്യ സഹായത്തിനായി മാറ്റാനുള്ള വഴികൾ (human escalation paths) എന്നിവ ഇതിൽ ഉൾപ്പെടുന്നു.

അപ്രസക്തമായ വിവരങ്ങൾ യുക്തിചിന്തയെ തളർത്തുന്നു. Retrieval-Augmented Generation പൈപ്പ്‌ലൈനുകൾ പലപ്പോഴും അപ്രസക്തമായ അമ്പതോളം ഖണ്ഡികകൾ കോൺടെക്സ്റ്റ് വിൻഡോയിലേക്ക് കുത്തിനിറയ്ക്കാറുണ്ട്. ഈ അനാവശ്യ വിവരങ്ങൾക്കിടയിൽ ഏജന്റ് കുടുങ്ങുകയും തെറ്റായ ടൂൾ തിരഞ്ഞെടുക്കുകയോ അല്ലെങ്കിൽ തെറ്റായ പാരാമീറ്ററുകൾ നിർമ്മിക്കുകയോ (hallucinate) ചെയ്യുന്നു. മോഡൽ വിവരങ്ങൾ കാണുന്നതിന് മുമ്പ് തന്നെ ഫിൽട്ടറിംഗ്, റാങ്കിംഗ്, സംക്ഷിപ്ത രൂപത്തിലുള്ള സംഗ്രഹം എന്നിവ ആവശ്യമാണ്.

ഒരു ഏജന്റിന് ബുദ്ധിശക്തി മാത്രം പോരാ. അതിന് ഒരു സിസ്റ്റം ആവശ്യമാണ്: മാനേജ്ഡ് മെമ്മറി, എക്സ്പ്ലിസിറ്റ് സ്റ്റേറ്റ് ട്രാക്കിംഗ്, കർശനമായ ഗാർഡ്‌റെയിൽസ്, ഒബ്സർവബിൾ ടെലിമെട്രി എന്നിവ ഇതിൽ ഉൾപ്പെടുന്നു. മോഡൽ എത്രത്തോളം മികച്ചതാണോ, അതിന് ചുറ്റുമുള്ള സിസ്റ്റവും അത്രത്തോളം മികച്ചതായിരിക്കണം. ഒരു ദുർബലമായ ലൂപ്പിനുള്ളിലെ ശക്തമായ മോഡൽ കൂടുതൽ വ്യക്തമായ പരാജയങ്ങൾ മാത്രമേ നൽകുകയുള്ളൂ.

ജോലി പൂർത്തിയാക്കുക

ഏജന്റുകളിലെ യഥാർത്ഥ ബുദ്ധിശക്തി എന്നത് ആദ്യത്തെ ഉത്തരം കൃത്യമായി നൽകുന്നതിലല്ല. പ്ലാൻ ചെയ്തതനുസരിച്ച് ഒന്നും നടക്കാത്ത സാഹചര്യത്തിൽ, ഉദ്ദേശ്യവും ഫലവും തമ്മിലുള്ള വ്യത്യാസം പരിഹരിച്ച് മുന്നോട്ട് പോകുന്നതിലാണ് അത് അടങ്ങിയിരിക്കുന്നത്. ആദ്യ ശ്രമം എളുപ്പമാണ്. ആർക്കും ഒരു 'ഹാപ്പി പാത്ത്' സ്ക്രിപ്റ്റ് ചെയ്യാൻ കഴിയും. എന്നാൽ പ്രൈമറി API പ്രവർത്തനരഹിതമാകുമ്പോഴും, കോൺടെക്സ്റ്റ് വിൻഡോ കുറഞ്ഞുവരുമ്പോഴും, ഉപയോക്താവിന് ക്ഷമ നശിക്കുമ്പോഴും, ഏജന്റ് ഇപ്പോഴും ഉപകാരപ്രദമായ എന്തെങ്കിലും നൽകേണ്ടി വരുന്ന നാലാമത്തെ ഇറ്ററേഷനാണ് യഥാർത്ഥ വെല്ലുവിളി.

ആ സ്ഥിരോത്സാഹമാണ് ഒരു ഡെമോയെ ഒരു ഉൽപ്പന്നത്തിൽ നിന്ന് വേർതിരിക്കുന്നത്. ഓരോ ഘട്ടത്തിൽ നിന്നും പഠിക്കാനുള്ള കഴിവാണത്; മോഡൽ വെയ്റ്റുകൾ തത്സമയം അപ്‌ഡേറ്റ് ചെയ്തുകൊണ്ടല്ല, മറിച്ച് പ്ലാൻ അപ്‌ഡേറ്റ് ചെയ്തുകൊണ്ടാണ് ഇത് സാധ്യമാകുന്നത്. തന്ത്രങ്ങൾ മാറിക്കൊണ്ടിരിക്കുമ്പോഴും ഏജന്റ് ലക്ഷ്യത്തിൽ ഉറച്ചുനിൽക്കുന്നു. ഇതാണ് 'ലൂപ്പിംഗ് പ്രിൻസിപ്പിൾ' പ്രായോഗികമാക്കുന്നത്.

അങ്ങനെയെങ്കിൽ ഭാവി വലിയ മോഡലുകൾക്കാണോ അതോ മികച്ച എക്സിക്യൂഷൻ ലൂപ്പുകൾക്കാണോ? സ്കെയിൽ തീർച്ചയായും സഹായിക്കും. കൂടുതൽ കഴിവുള്ള ഒരു മോഡൽ ഓരോ സൈക്കിളിനുള്ളിലും മികച്ച രീതിയിൽ ചിന്തിക്കും. എന്നാൽ കൃത്യമായതും നിരീക്ഷിക്കാവുന്നതും പ്രതിരോധശേഷിയുള്ളതുമായ ഒരു ലൂപ്പിനുള്ളിൽ പ്രവർത്തിക്കുന്ന ചെറിയൊരു മോഡൽ, എല്ലാം ഒറ്റയടിക്ക് (single shot) ചെയ്യാൻ ആവശ്യപ്പെടുന്ന ഒരു ഭീമൻ മോഡലിനേക്കാൾ എപ്പോഴും മികച്ച പ്രകടനം കാഴ്ചവെക്കും. പ്രവചനങ്ങളെ പ്രവൃത്തികളാക്കി മാറ്റുന്നത് ഈ ലൂപ്പാണ്. അവിടെ നിക്ഷേപിക്കുക.

സ്രോതസ്സ്: The Looping Principle: A Simple Mental Model for Understanding AI Agents

ഇത്തരത്തിലുള്ള കൂടുതൽ ചർച്ചകൾക്കായി, GyaanSetu learning community on Telegram-ൽ ചേരുക.