મેં પહેલાં વિચારતો હતો કે AI એજન્ટ બનાવવો એ મૂળભૂત રીતે ચેટબોટને પ્રોમ્પ્ટ આપવા જેવું જ છે. તમે પ્રશ્ન સારી રીતે પૂછો છો, મોડેલ જવાબ આપે છે, અને તમારું કામ પૂરું થઈ જાય છે. પછી મેં કેટલાક એપ્લિકેશન્સ લોન્ચ કર્યા. વાસ્તવિકતાનો સામનો કરવો પડ્યો. એક LLM એ એજન્ટ નથી. એક LLM માત્ર આગામી ટોકનનું અનુમાન લગાવે છે. લૂપ (loop) એ એજન્ટ બનાવે છે.

ચા બનાવવાનું વિચારો. તમે make_tea() નામનો એક સિંગલ કમાન્ડ આપો અને પછી જતી રહો તેવું નથી થતું. તમે કેટલ ભરો છો, તમને સમજાય છે કે નળનું દબાણ ઓછું છે, તમે રાહ જુઓ છો, તેને ચાલુ કરો છો, જુઓ છો કે સ્વિચ બગડેલી છે, બીજા બર્નર પર જાઓ છો, વરાળ તપાસો છો, રેડો છો, ચાખો છો, અને કદાચ મધ ઉમેરો છો કારણ કે ચાની પત્તીઓ વધુ સમય સુધી પલળેલી રહી હતી. ધ્યેય ક્યારેય બદલાતો નથી, પરંતુ પગલાં બદલાય છે. તમે અવલોકન કરો છો, સુધારો કરો છો અને ફરી પ્રયાસ કરો છો. AI એજન્ટ્સ બરાબર આ રીતે જ કામ કરે છે.

એજન્સી (Agency) બનાવતું ચક્ર

લૂપ એ કોઈ અમૂર્ત સિદ્ધાંત નથી. તે તમારા વતી કાર્ય કરતી કોઈપણ સિસ્ટમનું કાર્યકારી હૃદય છે. વ્યવહારમાં તે ખરેખર આવું દેખાય છે:

  • Think: મોડેલ ધ્યેય વિશે વિચારે છે અને નક્કી કરે છે કે તેને શું જોઈએ છે. એક યુઝર પૂછે છે, "શું મારે આવતીકાલે પોર્ટલેન્ડમાં છત્રી લેવી જોઈએ?" મોડેલ ઓળખે છે કે તેને હવામાનની આગાહી અને લોકેશનની જરૂર છે.
  • Act: મોડેલ એક ટૂલનો ઉપયોગ કરે છે. તે "Portland" ને ઉકેલવા માટે geocoding API ને કોલ કરી શકે છે, અને પછી કોઓર્ડિનેટ્સ સાથે વેધર એન્ડપોઇન્ટ (weather endpoint) પર જાય છે.
  • Observe: મોડેલ ટૂલનું આઉટપુટ વાંચે છે. શું API એ JSON આગાહી, 403 એરર, અથવા HTML મેન્ટેનન્સ પેજ આપ્યું?
  • Update: જે કંઈ તે જુએ તેના આધારે, મોડેલ તેની યોજનામાં સુધારો કરે છે. જો જિયોકોડરે Portland, Oregon ને બદલે Portland, Maine આપ્યું હોય, તો મોડેલે તેને સ્પષ્ટ કરવાની જરૂર છે. જો API ડાઉન હોય, તો તે બેકઅપ સોર્સ પર જઈ શકે છે અથવા યુઝરને પૂછી શકે છે.
  • Think Again: નવા સંદર્ભ (context) સાથે ચક્ર ફરી શરૂ થાય છે.

આ પાંચ અલગ-અલગ ફંક્શન્સ નથી જે તમે એકવાર લખો અને ભૂલી જાઓ. તે એક સતત એન્જિન છે જે ધ્યેય પ્રાપ્ત થાય ત્યાં સુધી અથવા કોઈ અચાનક અટકાવ (hard stop) આવે ત્યાં સુધી ચાલતું રહે છે. મોડેલ સ્ક્રિપ્ટની જેમ કોડ એક્ઝિક્યુટ નથી કરી રહ્યું. તે વિશ્વની સ્થિતિ વિશે વિચારી રહ્યું છે, એક ક્રિયા પસંદ કરી રહ્યું છે, તેના પરિણામને વાંચી રહ્યું છે, અને આગળ શું કરવું તે નક્કી કરી રહ્યું છે. આ એક ભવ્ય 'ઓટોકમ્પ્લીટ' (autocomplete) અને કામ પૂરું કરનાર એજન્ટ વચ્ચેનો તફાવત છે.

બધા ફ્રેમવર્ક એકસરખા કેમ લાગે છે

