உங்களுக்கு சப்-ஏஜென்ட்கள் தேவையில்லை
பெரும்பாலான மக்கள் ஏஜென்ட் கட்டமைப்புகளை (agent architectures) நிறுவன வரைபடங்களைப் (organizational charts) போல வரைகிறார்கள்.
அவர்கள் உச்சியில் ஒரு Orchestrator-ஐ வைக்கிறார்கள். ஒரு Researcher, ஒரு Coder மற்றும் ஒரு Tester-க்கு கோடுகளை வரைகிறார்கள். இது பார்ப்பதற்குத் தெளிவாகவும், தொழில்முறை ரீதியாகவும் (professional) இருக்கிறது.
இது ஒரு தவறு.
1975-இல், ஒரு மென்பொருள் திட்டம் தாமதமாகும் போது, அதில் கூடுதல் நபர்களைச் சேர்ப்பது அந்தத் தாமதத்தை இன்னும் அதிகமாக்கும் என்று ஃப்ரெட் புரூக்ஸ் (Fred Brooks) எழுதினார். தகவல் தொடர்புச் செலவுகள் (communication costs), வேலை முடிந்து போவதை விட வேகமாக அதிகரிப்பதால் இது நிகழ்கிறது.
நீங்கள் ஏஜென்ட்களின் கூட்டத்தை (swarm of agents) உருவாக்கும் போது, இதே தவறை மீண்டும் செய்கிறீர்கள்.
Orchestrator தனது முழு நேரத்தையும் துணைப் பணிகளை (subtasks) நிர்வகிப்பதிலேயே செலவிடுகிறது. இது மிகப்பெரிய கூடுதல் சுமையை (overhead) உருவாக்குகிறது. நீங்கள் ஒரு கட்டமைப்பை (architecture) உருவாக்கவில்லை; நீங்கள் ஒரு குழாய் அமைப்பை (plumbing) உருவாக்குகிறீர்கள்.
சப்-ஏஜென்ட்கள் ஏன் தோல்வியடைகின்றன என்பதற்கான காரணங்கள் இதோ:
- சூழல் இழப்பு (Context loss): ஒரு சப்-ஏஜென்ட் அதன் சொந்த விண்டோவில் இயங்குகிறது. அது தனது முழுமையான காரணத்தையும் (reasoning) முதன்மை ஏஜென்ட்டிற்கு (parent) அனுப்ப முடியாது. அது ஒரு சுருக்கத்தை (summary) மட்டுமே அனுப்புகிறது.
- செலவு மிகுந்த மாற்று வழிகள் (Expensive workarounds): முதன்மை ஏஜென்ட் என்ன நடந்தது என்பதைப் படிப்பதற்காக, மக்கள் ஏஜென்ட்களை கோப்புகள் (files) அல்லது git-இல் எழுதத் தூண்டுகிறார்கள். நீங்கள் ஒரு பகிரப்பட்ட நினைவகத்தை (shared memory) மீண்டும் உருவாக்குகிறீர்கள், ஆனால் அதை மெதுவாக்குகிறீர்கள்.
- டோக்கன் வீணாகுதல் (Token waste): ஒவ்வொரு எல்லையைத் தாண்டியும் சூழலை (context) கடத்துவதற்கு நீங்கள் பணம் செலுத்துகிறீர்கள். N ஏஜென்ட்கள் கொண்ட ஒரு கூட்டத்திற்கு N+1 டோக்கன்கள் செலவாகின்றன.
- முரண்பட்ட முடிவுகள் (Conflicting decisions): இணையான ஏஜென்ட்கள் (Parallel agents) வெவ்வேறு அனுமானங்களைச் செய்கின்றன. இரண்டு ஏஜென்ட்கள் ஒரே விஷயத்தை உருவாக்கும்போது, அவை பெரும்பாலும் வெவ்வேறு பாணிகள் அல்லது தர்க்கங்களைப் (logic) பயன்படுத்துகின்றன.
மல்டி-ஏஜென்ட் கட்டமைப்புகள் (multi-agent frameworks) 41% முதல் 87% வரை தோல்வி விகிதத்தைக் கொண்டுள்ளன என்று ஆய்வுகள் காட்டுகின்றன. ஏஜென்ட்கள் ஒருவருக்கொருவர் சரியாகப் புரிந்துகொள்ளாமல் பேசுவதால் இந்தத் தோல்விகள் ஏற்படுகின்றன. ஒரு சிறந்த மாடல் (model) இதைச் சரிசெய்யாது. இது ஒரு ஒருங்கிணைப்புப் பிரச்சினை (coordination problem), மாடல் சார்ந்த பிரச்சினை அல்ல.
அதற்குப் பதிலாக நீங்கள் எப்படி உருவாக்க வேண்டும்?
இந்த இரண்டு விதிகளைப் பின்பற்றுங்கள்:
- பணிகள் தனித்தனியானவை என்றால், அவற்றை தனித்தனி லூப்களாக (loops) இயக்கவும். இரண்டு தனித்தனி நிரல்களைப் (programs) பயன்படுத்தவும். இது இணையான செயலாக்கம் (parallel processing), மல்டி-ஏஜென்ட் சிஸ்டம் அல்ல.
- ஒரு பணிக்குத் தொடர்ச்சியான சிந்தனைத் தொடர் (single train of thought) தேவைப்பட்டால், ஒரே ஒரு லூப்பைப் பயன்படுத்தவும்.
ஒரு ஒற்றை லூப் அனைத்துச் சூழலையும் (context) ஒரே இடத்தில் வைத்திருக்கும். அது எளிதாகத் தன்னைத்தானே திருத்திக் கொள்ளும் (self-corrects). இது ஒரு குழப்பமான குழு உரையாடலுக்குப் (messy group chat) பதிலாக, ஒரு தெளிவான வரலாற்றை (clean history) வழங்கும்.
மெஷ்களை (meshes) உருவாக்குவதை நிறுத்துங்கள். லூப்களை (loops) உருவாக்கத் தொடங்குங்கள்.
Source: https://dev.to/tony__vi/you-dont-need-sub-agents-1eh7
Optional learning community: https://t.me/GyaanSetuAi