AI உலகம் 'லூப்' நிலையை அடைந்துவிட்டது

Meta-வின் @Scale மாநாட்டில் கடந்த வெள்ளிக்கிழமை, பார்வையாளர்களில் ஒருவர் Claude Code-ன் உருவாக்கியாளரான Boris Cherny-ஐ AI loops அடுத்த hype cycle-ஆ அல்லது உண்மையான ஒன்றா என்று கேட்டார். அவரது பதில் உடனடியாக வந்தது: உண்மையான, மற்றும் கையால் எழுதப்பட்ட குறியீட்டிலிருந்து agentic AI-க்கு மாறுவது போல் முக்கியமானது. அந்த பரிமாற்றம் உலகெங்கும் உள்ள டெவலப்பர்கள்조용히பரীட்சை செய்து வரும் ஒன்றுக்கு பெயர் வைத்தது, மேலும் AI அமைப்புகள் உண்மையில் என்ன செய்ய முடியும் என்பது பற்றி நாம் எப்படி சிந்திக்க வேண்டும் என்பதை மறுவடிவமைக்கிறது. AI உலகம் 'லூப்' நிலையை அடைந்துவிட்டது, மேலும் ஆசியாவில் கட்டமைக்கும் டெவலப்பர்களுக்கு, அந்த மாற்றம் குறிப்பிட்ட தாக்கங்களைக் கொண்டுள்ளது.

என்ன நடந்தது

Anthropic-ல் Claude Code-ன் தலைவரான Boris Cherny, Meta-வின் @Scale மாநாட்டில் தோன்றி "loops" AI அமைப்புகள் எவ்வாறு செயல்படுகின்றன என்பதில் அடுத்த முக்கிய கட்டடக்கலை மாற்றத்தை பிரதிநிதித்துவம் செய்கிறது என்ற வழக்கை முன்வைத்தார். அவர் விவரித்த முன்னேற்றம் நேரடியாக மேற்கோள் காட்டுவதற்கு தகுந்தது: "இரண்டு ஆண்டுகளுக்கு முன், நாங்கள் source code-ஐ கையால் எழுதினோம். agents code-ஐ எழுதும் வகையில் மாறத் தொடங்கினோம். இப்போது agents மற்ற agents-ஐ prompt செய்யும் புள்ளிக்கு மாறிக்கொண்டிருக்கிறோம், அவை பின்னர் code-ஐ எழுதுகின்றன." agentic AI-லிருந்து looping AI-க்கு செல்வது manual coding-லிருந்து agents-க்கு செல்வது போல் முக்கியமானது என்று அவர் வாதிட்டார்.

ஒரு loop உண்மையில் நடைமுறையில் எப்படி தெரிகிறது? Cherny தனது சொந்த setup-ஐ பேச்சில் விவரித்தார்: ஒரு agent தொடர்ந்து code architecture-ஐ மேம்படுத்த வழிகளை ஸ்கேன் செய்கிறது, மற்றொன்று duplicated abstractions-ஐ தேடுகிறது அவை ஒன்றிணைக்கப்படலாம். இரண்டும் எந்த மனித பங்களிப்பாளரும் செய்வது போல் pull requests-ஐ சமர்ப்பிக்கின்றன. Codebase எப்போதும் மாறிக்கொண்டிருப்பதால், எந்த agent-ம் ஒருபோதும் இயங்குவதை நிறுத்தாது. முடிவு வரி இல்லை — தொடர்ந்து, பின்னணி மேம்பாடு மட்டுமே.

இது முற்றிலும் புதிய பிரதேசம் அல்ல. Recursive loops கணினி அறிவியலின் தொடக்கத்திலிருந்தே ஒரு பிரதான — functions அவை தங்களை அழைக்கும் வரை ஒரு நிபந்தனை பூர்த்தி செய்யப்படும். இங்கே வேறுபாடு என்னவென்றால் stopping condition deterministic அல்ல. ஒரு sub-agent loop போதுமான வேலை செய்துவிட்டது என்று முடிவு செய்கிறது, hard-coded rule அல்ல. அந்த non-determinism இதை உண்மையில் புதியதாக உணர வைக்கிறது.

டெவலப்பர் சமூகங்களில் ஏற்கனவே சுழல்கிற ஒரு பிரபலமான செயல்படுத்தல் Ralph Loop — Ralph Wiggum-ன் பெயரில் சிறப்பாக பெயரிடப்பட்டது — model இதுவரை சாதித்த அனைத்தையும் சுருக்கி, இலக்கு பூர்த்தி செய்யப்பட்டுவிட்டதா என்று கேட்பதன் மூலம் செயல்படுகிறது. AI models நீண்ட காலத்திற்கு இயங்கும்போது drift-ஐ தடுப்பதற்கான ஒரு எளிய ஆனால் प्रभावी வழி,本質的に model-ஐ action மற்றும் self-evaluation-க்கு இடையே bounce செய்கிறது task முடியும் வரை.