જો તમે LangGraph, CrewAI, અથવા AutoGen સાથે સમય વિતાવ્યો હોય, તો તમે કદાચ નોંધ્યું હશે કે તેઓ એકબીજામાં ભળી જાય છે. LangGraph ફ્લોને નોડ્સ (nodes) અને એજિસ (edges) ના સતત ગ્રાફ તરીકે મોડેલ કરે છે. CrewAI એજન્ટ્સને ભૂમિકાઓ (roles) અને ક્રૂઝ (crews) માં ગોઠવે છે. AutoGen મલ્ટી-એજન્ટ વાતચીતોનું સંચાલન કરે છે. પેકેજિંગ અલગ છે, પણ હાડપિંજર (skeleton) સમાન છે.

તેઓ સમાન લાગે છે કારણ કે તેઓ બધા આ જ લૂપિંગ સિદ્ધાંત પર એન્જિનિયર્ડ કરવામાં આવ્યા છે. LangGraph સ્પષ્ટપણે ટૂલ કોલ્સ અને મોડેલ ઇન્ફરન્સ વચ્ચેના સ્ટેટ ટ્રાન્ઝિશન (state transitions) તરીકે ચક્રને સ્ટ્રક્ચર કરે છે. CrewAI લૂપને રોલ-આધારિત એજન્ટ્સમાં લપેટી દે છે, પરંતુ દરેક ક્રૂ મેમ્બર હજુ પણ પ્લાનિંગ, એક્ટિંગ અને ઓબ્ઝર્વિંગના ચક્રમાંથી પસાર થાય છે. AutoGen એક્ટર્સ વચ્ચે મેસેજની આપ-લે કરે છે, છતાં દરેક ટર્ન હજુ પણ જનરેટ, એક્ઝિક્યુટ, રિફ્લેક્ટ અને રૂટનું વેરિએશન છે.

આ ફ્રેમવર્ક લૂપ પર ધ્યાન કેન્દ્રિત કરે છે કારણ કે ત્યાં જ એજન્સી રહેલી છે. અન્ડરલાઇંગ મોડેલ GPT-4, Claude, અથવા ફાઇન-ટ્યુન કરેલું ઓપન-વેઇટ મોડેલ હોઈ શકે છે. લૂપ વગર, તમારી પાસે ખૂબ જ મોંઘું વાક્ય પૂરું કરનાર (sentence completer) સાધન છે. લૂપ સાથે, તમારી પાસે એવી સિસ્ટમ છે જે અનેક પ્રયાસો દ્વારા એક લક્ષ્ય તરફ આગળ વધી શકે છે.

જ્યારે સાચું કામ શરૂ થાય છે

લોકલ ડેમો જાદુઈ લાગે છે. પ્રોડક્શન એ જગ્યા છે જ્યાં જાદુ અને અસ્તવ્યસ્તતાનો સામનો થાય છે. એકવાર તમે પ્રોટોટાઇપિંગથી આગળ વધો, પછી તમે AI સમસ્યાઓ ઉકેલવાનું બંધ કરો છો અને સિસ્ટમ્સ એન્જિનિયરિંગની સમસ્યાઓ ઉકેલવાનું શરૂ કરો છો.

ટૂલની નિષ્ફળતા અનિવાર્ય છે. APIs ટાઈમ આઉટ થાય છે. તેઓ ખોટી રીતે બનાવેલ (malformed) JSON રિટર્ન કરે છે. તેઓ HTML માં લપેલી 500 એરર્સ આપે છે. જો તમારું લૂપ દરેક ટૂલના આઉટપુટ પર આંધળો વિશ્વાસ કરે છે, તો તમારો એજન્ટ સફળતાના ભ્રમ (hallucinate) પેદા કરશે અથવા મૂંઝવણમાં ફસાઈ જશે. તમારે દરેક રિટર્ન પેલોડ પર રીટ્રાય લોજિક (retry logic), સર્કિટ બ્રેકર્સ (circuit breakers) અને સ્કીમા વેલિડેશન (schema validation) ની જરૂર છે.

મેમરી જૂની (stale) થઈ જાય છે. તમારો એજન્ટ યાદ રાખે છે કે યુઝરની પસંદગીનું ડેટાબેઝ PostgreSQL છે, પરંતુ ઇન્ફ્રાસ્ટ્રક્ચર ટીમે ગઈકાલે રાત્રે નવા ક્લસ્ટર પર માઈગ્રેટ કર્યું છે. સંદર્ભ (context) ને રિફ્રેશ કરવા અથવા એક્સપાયર કરવા માટેની પદ્ધતિ વિના, એજન્ટ આત્મવિશ્વાસ સાથે ડેડ એન્ડપોઇન્ટ્સ સામે કમાન્ડ આપશે. મેમરીને ટાઈમસ્ટેમ્પ, કોન્ફિડન્સ સ્કોર્સ અને પોતાની જાતને અમાન્ય (invalidate) કરવાની ક્ષમતાની જરૂર છે.

