ஏஜென்டிக் லூப் (Agentic Loop): ஒரு நடைமுறை வழிகாட்டி

AI ஏஜென்ட்களுக்கு ப்ராம்ப்ட் (prompt) கொடுப்பதை நிறுத்துங்கள். லூப்களை (loops) வடிவமைக்கத் தொடங்குங்கள்.

பெரும்பாலான மக்கள் AI-ஐ ஒரு சாட்பாட் (chatbot) போல பயன்படுத்துகிறார்கள். நீங்கள் ஒரு ப்ராம்ப்ட் கொடுக்கிறீர்கள், அது ஒரு பதிலை அளிக்கிறது, நீங்கள் அடுத்த வேலைக்குச் செல்கிறீர்கள். இது ஒரு முறை மட்டுமே செய்யப்படும் பணி. இது ஒரு ஏஜென்ட் அல்ல.

ஒரு ஏஜென்டிக் லூப் (agentic loop) என்பது வேறுபட்டது. இது ஒரு வேலையைச் செய்கிறது, அதன் முடிவைச் சரிபார்க்கிறது, மேலும் தொடர்ந்து செய்ய வேண்டுமா அல்லது நிறுத்த வேண்டுமா என்று தீர்மானிக்கிறது.

சரிபார்ப்பு இல்லாத ஒரு பணி என்பது வெறும் நம்பிக்கை மட்டுமே.

ஒரு லூப் ஒரு எளிய சுழற்சியைப் பின்பற்றுகிறது:

  • தற்போதைய நிலையை கவனித்தல் (கோப்புகளைப் படித்தல் அல்லது சோதனைகளை இயக்குதல்).
  • ஒரு சிறிய நடவடிக்கையை எடுத்தல் (ஒன்றை மட்டும் மாற்றுதல்).
  • ஒரு நிலையான தரத்துடன் முடிவைச் சரிபார்த்தல்.
  • தொடர வேண்டுமா, வெற்றி பெற்றதால் நிறுத்த வேண்டுமா அல்லது தோல்வியடைந்ததால் நிறுத்த வேண்டுமா என்று தீர்மானித்தல்.

லூப் இன்ஜினியரிங் (Loop engineering) என்பது இத்தகைய சுழற்சிகளை உருவாக்கும் ஒரு கலை. இது உங்களை கைமுறை ப்ராம்ப்டிங்கிலிருந்து (manual prompting) தன்னாட்சி அமைப்புகளுக்கு (autonomous systems) மாற்றுகிறது.

ஒரு நம்பகமான லூப்பின் ஐந்து கட்டுமானத் தூண்கள்:

  • தூண்டுதல் (Trigger): லூப் எப்போது தொடங்குகிறது?
  • உள்ளீடுகள் (Inputs): ஒவ்வொரு முறையும் ஏஜென்ட் எந்தப் புதிய தரவைப் பார்க்கிறது?
  • செயல் (Action): அது செய்யும் ஒற்றை, மாற்றக்கூடிய மாற்றம் என்ன?
  • சரிபார்ப்பு (Check): வெற்றியை நிரூபிக்கும் நிலையான சோதனை எது?
  • நிறுத்தம் (Stop): செயல்பாட்டை முடிப்பதற்கான தெளிவான நிபந்தனைகள் என்ன?

ஏஜென்ட் தனது சொந்த வேலையைத் தானே மதிப்பிட அனுமதிக்காதீர்கள். குறியீட்டை (code) எழுதும் மாடல் தனக்குத் தானே மிகவும் கனிவாக இருக்கும். வேலையைச் சரிபார்க்க நீங்கள் ஒரு இரண்டாவது ஏஜென்ட் அல்லது ஒரு இயந்திரச் சோதனையைப் (mechanical test) பயன்படுத்த வேண்டும். இதுவே 'மேக்கர்-செக்கர்' (maker-checker) பிரிப்பு ஆகும்.

இந்த பொதுவான தோல்விகளைத் தவிர்க்கவும்:

  • முடிவில்லா லூப்கள் (Infinite loops): எப்போதும் அதிகபட்ச சுழற்சி எண்ணிக்கை (iteration count) மற்றும் பட்ஜெட்டை நிர்ணயிக்கவும்.
  • தவறான வெற்றி (Broken success): உங்கள் சரிபார்ப்பு "it looks done" என்று இருந்தால், ஏஜென்ட் பொய் சொல்லும். அதற்குப் பதிலாக "npm test passes" என்பதைப் பயன்படுத்தவும்.
  • காலாவதியான சூழல் (Stale context): நீண்ட உரையாடல்கள் தவறுகளுக்கு வழிவகுக்கும். ஏஜென்ட் வட்டில் (disk) உள்ள உண்மையான கோப்புகளைப் பார்ப்பதற்காக சூழலை (context) அடிக்கடி ரீசெட் செய்யவும்.

இலக்கு என்பது கைமுறை வேலையிலிருந்து மேற்பார்வையிடப்பட்ட தானியங்கி முறைக்கு (supervised automation) மாறுவதாகும். சிறிய அளவில் தொடங்குங்கள். பிழைகளைக் (bugs) கண்டறியும் ஒரு லூப்பை உருவாக்குங்கள். பின்னர் அவற்றைச் சரிசெய்யும் ஒரு லூப்பை உருவாக்குங்கள். உங்கள் சரிபார்ப்புகளை நீங்கள் நம்பிய பின்னரே ஆட்டோ-மெர்ஜிங் (auto-merging) முறைக்குச் செல்லுங்கள்.

மென்பொருளில் தடையாக இருப்பது இனி குறியீட்டைத் தட்டச்சு செய்வது அல்ல. இலக்கையும் சரிபார்ப்பையும் மிகத் தெளிவாக வரையறுப்பதே தடையாக உள்ளது; அப்போதுதான் நீங்கள் தூங்கிக் கொண்டிருக்கும்போது லூப் இயங்க முடியும்.

லூப்பை உருவாக்குங்கள். ஆனால் இன்ஜினியராகவே இருங்கள்.

Source: https://dev.to/truongpx396/the-agentic-loop-a-practical-field-guide-mnc

Optional learning community: https://t.me/GyaanSetuAi