மேலும் test-time compute-க்கான பரந்த push-க்கு ஒரு সংযோகம் உள்ளது — models parameters-ஐ scale செய்வதற்கு பதிலாக அதிக நேரம் reasoning செய்வதன் மூலம் சிறந்த outputs-ஐ உற்பத்தி செய்ய முடியும் என்ற ধারணை. Loops அந்த framework-ல் நேர்த்தியாக பொருந்துகிறது: ஒரு பெரிய inference pass-க்கு பதிலாக, நீங்கள் நேரத்தின் மீது தொடர்ந்து, iterative refinement-ஐ பெறுகிறீர்கள்.

ஆசியாவுக்கு இது ஏன் முக்கியமானது

ஆசியாவின் டெவலப்பர் ecosystem எப்போதும் adoption-ல் வேகமாக நகர்ந்துள்ளது, ஆனால் இங்கே structural conditions looping paradigm-ஐ குறிப்பாக பொருத்தமாக்குகிறது. Southeast Asia, India, மற்றும் East Asia-ல் engineering talent வேகமாக வளர்ந்து வருகிறது, ஆனால் senior engineering hours கட்டமைக்க வேண்டிய software-ன் அளவுடன் ஒப்பிடும்போது महंगा மற்றும் அரிதாக உள்ளது. ஒரு background agent தொடர்ந்து உங்கள் codebase-ஐ refactor செய்கிறது, duplicated abstractions-ஐ பிடிக்கிறது, மற்றும் கேட்காமல் PRs-ஐ சமர்ப்பிக்கிறது — அது ஒரு productivity multiplier அல்ல, இது ஒரு small team பராமரிக்க முடியும் என்பதில் structural change.

Jakarta அல்லது Ho Chi Minh City-ல் ஒரு five-person startup ஒரு fintech product-ஐ ship செய்கிறது என்று கருதுங்கள். அவர்கள் ஒரு codebase-ஐ கையாளுகிறார்கள் அது அவர்களின் team-ஐ review செய்ய முடியும் என்பதை விட வேகமாக வளர்ந்து வருகிறது. Technical debt accumulate ஆகிறது யாரும் அலட்சியமாக இருப்பதால் அல்ல, ஆனால் போதுமான hours இல்லாதிருப்பதால். Cherny விவரித்த வகையான ஒரு persistent refactoring agent பின்னணியில் இயங்குகிறது — அது சரியாக அந்த constraint-ஐ address செய்கிறது. இது engineers-ஐ replace செய்யாது; இது engineers எப்போதும் defer செய்யும் வேலையின் வகையை handle செய்கிறது.

ஆசியாவுக்கு குறிப்பாக முக்கியமான ஒரு language dimension உள்ளது. AI agent ecosystem-ல் பெரும்பாலான tooling மற்றும் documentation English-first. Loops, அவற்றின் இயல்பு மூலம், மிகவும் abstract — அவை code level-ல் செயல்படுகின்றன, இங்கே language barriers குறைவாக முக்கியமாக உள்ளது. உங்கள் TypeScript அல்லது Python architecture-ஐ மேம்படுத்தும் ஒரு agent Bahasa Indonesia அல்லது Mandarin-ஐ புரிந்து கொள்ள வேண்டியதில்லை அதன் வேலையை செய்ய. அது looping agents-ஐ natural language understanding-ஐ சார்ந்திருக்கும் பல AI capabilities-ஐ விட Asian development teams-க்கு மிகவும் உடனடியாக அணுகக்கூடியதாக்குகிறது.

Asia tech scene-ம் multi-agent architectures-ஐ பরீட்சை செய்ய பெரும்பாலான இடங்களை விட வேகமாக இருந்துள்ளது, குறிப்பாக enterprise automation-ல். MonstarX போன்ற platforms-ல் கட்டமைக்கும் companies ஏற்கனவே agents-ஐ பற்றி சிந்திக்கிறார்கள் அவை ஒன்றுடன் ஒன்று coordinate செய்கின்றன, single-model inference அல்ல. Loop concept அந்த mental model-ல் naturally slot செய்கிறது — agentic workflows-ஐ ஏற்கனவே செயல்படுத்தும் teams-க்கு இது குறைவான conceptual jump.

