SigNoz ഹാക്കത്തോണിനായി നിർമ്മിച്ച പുതിയ ഒബ്സർവേബിലിറ്റി അധിഷ്ഠിത (observability-driven) വർക്ക്ഫ്ലോ de grâce, നാല് സ്വയംഭരണാധികാരമുള്ള (autonomous) AI ഏജന്റുകൾക്ക് ഇപ്പോൾ ഒരു സോഫ്റ്റ്വെയർ പിശക് കണ്ടെത്താനും, പ്രശ്നമുണ്ടാക്കുന്ന കോഡ് തിരുത്താനും, ആ പരിഹാരം ശരിയാണെന്ന് ഉറപ്പുവരുത്താനും ഒരു മിനിറ്റിൽ താഴെ സമയം മതിയാകും.
AgentOps എന്ന് വിളിക്കപ്പെടുന്ന ഈ സിസ്റ്റം, SigNoz-ൽ എറർ സ്പൈക്കുകൾക്കായി നിരീക്ഷിക്കുന്നു, പ്രസക്തമായ ലോഗുകളും (logs) ട്രേസുകളും (traces) ശേഖരിക്കുന്നു, പിശകിന് കാരണമായ കൃത്യമായ ഫയലും വരിയും കണ്ടെത്തുന്നു, ഒരു സാൻഡ്ബോക്സിൽ (sandbox) സോഴ്സ് കോഡ് തിരുത്തുന്നു, തുടർന്ന് ബഗ് മാറിക്കഴിഞ്ഞുവെന്ന് തെളിയിക്കുന്നതിനായി റിക്വസ്റ്റ് വീണ്ടും റീപ്ലേ ചെയ്യുന്നു. ഓരോ പൂർണ്ണ ചക്ലയും 30-60 സെക്കൻഡുകൾക്കുള്ളിൽ പൂർത്തിയാകുന്നു, കൂടാതെ മനുഷ്യന്റെ ഒരു നിർദ്ദേശവും (prompt) ഇല്ലാതെ തന്നെ ഈ പ്രക്രിയ നടക്കുന്നു.
AI ഏജന്റുകൾക്ക് ഒബ്സർവേബിലിറ്റി (observability) പ്രധാനമാകുന്നത് എന്തുകൊണ്ട്
പരമ്പരാഗത SRE രീതികളിൽ ലോഗുകൾ, മെട്രിക്സുകൾ, ഡിസ്ട്രിബ്യൂട്ടഡ് ട്രേസുകൾ എന്നിവ ഒരു സർവീസിന്റെ കണ്ണുകളായിട്ടാണ് കണക്കാക്കുന്നത്. ഒരു റിക്വസ്റ്റ് പരാജയപ്പെടുമ്പോൾ, ഒരു എഞ്ചിനീയർ ആ പിശക് എവിടെയാണെന്ന് കണ്ടെത്താൻ ട്രേസ് പിന്തുടരുന്നു. ഇതേ തത്വം തന്നെയാണ് ഇപ്പോൾ AgentOps-നും ഉപയോഗിക്കുന്നത്, എന്നാൽ ഇവിടെ നിരീക്ഷിക്കപ്പെടുന്ന "സർവീസ്" എന്നത് ആ AI ഏജന്റ് തന്നെയാണ്.
ഏജന്റ് ഉപയോഗിക്കുന്ന ഓരോ ടൂളും—അത് ഒരു ലാംഗ്വേജ് മോഡൽ കോൾ ആകട്ടെ, ഫയൽ സിസ്റ്റം എഡിറ്റ് ആകട്ടെ അല്ലെങ്കിൽ ഒരു ടെസ്റ്റ് റണ്ണർ ആകട്ടെ—ട്രേസിൽ ഒരു സ്പാൻ (span) സൃഷ്ടിക്കുന്നു. ഒരു സ്പാൻ അതിന്റെ ആരംഭ സമയം, ദൈർഘ്യം, വിജയ നില എന്നിവ രേഖപ്പെടുത്തുന്നു, അതിനാൽ ഓരോ ചിന്താ പ്രക്രിയയ്ക്കും (reasoning step) എത്ര സമയം എടുത്തു എന്നും അത് വിജയിച്ചോ എന്നും ഏജന്റിന് കാണാൻ കഴിയും. ഈ സ്പാനുകൾ ഒന്നിച്ച് ചേർക്കുന്നതിലൂടെ, ഒരു മനുഷ്യൻ മാനുവലായി ഡീബഗ് ചെയ്യുമ്പോൾ ചെയ്യുന്നത് പോലെ, ഏജന്റിന് അതിന്റെ സ്വന്തം ചിന്താ പ്രക്രിയയുടെ പൂർണ്ണരൂപം മനസ്സിലാക്കാൻ സാധിക്കുന്നു.
"റിപ്പോർട്ടിംഗ് ലെയർ എന്ന നിലയിലുള്ള ഒബ്സർവേബിലിറ്റി" എന്നതിൽ നിന്ന് "കാഴ്ചപ്പാട് (perception) എന്ന നിലയിലുള്ള ഒബ്സർവേബിലിറ്റി" എന്നതിലേക്കുള്ള മാറ്റമാണ് ഇവിടെ പ്രധാനപ്പെട്ടത്. AgentOps ട്രേസ് ഡാറ്റ ഏജന്റുകളിലേക്ക് തന്നെ തിരികെ നൽകുന്നു, ഇത് തത്സമയം സ്വന്തം പ്രവർത്തനങ്ങളെക്കുറിച്ച് ചിന്തിക്കാൻ അവരെ അനുവദിക്കുന്നു. ഇതിന്റെ ഫലമായി, AI ഒരു അനുമാനം (hypothesis) രൂപീകരിക്കുക മാത്രമല്ല, പ്രശ്നം കണ്ടെത്താൻ ഉപയോഗിച്ച അതേ ടെലിമെട്രി (telemetry) ഉപയോഗിച്ച് അത് ശരിയാണോ എന്ന് പരിശോധിക്കുകയും ചെയ്യുന്നു.
നാല് ഘട്ടങ്ങളുള്ള വർക്ക്ഫ്ലോ
- Monitor (നിരീക്ഷിക്കുക) – പുതിയതായി റിപ്പോർട്ട് ചെയ്യപ്പെട്ട പിശകുകൾക്കായി ഒരു ലൈറ്റ് വെയ്റ്റ് വാച്ചർ SigNoz പരിശോധിക്കുന്നു.
- Diagnose (നിർണ്ണയിക്കുക) – ഏജന്റ് ബന്ധപ്പെട്ട ലോഗുകളും ട്രേസുകളും ശേഖരിക്കുന്നു, സ്റ്റാക്ക് എക്സ്ട്രാക്റ്റ് ചെയ്യുന്നു, കൂടാതെ പിശകിന് കാരണമായ ഫയലും വരിയും വേർതിരിച്ചറിയുന്നു.
- Fix (പരിഹരിക്കുക) – ഒരു സാൻഡ്ബോക്സ്ഡ് ഫയൽ സിസ്റ്റം സെർവർ ഉപയോഗിച്ച്, ഏജന്റ് കണ്ടെത്തിയ വരിയിൽ ഒരു പാച്ച് (patch) എഴുതുന്നു. സാൻഡ്ബോക്സ് കർശനമായ അനുമതികൾ നടപ്പിലാക്കുകയും, എഡിറ്റ് പോളിസി ലംഘിക്കുകയാണെങ്കിൽ സ്വയമേവ പഴയ അവസ്ഥയിലേക്ക് മടങ്ങുകയും (roll back) ചെയ്യുന്നു.
- Verify (സ്ഥിരീകരിക്കുക) – പാച്ച് ചെയ്ത കോഡിൽ ഏജന്റ് യഥാർത്ഥ റിക്വസ്റ്റ് വീണ്ടും അയക്കുന്നു. ട്രേസ് പരിശോധിക്കുമ്പോൾ പ്രശ്നമില്ലെങ്കിൽ, പരിഹാരം സ്ഥിരീകരിക്കുന്നു; അല്ലെങ്കിൽ ഏജന്റ് വീണ്ടും ശ്രമിക്കുന്നു.
എല്ലാ ഘട്ടങ്ങളും ഒരേ ഏജന്റുകൾ തന്നെ നിയന്ത്രിക്കുന്നു, ഓരോന്നും സ്വയംഭരണാധികാരമുള്ള ഒരു മൈക്രോ സർവീസ് ആയി പ്രവർത്തിക്കുന്നു. ഈ മുഴുവൻ പ്രക്രിയയും OpenTelemetry-യുമായി പൊരുത്തപ്പെടുന്ന സ്പാനുകളിലൂടെ നിരീക്ഷിക്കാൻ സാധിക്കും, ഇവ SigNoz സ്വീകരിക്കുകയും ദൃശ്യവൽക്കരിക്കുകയും ചെയ്യുന്നു.
വിശ്വാസ്യതയെക്കുറിച്ചുള്ള പാഠങ്ങൾ
പിശകുകളുടെ വ്യക്തത (Error clarity)
വെറുമൊരു "failed" എന്ന സ്റ്റാറ്റസ് കൊണ്ട് കാര്യമില്ല. "തെറ്റായ അനുമാനം" അല്ലെങ്കിൽ "പാച്ച് പ്രക്രിയയെ തടസ്സപ്പെടുത്തി" എന്നിങ്ങനെയുള്ള കൃത്യമായ കാരണങ്ങൾ ടീം ഇതിൽ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്. ഇതുവഴി അടുത്ത ഘട്ടത്തിലുള്ള ഏജന്റുകൾക്ക് വീണ്ടും ശ്രമിക്കണോ, പിന്നോട്ട് പോകണോ അതോ നിർത്തണോ എന്ന് തീരുമാനിക്കാൻ കഴിയും. മനുഷ്യർ നടത്തുന്ന പോസ്റ്റ്-മോർട്ടം (post-mortem) വിശകലനങ്ങളിലെ രീതിയാണിത്.
ഡാറ്റാ ലേറ്റൻസി (Data latency)
ടെലിമെട്രി വിവരങ്ങൾ ഉടനടി ലഭ്യമാകണമെന്നില്ല. അതിനാൽ, ഒരു പരിഹാരം ഉറപ്പിച്ചു പറയുന്നതിന് മുമ്പ് ആവശ്യമായ ലോഗുകൾ ലഭിച്ചുവെന്ന് ഉറപ്പാക്കാൻ ഏജന്റുകൾ ഇപ്പോൾ ചെറിയൊരു ഇടവേളയും പരിശോധനയും (sanity check) നടത്തുന്നു. ഈ മുൻകരുതൽ ഇല്ലെങ്കിൽ, അപൂർണ്ണമായ ഡാറ്റ ഉപയോഗിച്ച് ഏജന്റ് തെറ്റായ തീരുമാനങ്ങൾ എടുക്കാൻ സാധ്യതയുണ്ട്.
സുരക്ഷാ പരിധികൾ (Security boundaries)
ഒരു AI-യെ കോഡ് എഴുതാൻ അനുവദിക്കുന്നത് സുരക്ഷാ ഭീഷണി ഉയർത്താം. അതിനാൽ, സാൻഡ്ബോക്സ് ഒരു പ്രത്യേക ഫയൽ സിസ്റ്റം സെർവർക്ക് പിന്നിലാണ് പ്രവർത്തിക്കുന്നത്. ഇത് കോഡ് മാറ്റാനുള്ള പരിധി നിശ്ചിത റെപ്പോസിറ്ററിയിൽ മാത്രമായി പരിമിതപ്പെടുത്തുകയും, ടെസ്റ്റ് പരാജയപ്പെട്ടാൽ സ്വയമേവ പഴയ അവസ്ഥയിലേക്ക് മടങ്ങുകയും ചെയ്യുന്നു. ഈ രീതി AI-യുടെ പ്രവർത്തനങ്ങളെ നിയന്ത്രണത്തിലാക്കുന്നു.
ടോക്കൺ പരിധികൾ (Token limits)
ലാർജ് ലാംഗ്വേജ് മോഡലുകൾ API ടോക്കണുകൾ ഉപയോഗിക്കുന്നു, അന്വേഷണത്തിനിടയിൽ തന്നെ ദിവസേനയുള്ള ക്വാട്ട തീരാൻ സാധ്യതയുണ്ട്. ഓരോ സംഭവത്തിലും എത്ര ടോക്കൺ ഉപയോഗിക്കുന്നു എന്ന് AgentOps നിരീക്ഷിക്കുന്നു, നിശ്ചിത പരിധിയിൽ എത്തുമ്പോൾ കൂടുതൽ കോളുകൾ നിയന്ത്രിക്കുന്നു. ഇത് ക്വാട്ട തീർന്നുപോകുമ്പോൾ ഉണ്ടാകാൻ സാധ്യതയുള്ള പരാജയങ്ങൾ ഒഴിവാക്കാൻ സഹായിക്കുന്നു.
ഡെമോ തെളിയിച്ചത്
കോഡ്ബേസിൽ ഇതുവരെ ഉണ്ടായിട്ടില്ലാത്ത ഒരു പുതിയ ബഗ് ടീം മനഃപൂർവ്വം ഉൾപ്പെടുത്തി. AgentOps ആ വ്യതിയാനം കണ്ടെത്തി, കൃത്യമായ വരിയിലേക്ക് അത് ട്രാസ് ചെയ്തു, തിരുത്തൽ നിർദ്ദേശിച്ചു, സാൻഡ്ബോക്സിൽ പാച്ച് പ്രയോഗിച്ചു, ഒടുവിൽ റിക്വസ്റ്റ് വിജയിച്ചുവെന്ന് ഉറപ്പുവരുത്തി—ഇതെല്ലാം യാതൊരുവിധ മാനുവൽ കോഡ് മാറ്റങ്ങളോ പുതിയ പ്രോംപ്റ്റുകളോ ഇല്ലാതെ തന്നെ നടന്നു. ഇതിനായി എടുത്ത സമയം ഒരു മിനിറ്റിൽ താഴെയായിരുന്നു, ഇത് റിപ്പോർട്ട് ചെയ്ത 30-60 സെക്കൻഡ് എന്ന സമയവുമായി പൊരുത്തപ്പെടുന്നു.
ഒരു വിയോജിപ്പ്: സ്വയംഭരണാധികാരം (autonomy) എല്ലാ പ്രശ്നങ്ങൾക്കും പരിഹാരമല്ല
ഇനി ശ്രദ്ധിക്കേണ്ട കാര്യങ്ങൾ
- മോഡൽ-അജ്ഞാത ടെലിമെട്രി (Model-agnostic telemetry) – കൂടുതൽ വെണ്ടർമാർ OpenTelemetry-അനുയോജ്യമായ സ്പാനുകൾ (spans) ലഭ്യമാക്കുമ്പോൾ, ഈ സമീപനം വെണ്ടർ-നിഷ്പക്ഷമായി മാറാനും വൈവിധ്യമാർന്ന സ്റ്റാക്കുകളിൽ (heterogeneous stacks) ഇത് നടപ്പിലാക്കുന്നത് എളുപ്പമാക്കാനും സാധ്യതയുണ്ട്.
- പോളിസി അധിഷ്ഠിത ഗാർഡ്റെയിലുകൾ (Policy-driven guardrails) – ഏത് ഫയലുകൾ ഒരു ഏജന്റിന് എഡിറ്റ് ചെയ്യാമെന്നോ, അല്ലെങ്കിൽ ഒരു കമ്മിറ്റിന് മുമ്പ് ഏത് ടെസ്റ്റ് സ്യൂട്ടുകൾ പാസ് ചെയ്യണമെന്നോ നിശ്ചയിക്കുന്ന കോൺഫിഗറബിൾ പോളിസികൾ ഉൾപ്പെടുത്തുന്നത് ഗവേണൻസ് സംബന്ധമായ ആശങ്കകൾ പരിഹരിക്കും.
- ചെലവ് അറിഞ്ഞുകൊണ്ടുള്ള ടോക്കൺ ബജറ്റിംഗ് (Cost-aware token budgeting) – സംഭവത്തിന്റെ തീവ്രത അനുസരിച്ചുള്ള ഡൈനാമിക് ടോക്കൺ അലോക്കേഷൻ, ക്വാട്ട തീർന്നുപോകുന്നത് തടയുന്നതോടൊപ്പം തന്നെ ഉയർന്ന സ്വാധീനമുള്ള ബഗുകൾ കൈകാര്യം ചെയ്യാനുള്ള ശേഷിയും നിലനിർത്തും.
AgentOps കാണിക്കുന്നത് ബഗ് ഫിക്സ് സൈക്കിളിന് 30-60 സെക്കൻഡ് വരെ എടുക്കുമെന്നാണ്. ഓബ്സർവബിലിറ്റി (observability) സ്വയംഭരണാധികാരമുള്ള സോഫ്റ്റ്വെയർ അസിസ്റ്റന്റുകൾക്ക് ഉപയോഗിക്കാമെന്നതിന്റെ ഒരു പ്രൂഫ്-ഓഫ്-കോൺസെപ്റ്റ് ഈ പരീക്ഷണം തെളിയിക്കുന്നു.