જ્યારે તમે કોઈ પણ જવાબદાર વ્યક્તિ વગર મોટા પ્રોજેક્ટનું આયોજન કરો છો ત્યારે શું થાય છે? મોટાભાગના સોફ્ટવેર સ્ટેક્સ એક સિંગલ ઓર્કેસ્ટ્રેટર (orchestrator) માનીને ચાલે છે. એક પ્રોસેસ સ્ટેટ (state) ધરાવે છે, જોબ્સને ક્યુ (queue) માં રાખે છે અને કાર્યો સોંપે છે. જો તે કોઓર્ડિનેટર રિસ્ટાર્ટ થાય, તો આખું વર્કફ્લો ખોરવાઈ જાય છે. એક નવો પ્રોજેક્ટ આ ધારણાને સંપૂર્ણપણે બદલી નાખે છે. તે દર્શાવે છે કે કેવી રીતે AI એજન્ટ્સનું એક ઝૂમખું "જાપાનની બે અઠવાડિયાની સફરનું આયોજન કરો" જેવા લક્ષ્યને કોઈપણ સિંગલ નોડ દ્વારા સંપૂર્ણ પ્લાન રાખ્યા વિના, એક સંપૂર્ણ ટાસ્ક ટ્રીમાં વિભાજિત કરી શકે છે.

નેતા વગરની સિસ્ટમ કેમ બનાવવી?

કેન્દ્રીય આયોજકો (Centralized planners) વિશે સમજવું સરળ છે. તમે સર્વરને વિનંતી મોકલો છો, તે કામ વહેંચે છે, અને વર્કર્સ રિપોર્ટ આપે છે. સમસ્યા એ છે કે સર્વર એક જ્ઞાનાત્મક અને ભૌતિક અવરોધ (bottleneck) બની જાય છે. તે જ સત્યનો માલિક હોય છે.

વિતરિત સેટઅપ (distributed setup) માં, સત્ય એક સહિયારી છબીમાં ફેરવાઈ જાય છે જેના પર નેટવર્ક ગોસિપ (gossip) દ્વારા એકમત થાય છે. આ ચોક્કસ Python અમલીકરણ બે અલગ-અલગ ખ્યાલોને જોડે છે. પહેલો છે ઇટરેટિવ રિફાઇનમેન્ટ લૂપ: એક એજન્ટ પ્રસ્તાવ લખે છે, બીજો તેને સ્કોર કરે છે, અને ત્રીજો તેને સુધારે છે. બીજું છે libp2p પર બનેલું પીઅર-ટુ-પીઅર નેટવર્કિંગ લેયર, જે એજન્ટોને કોઈપણ રજિસ્ટ્રી અથવા લોડ બેલેન્સર વગર આપમેળે એકબીજાને શોધવામાં મદદ કરે છે. પરિણામ એવું ક્લસ્ટર છે જ્યાં કોઈ પણ ઓર્કેસ્ટ્રા કંડક્ટર વગર પીઅર્સ દેખાય છે, પ્રસ્તાવ મૂકે છે, મતદાન કરે છે અને અમલીકરણ કરે છે.

ચાર ભૂમિકાઓ

સિસ્ટમ દરેક સહભાગીને ચાર વ્યક્તિત્વમાંથી એક સોંપે છે. તમારે ચાર ભૌતિક મશીનોની જરૂર નથી. તેઓ એક લેપટોપ પર સહઅસ્તિત્વ ધરાવી શકે છે અથવા હોમ નેટવર્ક પર ફેલાયેલા હોઈ શકે છે. ભૂમિકાઓ આ મુજબ છે:

  • Decomposer (વિભાજક). આ એજન્ટ ઉચ્ચ-સ્તરીય લક્ષ્ય મેળવે છે અને તેને પેટા-લક્ષ્યોમાં વિભાજિત કરવાનો પ્રસ્તાવ મૂકે છે. કારણ કે સિસ્ટમ સમાંતર રીતે અનેક વિભાજકો ચલાવે છે, તેથી તમને જાપાનની સફર માટે ત્રણ અલગ-અલગ રીતો મળી શકે છે. એક પ્રવાસને ભૂગોળ મુજબ વિભાજિત કરી શકે છે: ટોક્યો, ક્યોટો, ઓસાકા. બીજું પ્રવૃત્તિ મુજબ વિભાજિત કરી શકે છે: પરિવહન, રહેઠાણ, ભોજન, જોવાલાયક સ્થળો. ત્રીજું દિવસ મુજબ ક્રમ આપી શકે છે. નેટવર્ક તે તમામ પર વિચાર કરે છે.

  • Scorer (સ્કોરર). આ એજન્ટો એડિટોરિયલ બોર્ડ તરીકે કામ કરે છે. તેઓ સૂચવેલા વિભાજનની તપાસ કરે છે અને તેને રેટિંગ આપે છે. સ્કોર એ દર્શાવે છે કે પેટા-લક્ષ્યો પૂરતા પ્રમાણમાં નક્કર, એકબીજા સાથે ઓવરલેપ ન કરતા અને સામૂહિક રીતે સંપૂર્ણ છે કે નહીં. વધુ મહત્વનું છે કે, સ્કોરર નક્કી કરે છે કે પ્રસ્તાવ સ્વીકારવા માટે પૂરતો સારો છે કે નહીં. તેની મંજૂરી વિના, વિભાજન અનિશ્ચિતતામાં રહે છે.

  • Executor (અમલીકરણકર્તા). એકવાર ટ્રી લીફ નોડ્સ (leaf nodes) સુધી પહોંચી જાય જે અમલમાં મૂકવા માટે નાના હોય, ત્યારે એક્ઝિક્યુટર્સ તેનો દાવો કરવા માટે દોડી આવે છે. તેઓ કેન્દ્રીય ક્યુ (queue) પાસેથી પરવાનગીની રાહ જોતા નથી. તેના બદલે, તેઓ કોને કયું કાર્ય મળશે તે નક્કી કરવા માટે ટાઈમસ્ટેમ્પ પ્રોટોકોલનો ઉપયોગ કરે છે. વિજેતા લોકલ LLM કોલ દ્વારા જોબ ચલાવે છે અને પરિણામ બ્રોડકાસ્ટ કરે છે.

  • Observer (નિરીક્ષક). આ એ શાંતિથી જોનાર છે જેની દરેક નેટવર્કને જરૂર હોય છે. તે શાંતિથી ગોસિપ સાંભળે છે, વાતોમાંથી પ્લાન ટ્રીનું પુનઃનિર્માણ કરે છે, અને વાંચી શકાય તેવો સ્નેપશોટ પ્રિન્ટ કરે છે. કારણ કે તે ક્યારેય બોલતું નથી, તે એક મહત્વપૂર્ણ મુદ્દો સાબિત કરે છે: મોડા જોડાનાર કોઈપણ વ્યક્તિ માત્ર સાંભળીને આખા પ્લાન વિશે જાણી શકે છે.

