Claude Code 2.1.212 ഉപയോഗിച്ച് ഒരു AI സെഷനിൽ എത്രത്തോളം സബ്-ഏജന്റുകളെയും (sub-agents) വെബ് സെർച്ചുകളെയും (web searches) ഉപയോഗിക്കാമെന്നതിന് കർശനമായ പരിധികൾ നിശ്ചയിക്കാൻ ഇപ്പോൾ ഡെവലപ്പർമാർക്ക് സാധിക്കും. ഇത് അനിയന്ത്രിതമായ ചിലവുകൾ തടയാൻ സഹായിക്കുന്നു.
ഈ അപ്ഡേറ്റിലൂടെ രണ്ട് കോൺഫിഗറബിൾ ക്യാപ്പുകൾ (configurable caps) ചേർത്തിരിക്കുന്നു - ഒന്ന് സബ്-ഏജന്റ് സ്പോണുകൾക്കും (sub-agent spawns) മറ്റൊന്ന് വെബ്-സെർച്ച് കോളുകൾക്കുമാണ്. ഇവ രണ്ടും ഒരു സെഷന് 200 വീതം ആണ് ഡിഫോൾട്ട് ആയി നൽകിയിരിക്കുന്നത്. എൻവയോൺമെന്റ് വേരിയബിളുകൾ (environment variables) ഉപയോഗിച്ച് ഡെവലപ്പർമാർക്ക് ഈ സംഖ്യ കുറയ്ക്കാവുന്നതാണ്. കൂടാതെ, രണ്ട് മിനിറ്റിൽ കൂടുതൽ നീണ്ടുനിൽക്കുന്ന ഏതൊരു MCP (Model-Control-Plane) കോളും സ്വയമേവ ബാക്ക്ഗ്രൗണ്ടിലേക്ക് മാറ്റപ്പെടും, ഇത് ഒരു സാവധാനത്തിലുള്ള ടൂൾ കാരണം മുഴുവൻ വർക്ക്ഫ്ലോയും തടസ്സപ്പെടുന്നത് ഒഴിവാക്കുന്നു.
ഈ പരിധികൾ ഇപ്പോൾ പ്രധാനമാകുന്നത് എന്തുകൊണ്ട്
നിയന്ത്രണങ്ങളില്ലാതെ മറ്റ് ഏജന്റുകളെ വിളിക്കാനോ വെബ് സ്ക്രാപ്പ് ചെയ്യാനോ കഴിയുന്ന AI ഏജന്റുകൾ ഉപയോഗപ്രദമാണ്, എന്നാൽ അവ സാമ്പത്തികമായ വെല്ലുവിളികളും ഉയർത്തുന്നു. അവ്യക്തമായ ഒരു പ്രോംപ്റ്റ് (prompt) സബ്-ഏജന്റുകളുടെ ഒരു നിരയെ തന്നെ ഉണർത്തുകയും, അവ ഓരോന്നും ടോക്കണുകൾ ഉപയോഗിക്കുകയും ബാഹ്യ ടൂളുകളെ വിളിക്കുകയും ചെയ്തേക്കാം. ഇതിന്റെ ഫലമായി, ആരും ശ്രദ്ധിക്കുന്നതിന് മുമ്പ് തന്നെ വലിയൊരു ബില്ല് വരാൻ സാധ്യതയുണ്ട്. പ്രായോഗികമായി ടീമുകൾ റിപ്പോർട്ട് ചെയ്ത കാര്യങ്ങൾ ഇവയാണ്:
- യഥാർത്ഥ ടാസ്ക് ബജറ്റിനേക്കാൾ വളരെ വലിയ തോതിലുള്ള അപ്രതീക്ഷിത ടോക്കൺ ചിലവ്.
- ഒരേസമയം പ്രവർത്തിക്കുന്ന സബ്-ഏജന്റുകൾ പരസ്പരം എഡിറ്റുകളിൽ ഇടപെടുന്നത് മൂലം വൈരുദ്ധ്യങ്ങൾ നിറഞ്ഞ ഫലങ്ങൾ ഉണ്ടാകുന്നു.
- കൂട്ടിച്ചേർക്കാൻ പ്രയാസമുള്ള അസംപൂർണ്ണ ഔട്ട്പുട്ടുകളുടെ വലിയ നിര.
- സാവധാനത്തിൽ പ്രവർത്തിക്കുന്ന ബാഹ്യ ടൂളുകൾ കാരണം സെഷൻ മുഴുവൻ വൈകുന്നത്, ഒരു ചെറിയ ചോദ്യം പോലും മിനിറ്റുകൾ നീളുന്ന കാത്തിരിപ്പായി മാറുന്നു.
ഒരു കർശനമായ പരിധി (hard ceiling) നിശ്ചയിക്കുന്നതിലൂടെ, ചിലവുകൾ കുതിച്ചുയരുന്നതിന് മുമ്പ് സിസ്റ്റത്തെ നിർത്താൻ Claude Code സഹായിക്കുന്നു, അതേസമയം ഒരു മനുഷ്യന് പരിശോധിക്കാൻ കഴിയുന്ന ഭാഗികമായ ഉത്തരവും ഇത് നൽകുന്നു.
ക്യാപ്പുകൾ എങ്ങനെ നിശ്ചയിക്കാം
ഈ മൂന്ന് നിയന്ത്രണങ്ങളും എൻവയോൺമെന്റ് വേരിയബിളുകളായി ലഭ്യമാണ്:
export CLAUDE_CODE_MAX_SUBAGENTS_PER_SESSION=12 # default 200
export CLAUDE_CODE_MAX_WEB_SEARCHES_PER_SESSION=30 # default 200
export CLAUDE_CODE_MCP_AUTO_BACKGROUND_MS=120000 # 2 minutes
മിക്ക പര്യവേക്ഷണ ജോലികൾക്കും (exploratory work) ഡിഫോൾട്ട് മൂല്യങ്ങൾ മതിയാകും, എങ്കിലും ഓരോ ജോലിയുടെയും റിസ്ക് പ്രൊഫൈലിന് അനുസരിച്ച് ടീമുകൾക്ക് ഇവ കുറയ്ക്കാവുന്നതാണ്. ഈ റിലീസ് അറിയിച്ച ലേഖനം ചില നിർദ്ദേശങ്ങൾ നൽകുന്നുണ്ട്:
- Local bug fix: 0-2 സബ്-ഏജന്റുകൾ, 0-5 സെർച്ചുകൾ.
- PR review: 3-5 സബ്-ഏജന്റുകൾ, 0-10 സെർച്ചുകൾ.
- Incident investigation: 2-4 സബ്-ഏജന്റുകൾ, 10-25 സെർച്ചുകൾ.
- Broad architecture research: 1 സിന്തസൈസർ, 2-4 റിസർച്ചർമാർ, 20-40 സെർച്ചുകൾ.
ഇവ നിർബന്ധമായും പാലിക്കേണ്ട നിയമങ്ങളല്ല; ഡെവലപ്പർമാർക്ക് ഒരു അടിസ്ഥാനമായി (baseline) ഉപയോഗിക്കാനുള്ളതാണ്.
ഗുണദോഷങ്ങൾ (The trade-off)
ഏജന്റ് പ്രവർത്തനങ്ങൾക്ക് കർശനമായ പരിധി നിശ്ചയിക്കുന്നത് നല്ല രീതിയിലുള്ള ടാസ്ക് ഡിസൈനിന് പകരമാവില്ല. ഒരു പ്രശ്നം ഒരു സെഷനിൽ തീർക്കാൻ കഴിയാത്തത്ര വലുതാണെങ്കിൽ, അതിനെ വിവിധ ഘട്ടങ്ങളായി തിരിക്കുക, ഓരോ ഘട്ടത്തിനും ഒരു ബജറ്റ് നിശ്ചയിക്കുക, അടുത്ത ഘട്ടത്തിലേക്ക് പോകുന്നതിന് മുമ്പ് ഒരു മനുഷ്യന്റെ പരിശോധന (human checkpoint) ഉറപ്പാക്കുക എന്നതാണ് ശരിയായ രീതി. പരിമിതപ്പെടുത്തിയ ഒരു സിസ്റ്റം, ആവർത്തന ലൂപ്പുകളിൽ പണം പാഴാക്കുന്നതിന് പകരം, ബാക്കിയുള്ള ചോദ്യങ്ങൾ സഹിതം ഉപയോഗപ്രദമായ ഒരു ഭാഗിക ഫലം നൽകണം.
പരിധി വളരെ കർശനമാക്കുന്നത് ഒരു റിസ്ക് ആണ്; കാരണം ഒരു പരിഹാരത്തിൽ എത്തുന്നതിന് മുമ്പ് തന്നെ ഏജന്റ് പ്രവർത്തനം നിലച്ചുപോയേക്കാം, ഇത് ഡെവലപ്പർമാരെ ഉയർന്ന പരിധിയോടെ വീണ്ടും ജോലി ചെയ്യാൻ നിർബന്ധിതരാക്കും. ഈ അധിക പരിശ്രമം ചിലപ്പോൾ ബുദ്ധിമുട്ടായേക്കാം, എങ്കിലും നിയന്ത്രണമില്ലാത്ത ഒരു സെഷൻ വരുത്തിവെക്കുന്ന നഷ്ടം അതിനേക്കാൾ വളരെ കൂടുതലായിരിക്കും.
പ്രൊഡക്ഷനിലേക്ക് എത്തിക്കുന്നത് എങ്ങനെ
- ഒരു സ്റ്റേജിംഗ് എൻവയോൺമെന്റിൽ (staging environment) Claude Code 2.1.212-ലേക്ക് അപ്ഗ്രേഡ് ചെയ്യുക.
- ഒരു വർക്ക്ഫ്ലോ തിരഞ്ഞെടുക്കുക – ഉദാഹരണത്തിന്, PR റിവ്യൂ – കൂടാതെ ഒരു മിതമായ ബജറ്റ് നിശ്ചയിക്കുക.
- എത്ര സബ്-ഏജന്റുകൾ പ്രവർത്തിച്ചു, എത്ര വെബ് സെർച്ചുകൾ നടത്തി, രണ്ട് മിനിറ്റ് പരിധി പിന്നിട്ട ഏതെങ്കിലും MCP കോളുകൾ എന്നിവ രേഖപ്പെടുത്താൻ നിങ്ങളുടെ ലോഗുകൾ (logs) ക്രമീകരിക്കുക.
- പരിധിയിൽ എത്തുന്ന ഓരോ റണ്ണും പരിശോധിക്കുക. പരിധി നിശ്ചയിച്ചത് പണം ലാഭിച്ചോ അതോ യഥാർത്ഥ പുരോഗതിയെ തടഞ്ഞോ എന്ന് തീരുമാനിക്കുക, അതിനനുസരിച്ച് പരിധികൾ ക്രമീകരിക്കുക.
ഈ ക്യാപ്പുകൾ റൺടൈമിൽ (runtime) നടപ്പിലാക്കുന്നതിനാൽ, അവ ലോഗുകളിൽ ഉടൻ തന്നെ കാണാൻ സാധിക്കും. ഈ മെട്രിക്സുകൾ നിരീക്ഷിക്കുന്ന ടീമുകൾക്ക് ഒരു ഫീഡ്ബാക്ക് ലൂപ്പ് (feedback loop) ഉണ്ടാക്കിയെടുക്കാം: ഏജന്റിന് ജോലി പൂർത്തിയാക്കാൻ കഴിയാത്ത അവസ്ഥ വരുന്നത് വരെ ബജറ്റ് കുറയ്ക്കുക, തുടർന്ന് പ്രധാന ജോലി പൂർത്തിയാക്കാൻ ആവശ്യമായ രീതിയിൽ മാത്രം അത് വർദ്ധിപ്പിക്കുക.
ഇനി ശ്രദ്ധിക്കേണ്ട കാര്യങ്ങൾ
ഇത് തുടക്ക ഘട്ടത്തിലായതിനാൽ, ചിലവ് ലാഭിക്കുന്നതിനെക്കുറിച്ചുള്ള യഥാർത്ഥ വിവരങ്ങൾ പരിമിതമാണ്. ഈ ക്യാപ്പുകൾ നടപ്പിലാക്കുന്ന സ്ഥാപനങ്ങൾ താഴെ പറയുന്നവ നിരീക്ഷിക്കണം:
- മാറ്റത്തിന് മുമ്പും ശേഷവുമുള്ള സെഷൻ കണക്കാക്കിയ ചിലവ്.
- വിവിധ ബജറ്റ് നിലവാരത്തിലുള്ള ടാസ്ക്കുകളുടെ പൂർത്തീകരണ നിരക്ക്.
- ഏജന്റ് നേരത്തെ നിൽക്കുമ്പോഴും, അല്ലെങ്കിൽ പൂർണ്ണമായി പ്രവർത്തിക്കുമ്പോഴും ഉപയോക്താവിന്റെ തൃപ്തി.
ഈ ക്യാപ്പുകൾ ഫലപ്രദമാണെന്ന് തെളിഞ്ഞാൽ, വ്യവസായത്തിലുടനീളം ബജറ്റ് അവബോധമുള്ള (budget-aware) AI ഏജന്റുകൾക്കായി വലിയൊരു മാറ്റം നമുക്ക് കാണാൻ കഴിഞ്ഞേക്കും. പരിധികൾ വളരെ കർശനമാണെന്ന് ഡെവലപ്പർമാർക്ക് തോന്നിയാൽ, അടുത്ത പതിപ്പിൽ ഓരോ ടൂളിനും പ്രത്യേക ബജറ്റുകൾ അല്ലെങ്കിൽ ചിലവിനനുസരിച്ചുള്ള ഡൈനാമിക് സ്കെയിലിംഗ് (dynamic scaling) പോലുള്ള കൂടുതൽ സൂക്ഷ്മമായ നിയന്ത്രണങ്ങൾ കൊണ്ടുവന്നേക്കാം.
ചുരുക്കത്തിൽ: AI അധിഷ്ഠിത ഓട്ടോമേഷൻ സാമ്പത്തികമായ അപ്രതീക്ഷിത ചിലവുകളായി മാറുന്നത് തടയാൻ Claude Code 2.1.212 ടീമുകൾക്ക് ലളിതവും ഫലപ്രദവുമായ ഒരു മാർഗ്ഗം നൽകുന്നു. ക്യാപ്പുകൾ ഉപയോഗിക്കുക, ഫലങ്ങൾ നിരീക്ഷിക്കുക, നിങ്ങളുടെ ഏജന്റുകൾക്ക് എത്രത്തോളം സ്വയംഭരണം (autonomy) നൽകണമെന്ന് തീരുമാനിക്കാൻ ഡാറ്റയെ ഉപയോഗിക്കുക.