ઇન્ફિનાઇટ લૂપ્સ (Infinite loops) શાંત હત્યારા છે. એક એજન્ટ વેબ પર સર્ચ કરે છે, કંઈપણ ઉપયોગી મળતું નથી, ક્વેરીમાં થોડો સુધારો કરે છે, ફરીથી સર્ચ કરે છે, કંઈ મળતું નથી, અને આ પ્રક્રિયાનું પુનરાવર્તન કરે છે. મહત્તમ ઇટરેશન સીલિંગ (maximum iteration ceiling) અથવા સેમેન્ટિક ડુપ્લીકેટ ડિટેક્શન વિના, યુઝર રાહ જોતો રહેશે અને તે ટોકન્સ તથા પૈસા બરબાદ કરશે. તમારે ગાર્ડરેલ્સ (guardrails) બનાવવા પડશે: રીટ્રાય પર કડક મર્યાદા, ડાઇવર્જન્સ ચેક્સ (divergence checks) અને હ્યુમન એસ્કેલેશન પાથ (human escalation paths).

અપ્રસ્તુત ડેટા તર્કને ડૂબાડી દે છે. Retrieval-Augmented Generation પાઇપલાઇન્સ ઘણીવાર context window માં અસ્પષ્ટ રીતે સંબંધિત દસ્તાવેજોના પચાસ ફકરાઓ ઠાંસી દે છે. એજન્ટ આ બિનજરૂરી માહિતીમાં અટવાઈ જાય છે અને ખોટું સાધન પસંદ કરે છે અથવા પેરામીટર વિશે ભ્રમ પેદા કરે છે. મોડેલ દ્વારા મેળવેલ ટેક્સ્ટ જોવામાં આવે તે પહેલાં તમારે ફિલ્ટરિંગ, રેન્કિંગ અને સંક્ષિપ્ત સારાંશની જરૂર છે.

એક એજન્ટને માત્ર બુદ્ધિ કરતાં વધુની જરૂર છે. તેને એક સિસ્ટમની જરૂર છે: managed memory, explicit state tracking, કડક guardrails, અને observable telemetry. મોડેલ જેટલું સારું હશે, તેની આસપાસની સિસ્ટમ પણ તેટલી જ સારી હોવી જોઈએ. એક નબળા લૂપની અંદર રહેલું શક્તિશાળી મોડેલ માત્ર વધુ સ્પષ્ટ નિષ્ફળતાઓ જ પેદા કરે છે.

કામ પૂર્ણ કરવું

એજન્ટ્સમાં સાચી બુદ્ધિ એ પ્રથમ જવાબ આપવા વિશે નથી. તે જ્યારે કંઈપણ યોજના મુજબ ન ચાલતું હોય ત્યારે ઈરાદા અને પરિણામ વચ્ચેના અંતરને કેવી રીતે પાર કરવું તે વિશે છે. પ્રથમ પ્રયાસ સરળ છે. કોઈપણ happy path સ્ક્રિપ્ટ કરી શકે છે. અઘરો ભાગ ચોથું iteration છે, જ્યારે primary API બંધ હોય, context window ઘટી રહી હોય, વપરાશકર્તા અધીરો થઈ રહ્યો હોય અને એજન્ટને હજુ પણ કંઈક ઉપયોગી આપવાની જરૂર હોય.

આ મક્કમતા જ એક demo ને product થી અલગ પાડે છે. તે દરેક પગલા પરથી શીખવાની ક્ષમતા છે, real time માં model weights અપડેટ કરીને નહીં, પરંતુ યોજના અપડેટ કરીને. જ્યારે tactics બદલાય છે ત્યારે એજન્ટ લક્ષ્યને સ્થિર રાખે છે. આ જ looping principleનું કાર્ય છે.

તો શું ભવિષ્ય મોટા મોડેલ્સનું છે કે પછી વધુ સારા execution loops નું? Scale ચોક્કસપણે મદદ કરે છે. વધુ સક્ષમ મોડેલ દરેક સાયકલની અંદર વધુ સારી રીતે તર્ક કરે છે. પરંતુ એક tight, observable અને resilient લૂપની અંદર ચાલતું નાનું મોડેલ લગભગ હંમેશા એવા વિશાળ મોડેલ કરતા વધુ સારું પ્રદર્શન કરશે જેને બધું જ single shot માં ઉકેલવાનું કહેવામાં આવ્યું હોય. લૂપ જ અનુમાનને ક્રિયામાં ફેરવે છે. ત્યાં રોકાણ કરો.

સ્ત્રોત: The Looping Principle: A Simple Mental Model for Understanding AI Agents

આ પ્રકારની વધુ ચર્ચાઓ માટે, Telegram પર GyaanSetu લર્નિંગ કોમ્યુનિટીમાં જોડાઓ.