നിങ്ങൾക്ക് സബ്-ഏജന്റുകൾ (Sub-Agents) ആവശ്യമില്ല
മിക്ക ആളുകളും ഏജന്റ് ആർക്കിടെക്ചറുകൾ (agent architectures) ഒരു ഓർഗനൈസേഷണൽ ചാർട്ട് പോലെയാണ് വരയ്ക്കുന്നത്.
അവർ മുകളിൽ ഒരു Orchestrator വയ്ക്കുന്നു. ഒരു Researcher, ഒരു Coder, ഒരു Tester എന്നിവരിലേക്ക് വരകൾ വരയ്ക്കുന്നു. ഇത് കാണാൻ വൃത്തിയുള്ളതും പ്രൊഫഷണലുമാണ്.
എന്നാൽ ഇതൊരു തെറ്റാണ്.
1975-ൽ ഫ്രെഡ് ബ്രൂക്സ് എഴുതിയത്, വൈകിയ ഒരു സോഫ്റ്റ്വെയർ പ്രോജക്റ്റിലേക്ക് കൂടുതൽ ആളുകളെ ചേർക്കുന്നത് അത് കൂടുതൽ വൈകിക്കാൻ മാത്രമേ സഹായിക്കൂ എന്നാണ്. ആശയവിനിമയത്തിനുള്ള ചിലവ് (communication costs), ജോലി പൂർത്തിയാകുന്നതിനേക്കാൾ വേഗത്തിൽ വർദ്ധിക്കുന്നത് കൊണ്ടാണ് ഇത് സംഭവിക്കുന്നത്.
നിങ്ങൾ ഏജന്റുകളുടെ ഒരു കൂട്ടം (swarm of agents) നിർമ്മിക്കുമ്പോൾ, ഈ തെറ്റ് ആവർത്തിക്കുന്നു.
Orchestrator അതിന്റെ മുഴുവൻ സമയവും സബ് ടാസ്ക്കുകൾ (subtasks) നിയന്ത്രിക്കുന്നതിനായി ചിലവഴിക്കുന്നു. ഇത് വലിയൊരു അധികഭാരം (overhead) ഉണ്ടാക്കുന്നു. നിങ്ങൾ ഒരു ആർക്കിടെക്ചർ അല്ല നിർമ്മിക്കുന്നത്, മറിച്ച് പ്ലംബിംഗ് (plumbing) ആണ്.
സബ്-ഏജന്റുകൾ പരാജയപ്പെടുന്നത് എന്തുകൊണ്ടെന്നാൽ:
- കോൺടെക്സ്റ്റ് നഷ്ടപ്പെടൽ (Context loss): ഒരു സബ്-ഏജന്റ് അതിന്റെ സ്വന്തം വിൻഡോയിലാണ് പ്രവർത്തിക്കുന്നത്. അതിന്റെ പൂർണ്ണമായ യുക്തി (reasoning) പാരന്റ് ഏജന്റിലേക്ക് കൈമാറാൻ അതിന് കഴിയില്ല. അത് ഒരു സംഗ്രഹം (summary) മാത്രമേ അയക്കുന്നുള്ളൂ.
- ചെലവേറിയ പരിഹാരങ്ങൾ (Expensive workarounds): പാരന്റ് ഏജന്റിന് നടന്ന കാര്യങ്ങൾ വായിക്കാൻ വേണ്ടി ആളുകൾ ഏജന്റുകളെ ഫയലുകളിലോ git-ലോ എഴുതാൻ നിർബന്ധിക്കുന്നു. നിങ്ങൾ ഷെയർഡ് മെമ്മറി (shared memory) വീണ്ടും നിർമ്മിക്കുകയാണ്, പക്ഷേ അത് കൂടുതൽ സാവധാനത്തിലാക്കുന്നു.
- ടോക്കൺ പാഴാകുന്നു (Token waste): ഓരോ അതിർവരമ്പുകൾ കടന്നുപോകുമ്പോഴും കോൺടെക്സ്റ്റ് കൈമാറാൻ നിങ്ങൾ പണം നൽകേണ്ടി വരുന്നു. N ഏജന്റുകളുള്ള ഒരു കൂട്ടത്തിന് N+1 ടോക്കണുകൾ ചിലവാകുന്നു.
- പരസ്പരവിരുദ്ധമായ തീരുമാനങ്ങൾ (Conflicting decisions): സമാന്തരമായി പ്രവർത്തിക്കുന്ന ഏജന്റുകൾ വ്യത്യസ്ത അനുമാനങ്ങൾ (assumptions) എടുക്കുന്നു. രണ്ട് ഏജന്റുകൾ ഒരേ കാര്യം നിർമ്മിക്കുകയാണെങ്കിൽ, അവർ പലപ്പോഴും വ്യത്യസ്ത ശൈലികളോ ലോജിക്കോ ആണ് ഉപയോഗിക്കുന്നത്.
മൾട്ടി-ഏജന്റ് ഫ്രെയിംവർക്കുകൾക്ക് (multi-agent frameworks) 41% മുതൽ 87% വരെ പരാജയ നിരക്കുണ്ടെന്ന് ഗവേഷണങ്ങൾ കാണിക്കുന്നു. ഏജന്റുകൾ പരസ്പരം ആശയവിനിമയം നടത്താൻ കഴിയാതെ വരുന്നതുകൊണ്ടാണ് ഈ പരാജയങ്ങൾ സംഭവിക്കുന്നത്. ഒരു മികച്ച മോഡൽ കൊണ്ട് ഇത് പരിഹരിക്കാൻ കഴിയില്ല. ഇതൊരു കോർഡിനേഷൻ പ്രശ്നമാണ്, മോഡൽ പ്രശ്നമല്ല.
എങ്കിൽ നിങ്ങൾ എങ്ങനെയാണ് നിർമ്മിക്കേണ്ടത്?
ഈ രണ്ട് നിയമങ്ങൾ പാലിക്കുക:
- ജോലികൾ സ്വതന്ത്രമാണെങ്കിൽ, അവയെ പ്രത്യേക ലൂപ്പുകളായി (loops) പ്രവർത്തിപ്പിക്കുക. രണ്ട് പ്രത്യേക പ്രോഗ്രാമുകൾ ഉപയോഗിക്കുക. ഇത് പാരലൽ പ്രോസസ്സിംഗ് (parallel processing) ആണ്, മൾട്ടി-ഏജന്റ് സിസ്റ്റമല്ല.
- ഒരു ജോലിക്ക് ഒരേ ചിന്താശൈലി (single train of thought) ആവശ്യമാണെങ്കിൽ, ഒരു സിംഗിൾ ലൂപ്പ് ഉപയോഗിക്കുക.
ഒരു സിംഗിൾ ലൂപ്പ് എല്ലാ കോൺടെക്സ്റ്റും ഒരിടത്ത് തന്നെ സൂക്ഷിക്കുന്നു. ഇത് എളുപ്പത്തിൽ സ്വയം തിരുത്തുന്നു (self-corrects). ഇത് കുഴപ്പമുള്ള ഒരു ഗ്രൂപ്പ് ചാറ്റിന് പകരം വൃത്തിയുള്ള ഒരു ഹിസ്റ്ററി നൽകുന്നു.
മെഷുകൾ (meshes) നിർമ്മിക്കുന്നത് നിർത്തുക. ലൂപ്പുകൾ (loops) നിർമ്മിച്ചു തുടങ്ങുക.
Source: https://dev.to/tony__vi/you-dont-need-sub-agents-1eh7
Optional learning community: https://t.me/GyaanSetuAi