સત્યના સ્ત્રોત તરીકે ગોસિપ

libp2p લેયર ડિસ્કવરી અને મેસેજિંગ સંભાળે છે. એજન્ટો પ્રોટોકોલના ઇન-બિલ્ટ પીઅર ડિસ્કવરી દ્વારા એકબીજાને શોધે છે, અને પછી શેર કરેલા ટોપિક પર મેસેજ બ્રોડકાસ્ટ કરે છે. અહીં કોઈ રેકોર્ડ ડેટાબેઝ નથી, કે કોઈ પ્રમાણિત પ્લાન રાખતી Redis કેશ નથી.

દરેક પીઅર પ્લાન ટ્રીની પોતાની નકલ રાખે છે અને તે સાંભળેલી ગોસિપના આધારે તેને અપડેટ કરે છે. જ્યારે એક વિભાજક પ્રસ્તાવ બ્રોડકાસ્ટ કરે છે, ત્યારે દરેક અન્ય નોડ તેને મેળવે છે, ફોર્મેટને વેલિડેટ કરે છે, અને તેની લોકલ ટ્રીમાં તે શાખા ઉમેરે છે. જ્યારે સ્કોરર્સ મતદાન કરે છે, ત્યારે ગણતરી પણ તે જ રીતે ફેલાય છે. જો બે એક્ઝિક્યુટર્સ એક જ કાર્ય માટે વિરોધાભાસી દાવાઓ કરે છે, તો ટાઈમસ્ટેમ્પ પ્રોટોકોલ તે સંઘર્ષને ઉકેલે છે. નેટવર્ક વહેલા દાવા પર સહમત થાય છે અને મોડા દાવાને નકારી કાઢે છે.

સમય જતાં, ટ્રી મૂળ લક્ષ્યથી સ્વીકૃત પેટા-લક્ષ્યોના સ્તરો દ્વારા નીચે તરફ વધે છે જ્યાં સુધી તે નાના કાર્યો સુધી ન પહોંચી જાય. આ પ્રક્રિયા બ્લોકચેન કન્સન્સસ (સંમતિ) પ્રાપ્ત કરવા જેવી જ છે, સિવાય કે પેલોડ સિક્કાઓના લેજરને બદલે ટ્રાવેલ ઇટિનરરી અથવા સોફ્ટવેર સ્પેક છે.

મતદાન અને અમલીકરણની દોડ

લોકશાહી મોંઘી છે, અને આ સિસ્ટમ તેની કિંમત લેટન્સી (latency) તરીકે ચૂકવે છે. વિભાજન ત્યારે જ જીતે છે જો પૂરતા સ્કોરર્સ સહમત થાય. તમે ક્લસ્ટરને કેવી રીતે કન્ફિગર કરો છો તેના પર આધાર રાખીને તે થ્રેશોલ્ડ સાદી બહુમતી અથવા વધુ કડક કોરમ (quorum) હોઈ શકે છે. વિભાજકો પ્રસ્તાવ મૂકવાનું બંધ કરતા નથી, તેથી નેટવર્ક ઘણીવાર એકસાથે અનેક સ્પર્ધક ટ્રીનું મૂલ્યાંકન કરે છે. અંતે, એક ટ્રી જરૂરી મતો મેળવે છે અને તેના પેટા-લક્ષ્યો ડ્રાફ્ટમાંથી સ્વીકૃત સ્ટેજમાં પહોંચી જાય છે.

Executors add another layer of coordination. Because tasks are public on the gossip channel, multiple executors might try to grab the same attractive leaf node. The timestamp protocol acts as a tiebreaker. Each claim carries a monotonic timestamp, and the network honors the earliest one. The loser simply moves on to the next available task. This is crude, but it avoids the need for a centralized scheduler locking rows in a database.

Resilience by Design

The architecture earns its keep when things break. If a decomposer crashes after proposing half the subgoals, the surviving decomposers continue offering splits. The plan does not stall waiting for a respawn. If a scorer drops off the network, the remaining voters can still reach quorum as long as you sized the cluster appropriately.

The real payoff is late joins. A new agent that boots up halfway through does not need a snapshot or a