நிச்சயமாக, risk என்னவென்றால் sufficient oversight இல்லாமல் இயங்கும் loops errors-ஐ improvements-ஐ போல் compound செய்ய முடியும். ஒரு agent என்ன ஒரு நல்ல abstraction என்பது பற்றி தவறாக இருந்தால் அது forever, scale-ல் தவறாக இருக்கும். அந்த governance challenge உண்மையான, மற்றும் இது ஆசிய teams-ஐ deliberately சிந்திக்க வேண்டிய ஒன்று இந்த patterns-ஐ adopt செய்யும்போது.

டெவலப்பர்களுக்கு இது என்ன அர্த்தம்

நீங்கள் இன்று AI-ஐ கொண்டு கட்டமைக்கிறீர்கள் என்றால், loops system செய்யும் என்பது பற்றி உங்கள் mental model-ஐ மாற்றுகிறது. நீங்கள் ஒரு prompt-ஐ அனுப்பி response-க்கு காத்திருக்கிறீர்கள் அல்ல. நீங்கள் ஒரு persistent process-ஐ configure செய்கிறீர்கள் — ஒன்று goals உள்ளது, முடிவுகளை செய்கிறது, மற்றும் ongoing basis-ல் outputs-ஐ உற்பத்தி செய்கிறது. அது ஒரு contractor-ஐ hire செய்வதற்கு closer ஒரு query-ஐ run செய்வதை விட.

நடைமுறையில், இது உங்கள் build செய்வதற்கு என்ன அர்த்தம்:

• உங்கள் agents-ஐ tightly scope செய்யுங்கள். Cherny-ன் agents ஒவ்வொன்றும் ஒரு narrow, well-defined mandate உள்ளது — ஒன்று architecture improvements-ஐ தேடுகிறது, மற்றொன்று duplicated abstractions-ஐ. அவை எல்லாம் செய்யாது. Scope எவ்வளவு tighter, loop drift செய்ய வாய்ப்பு குறைவாக அது territory-க்கு அங்கு damage-ஐ cause செய்கிறது.
• Loop-ல் evaluation-ஐ build செய்யுங்கள். Ralph Loop செயல்படுகிறது ஏனெனில் இது model தனது progress-ஐ check செய்ய force செய்கிறது. நீங்கள் run செய்யும் எந்த loop-ம் ஒரு evaluation step உள்ளது baked in — அது ஒரு sub-agent, ஒரு test suite, அல்லது ஒரு human review gate PRs-க்கு ஒரு குறிப்பிட்ட complexity threshold-க்கு மேல்.
• Loop outputs-ஐ contributor PRs-ஐ போல் treat செய்யுங்கள். Cherny-ன் agents pull requests-ஐ submit செய்கிறது. அது சரியான abstraction. Auto-merge செய்யாதீர்கள். Loop outputs-ஐ review செய்யுங்கள் நீங்கள் ஒரு junior developer-ன் வேலையை review செய்வது போல் — change சரியாக உள்ளதா என்பதற்கு attention-ஐ கொண்டு, அது compile செய்கிறதா என்பது அல்ல.
• Read-only loops-ஐ கொண்டு தொடங்குங்கள். Agent write மற்றும் submit செய்ய அனுமதிப்பதற்கு முன், observation mode-ல் run செய்யுங்கள். அது flag செய்ய அனுமதிக்கவும் அது என்ன மாற்றம் செய்யும் உண்மையில் மாற்றம் செய்யாமல். அது உங்களுக்கு sense கொடுக்கிறது அதன் judgment trustworthy உள்ளதா என்பது write access-ஐ hand over செய்வதற்கு முன்.
• Drift-க்கு monitor செய்யுங்கள் நேரத்தின் மீது. ஒரு loop அது days அல்லது weeks-க்கு run செய்யக்கூடும் small errors accumulate செய்ய முடியும் அவை compound செய்கிறது. Logging-ஐ set up செய்யுங்கள் அது உங்களுக்கு audit செய்ய அனுமதிக்கிறது ஒரு loop என்ன செய்துவிட்டது, அது தற்போது செய்யும் என்பது அல்ல.

இதற்கான tooling இன்னும் maturing. பெரும்பாலான டெவலப்பர்கள் இன்று manually loops-ஐ stitch செய்கிறார்கள் — orchestration frameworks, custom evaluation scripts, மற்றும் நிறைய prompt engineering-ஐ பயன்படுத்தி. ஆனால் primitives-ஐ clearer ஆகிறது, மற்றும் platforms அவை persistent agent execution-ஐ support செய்கிறது proper state management-ஐ கொண்டு significantly மிகவும் valuable ஆகிறது இந்த pattern spread செய்யும்போது.

MonstarX-ஐ பயன்படுத்தும் teams-க்கு, looping agents-ஐ build செய்வது native support-ஐ பெறுகிறது state persistence மற்றும் agent orchestration-க்கு.