എന്തുകൊണ്ടാണ് ഒരു ടു-ബ്രെയിൻ (two-brain) ആർക്കിടെക്ചർ ഉപയോഗിക്കുന്നത്?
മിക്ക കോഡ് എഴുതുന്ന അസിസ്റ്റന്റുകളും എന്താണ് നിർമ്മിക്കേണ്ടതെന്ന് തീരുമാനിക്കുകയും സ്രോതസ്സ് (source) എഴുതുകയും ചെയ്യേണ്ട ഒരു സിംഗിൾ മോഡൽ ആണ് ഉപയോഗിക്കുന്നത്. നീണ്ട സെഷനുകൾ കഴിയുമ്പോൾ മോഡലിന്റെ കോൺടെക്സ്റ്റ് വിൻഡോ (context window) നിറയുകയും, അത് "കോൺടെക്സ്റ്റ് ഡ്രിഫ്റ്റ്" (context drift) എന്ന അവസ്ഥയ്ക്ക് കാരണമാവുകയും ചെയ്യുന്നു - അതായത്, മോഡൽ നേരത്തെയുള്ള തീരുമാനങ്ങൾ മറന്നുപോകുകയും പരസ്പരവിരുദ്ധമായതോ അല്ലെങ്കിൽ ആവർത്തിച്ചുള്ളതോ ആയ കോഡുകൾ നൽകുകയും ചെയ്യുന്നു. Cursor ഇത് പരിഹരിക്കുന്നത് മാനസികമായ ജോലി വിഭജിച്ചുകൊണ്ടാണ്:
- പ്ലാനർ ഏജന്റുകൾ (Planner agents) ഏറ്റവും കരുത്തുറ്റ മോഡലുകളിൽ പ്രവർത്തിക്കുന്നു (ഡ്രാഫ്റ്റിൽ Opus 4.8 അല്ലെങ്കിൽ Fable 5 എന്ന് പരാമർശിക്കുന്നു). അവർ ഒരു ഉയർന്ന തലത്തിലുള്ള അഭ്യർത്ഥനയെ ടാസ്ക് ഹൈരാർക്കിയിലേക്ക് (task hierarchy) വിഭജിക്കുകയും, അവ്യക്തതകൾ പരിഹരിക്കുകയും, ഡിസൈൻ തീരുമാനങ്ങൾ രേഖപ്പെടുത്തുകയും ചെയ്യുന്നു.
- വർക്കർ ഏജന്റുകൾ (Worker agents) വേഗതയേറിയതും ഉയർന്ന പ്രകടനം കാഴ്ചവെക്കുന്നതുമായ മോഡലുകളിൽ (Composer 2.5) പ്രവർത്തിക്കുന്നു. അവർ പ്ലാനർമാരിൽ നിന്ന് കൃത്യമായ ജോലികൾ സ്വീകരിക്കുകയും കോഡ് സ്നിപ്പറ്റുകൾ (code snippets) നിർമ്മിക്കുകയും ചെയ്യുന്നു.
"എന്ത്" (what), "എങ്ങനെ" (how) എന്നിവയെ വേർതിരിച്ചു നിർത്തുന്നത് സിംഗിൾ മോഡൽ സിസ്റ്റങ്ങളെ തടസ്സപ്പെടുത്തുന്ന ഓവർലോഡ് ഒഴിവാക്കാൻ സഹായിക്കുന്നു. ഓരോ മോഡലും അതിന്റെ പങ്ക് അനുസരിച്ചുള്ള കോൺടെക്സ്റ്റ് വലുപ്പത്തിൽ തന്നെ നിലനിൽക്കുന്നു, ഇത് ടോക്കൺ ബജറ്റ് അമിതമായി വർദ്ധിക്കുന്നത് ഒഴിവാക്കുന്നു. ഇത് പ്രോംപ്റ്റുകൾ ചുരുക്കി എഴുതാൻ ഡിസൈനർമാർ നിർബന്ധിതരാകുന്നത് തടയുന്നു.
സ്വാർമിനെ (swarm) വിപുലീകരിക്കുമ്പോൾ
Cursor-ന്റെ സ്വാർമിന്റെ (swarm) ആദ്യകാല പതിപ്പുകൾ മണിക്കൂറിൽ ഏകദേശം ആയിരം കമ്മിറ്റുകൾ വരെ നടത്തിയിരുന്നു. സ്പ്ലിറ്റ്-ബ്രെയിൻ റീഡിസൈനിന് ശേഷം സിസ്റ്റം സെക്കൻഡിൽ ഏകദേശം ആയിരം കമ്മിറ്റുകൾ എന്ന വേഗതയിൽ എത്തി. ആ വേഗത ഒരു പുതിയ തടസ്സം (bottleneck) വെളിപ്പെടുത്തി: വേർഷൻ കൺട്രോൾ ടൂളുകൾ ഇത്രയധികം മത്സരങ്ങൾക്കായി (contention) നിർമ്മിക്കപ്പെട്ടവയായിരുന്നില്ല. രണ്ട് പ്ലാനർമാർ പരസ്പരം കൂട്ടിമുട്ടുന്ന നിർദ്ദേശങ്ങൾ നൽകിയാൽ, റെപ്പോസിറ്ററിയിൽ ആവർത്തിച്ചുള്ള ലോജിക് വരാൻ സാധ്യതയുണ്ട് - ഈ പ്രശ്നത്തെ ടീം "സ്പ്ലിറ്റ്-ബ്രെയിൻ എററുകൾ" (split-brain errors) എന്ന് വിളിക്കുന്നു.
Cursor മൂന്ന് സുരക്ഷാ മാർഗങ്ങളിലൂടെ ഈ അരാജകത്വത്തെ നിയന്ത്രിച്ചു:
- പങ്കാളിത്ത ഡിസൈൻ ഡോക്യുമെന്റുകൾ (Shared design documents) – ഓരോ പ്ലാനറും അതിന്റെ തീരുമാനങ്ങൾ നിർമ്മിച്ച കോഡുമായി ബന്ധിപ്പിച്ചിട്ടുള്ള ഒരു കേന്ദ്രീകൃത ഡോക്യുമെന്റിൽ രേഖപ്പെടുത്തുന്നു. വർക്കർമാർ ആ ലിങ്കുകൾ പിന്തുടരുന്നു, അതിനാൽ ഒരേ ഡിസൈൻ മറ്റൊരിടത്തും വീണ്ടും നിർമ്മിക്കപ്പെടുന്നില്ല.
- മൾട്ടി-ആംഗിൾ റിവ്യൂകൾ (Multi-angle reviews) – മൂന്ന് ഏജന്റുകൾ ജോലിയുടെ വ്യത്യസ്ത ഭാഗങ്ങൾ പരിശോധിക്കുന്നു (മുഴുവൻ ട്രാൻസ്ക്രിപ്റ്റ്, ഔട്ട്പുട്ട് മാത്രം, അല്ലെങ്കിൽ കോഡ് മാത്രം). ഈ ക്രോസ്-ചെക്കിംഗ് വഴി ഒരു സിംഗിൾ വ്യൂവിന് കണ്ടെത്താൻ കഴിയാത്ത വൈരുദ്ധ്യങ്ങൾ കണ്ടെത്താനാകും.
- സ്വയം പരിപാലിക്കുന്ന ഫീൽഡ് ഗൈഡുകൾ (Self-maintained field guides) – ഏജന്റുകൾ അപ്രതീക്ഷിത കണ്ടെത്തലുകളും വീഴ്ചകളും ഉൾക്കൊള്ളുന്ന ഒരു "നോളജ് ഫോൾഡർ" (knowledge folder) സൂക്ഷിക്കുന്നു. ഒരു പുതിയ വർക്കർ തുടങ്ങുമ്പോൾ, അറിയപ്പെടുന്ന തെറ്റുകൾ ആവർത്തിക്കാതിരിക്കാൻ അത് ഈ ഫോൾഡർ പരിശോധിക്കുന്നു, ഇത് സ്വാർമിന് മൊത്തത്തിൽ ഒരു ഷോർട്ട്-ടേം മെമ്മറി (short-term memory) നൽകുന്നു.
മാറ്റങ്ങളുടെ പ്രവാഹത്തിനിടയിലും ഈ നടപടികൾ കോഡ്ബേസ് (codebase) സുതാര്യമായി നിലനിർത്തുന്നു.
പ്രസക്തമായ ബെഞ്ച്മാർക്കുകൾ (Benchmarks)
കൃത്യതയ്ക്കും വലുപ്പത്തിനും വെല്ലുവിളിയാകുന്ന ഒരു ജോലിയായ 835 പേജുള്ള SQLite മാനുവൽ (ഒരു Rust ഇംപ്ലിമെന്റേഷൻ) മുഴുവനായി പുനർനിർമ്മിച്ചുകൊണ്ട് Cursor ഹൈബ്രിഡ് സ്വാർമിനെ പരീക്ഷിച്ചു. ഫലങ്ങൾ വളരെ വ്യക്തമായിരുന്നു:
- കൃത്യത (Accuracy) – ഹൈബ്രിഡ് കോൺഫിഗറേഷൻ (planner + Composer workers) 100% കൃത്യത കൈവരിച്ചു, ഇത് പരാമർശിക്കപ്പെട്ട ഏറ്റവും നൂതനമായ മോഡലിന്റെ (*GPT-5.5