कैसे चलता है
एक लक्ष्य से ऐसे प्लान तक, जिसे आप फ़ॉलो कर सकें
छह चरणों का एक चक्र। आप बताते हैं कि आपको क्या चाहिए। PO उसका प्लान बनाता है, टास्क का क्रम तय करता है, याद करता है कि प्रोजेक्ट क्या जानता है, काम चलाता है, उसे जाँचता है और जो सीखा उसे सहेजता है। हर चरण के नीचे आप तकनीकी ब्योरा खोल सकते हैं।
प्लान → क्रम → याद करना → रन → जाँच → सीख, फिर वापस याद करना पर। चरण 6 में जो सहेजा जाता है, अगले प्लान में चरण 3 वही याद करता है।
चक्र
चक्र, चरण-दर-चरण
स्क्रॉल करें: हर चित्र प्रोडक्ट की स्क्रीन की तरह बना है। उदाहरण एक टीम वीकेंड का है।
6 में से चरण 1
आप बताते हैं कि क्या चाहिए, आपको प्लान मिलता है
आप नतीजा एक वाक्य में बताते हैं। असिस्टेंट उसे टास्क वाले प्लान में बदलता है। हर टास्क के चरण होते हैं, और हर चरण बताता है कि उसके पूरा होने की जाँच कैसे होगी।
अंदर की बात
नतीजा एक प्राथमिकता और उसकी शर्तों के साथ प्लान के रूप में सहेजा जाता है, फिर टास्क में बाँटा जाता है। हर टास्क बताता है कि वह किस पर निर्भर है और उसके चरण क्या हैं। हर चरण के साथ वह जाँच होती है जो साबित करती है कि वह पूरा हुआ।
प्लान, टास्क और चरण डेटा के रूप में सहेजे जाते हैं, चैट के खुले टेक्स्ट के रूप में नहीं। स्क्रीन और रनर एक ही स्थितियाँ पढ़ते हैं।
plan(action: "create", title, description, priority: 8, constraints: [{ constraint_type: "performance", … }])task(action: "create", plan_id, title, depends_on: [task_id], steps: [{ description, verification }])- प्लान की स्थिति: draft, approved, in_progress, completed, cancelled।
- शर्तों के प्रकार: performance, security, style, compatibility, other।
- code(action: "plan_implementation", auto_create_plan: true) कोड ग्राफ़ से प्लान का मसौदा बनाता है।
6 में से चरण 2
जो टास्क एक-दूसरे पर निर्भर नहीं हैं, वे साथ चलते हैं
PO टास्क को छाँटता है। कोई टास्क सिर्फ़ उन टास्क का इंतज़ार करता है जिनकी उसे ज़रूरत है। बाकी सब अभी, एक साथ, शुरू हो सकते हैं।
अंदर की बात
कोई टास्क तभी शुरू होता है जब उसकी सारी निर्भरताएँ पूरी हो चुकी हों। PO इन जुड़ावों को वेव में बदलता है: वेव 1 में वे सब टास्क हैं जिनकी कोई शर्त बाकी नहीं, वेव 2 में वे जो वेव 1 से खुलते हैं, और इसी तरह आगे।
एक ही वेव के टास्क स्वतंत्र हैं, इसलिए एक साथ चलते हैं। निर्भरताओं की सबसे लंबी कड़ी, यानी क्रिटिकल पाथ, वेव की न्यूनतम संख्या तय करती है।
plan(action: "get_waves", plan_id)plan(action: "get_critical_path", plan_id)- plan(action: "get_dependency_graph") टास्क का DAG लौटाता है।
- task(action: "get_next") अगला बिना रुकावट वाला टास्क लौटाता है, सबसे ऊँची प्राथमिकता पहले।
- रन फिर शुरू होने पर वेव दोबारा निकाली जाती हैं और पूरी हो चुकी वेव छोड़ दी जाती हैं।
6 में से चरण 3
असिस्टेंट देखता है कि प्रोजेक्ट पहले से क्या जानता है
हर टास्क से पहले असिस्टेंट वे नोट और निर्णय पढ़ता है जो लागू होते हैं। इसलिए वह वही सवाल बार-बार नहीं पूछता।
अंदर की बात
टास्क से पहले असिस्टेंट प्रोजेक्ट की मेमोरी पढ़ता है: नोट (चेतावनियाँ, दिशानिर्देश, पैटर्न), वजह के साथ निर्णय, और कोड प्रोजेक्ट में, उन फ़ाइलों के आसपास का कोड जिन्हें वह छुएगा। मतलब के आधार पर खोज सबसे करीबी मेल पहले ढूँढती है।
फिर PO नोट के बीच के जुड़ावों का पीछा करता है। जो नोट सवाल से मेल नहीं खाया, वह भी दिख सकता है, क्योंकि जो नोट मेल खाया वह उससे मज़बूती से जुड़ा है। हर कदम पर जुड़ाव कमज़ोर पड़ता है, और जो नोट धुँधले पड़ चुके हैं उन्हें छोड़ दिया जाता है।
note(action: "search_semantic", query, project_slug)decision(action: "search_semantic", query)admin(action: "search_neurons", query, max_hops: 2)note(action: "get_context", entity_type: "file", entity_id)- स्प्रेडिंग एक्टिवेशन के डिफ़ॉल्ट: 20 शुरुआती नोट, 2 हॉप, हर हॉप पर सिग्नल आधा, 10 नतीजे।
- नतीजों की 40% जगहें उन नोट के लिए रखी जाती हैं जो सिनैप्स के ज़रिए मिले।
- आगे बढ़ाया गया स्कोर = पैरेंट स्कोर x सिनैप्स का वज़न x नोट की एनर्जी x डिके।
6 में से चरण 4
असिस्टेंट टास्क करते हैं, समूह-दर-समूह
हर टास्क अपने असिस्टेंट के पास जाता है। एक समूह के टास्क साथ चलते हैं, और अगला समूह इंतज़ार करता है।
अंदर की बात
plan(action: "run") रनर को उसकी अपनी git ब्रांच पर शुरू करता है। हर वेव के लिए वह हर योग्य टास्क पर एक असिस्टेंट सेशन शुरू करता है और उन्हें एक सीमा तक (डिफ़ॉल्ट 4) समानांतर चलाता है।
हर टास्क को प्रोजेक्ट की मेमोरी से बना प्रॉम्प्ट मिलता है: उसका विवरण, चरण और शर्तें, उससे जुड़े नोट, मेल खाते पर्सोना और स्किल, और पिछली वेव ने क्या किया उसका सार। एक गार्ड सेशन को निष्क्रिय समय, दोहराई गई कॉल और टाइमआउट के लिए देखता है, और असिस्टेंट भटकने पर संकेत भेजता है।
plan(action: "run", plan_id, cwd, project_slug)plan(action: "run_status", plan_id)- टास्क को उसके टैग, चरण और फ़ाइलों से सरल, जटिल या रचनात्मक के रूप में आँका जाता है। यह प्रोफ़ाइल उसकी समय-सीमा और लागत का बजट तय करती है।
- सरल: 600 s और $0.50। जटिल: 3600 s और $2.00। रचनात्मक: 1800 s और $1.00।
- रन सहेजे जाते हैं, इसलिए रीस्टार्ट के बाद रन फिर शुरू किया जा सकता है। plan(action: "cancel_run") एक को रोकता है।
6 में से चरण 5
समूह तब पूरा होता है जब उसकी जाँचें पास हों
अगला समूह शुरू होने से पहले PO काम जाँचता है। चरण बंद होने चाहिए और बदलावों में कोई संवेदनशील फ़ाइल नहीं बचनी चाहिए। कोड प्रोजेक्ट में PO यह भी जाँचता है कि वह अब भी बिल्ड होता है।
अंदर की बात
जब वेव ख़त्म होती है, तो अगली से पहले रनर उसे जाँचता है। वह देखता है कि असिस्टेंट ने कमिट बनाए, हर चरण पूरा हुआ या छोड़ा गया, प्रोजेक्ट बिल्ड होता है, और डिफ़ में कोई संवेदनशील फ़ाइल नहीं है।
रन खुद एक स्टेट मशीन है। एक लाइफ़साइकिल प्रोटोकॉल approved से executing और फिर post_run तक जाता है, और हर कदम के लिए साफ़ ट्रिगर चाहिए। जिस टास्क का असिस्टेंट फ़ेल हो या टाइमआउट हो, उसे डिफ़ॉल्ट रूप से एक बार फिर चलाया जाता है, त्रुटि को संदर्भ बनाकर।
protocol(action: "transition", run_id, trigger: "child_completed")step(action: "get_progress", task_id)- बिल्ड जाँच: पहचानी गई भाषा के हिसाब से cargo check, npm run build या go build ./...।
- अस्वीकार की गई संवेदनशील फ़ाइलें: .env, credentials.json, *.pem, *.key और ऐसी ही।
- टेस्ट एक विकल्प हैं, डिफ़ॉल्ट रूप से बंद। plan-runner-reviewed किसी व्यक्ति के लिए awaiting_review स्टेट जोड़ता है।
6 में से चरण 6
जो सीखा गया, अगली बार के लिए सहेजा जाता है
काम पूरा होने पर जो तय हुआ और सीखा गया, वह प्रोजेक्ट की मेमोरी में वापस लिखा जाता है। अगला प्लान उसी से शुरू होता है।
अंदर की बात
टास्क पूरा होने पर रनर बिना किसी मॉडल को बुलाए वापस लिखता है: वह कमिट को टास्क और प्लान से जोड़ता है, git लॉग से एक संदर्भ नोट बनाता है, और निर्णयों को उन फ़ाइलों से बाँधता है जिन पर वे असर डालते हैं।
असिस्टेंट वह जोड़ता है जो सिर्फ़ वही जानता है: विकल्पों के साथ निर्णय, चेतावनियाँ, पैटर्न। साथ इस्तेमाल हुए नोट करीब आते हैं। जो नोट कभी इस्तेमाल नहीं होते, उनकी एनर्जी घटती है और वे पुराने पड़ जाते हैं। एक एपिसोड अनुरोध, स्टेट के बीच का रास्ता और नतीजा दर्ज करता है। अगला प्लान चरण 3 से, यह सब लेकर, शुरू होता है।
decision(action: "add", task_id, rationale, alternatives)note(action: "create", note_type: "gotcha", content, anchors)episode(action: "collect", run_id, project_id)admin(action: "reinforce_neurons", note_ids)- पुरानापन आख़िरी गतिविधि के बाद के समय के साथ बढ़ता है, एक दर से जो नोट के प्रकार पर निर्भर है। note(action: "confirm") उसे रीसेट करता है।
- स्किल मज़बूती से जुड़े नोट के समूहों से उभरती हैं (admin(action: "detect_skills"))।
ज़िम्मेदारियाँ
कौन क्या करता है
PO यांत्रिक काम सँभालता है, ताकि असिस्टेंट काम पर ध्यान दे सके।
PO बिना कहे करता है
- टास्क को समूहों में छाँटता है और असिस्टेंट शुरू करता है।
- हर समूह जाँचता है: चरण बंद, कोई संवेदनशील फ़ाइल नहीं, और कोड प्रोजेक्ट के लिए बिल्ड।
- बदलावों को टास्क से जोड़ता है और जो हुआ उसका नोट लिखता है।
- हर रन के बदलाव उसकी अपनी git ब्रांच पर रखता है।
- दर्ज करता है कि किस पर्सोना और स्किल ने मदद की।
असिस्टेंट अपने टूल से करता है
- शुरू करने से पहले नोट और निर्णय खोजता है।
- प्लान, टास्क और चरण बनाता है, और उनकी स्थिति अपडेट करता है।
- निर्णय को उसके विकल्पों और असर वाली चीज़ों के साथ सहेजता है।
- चेतावनियाँ, दिशानिर्देश और पैटर्न लिखता है, उनसे जोड़कर जिनके बारे में वे हैं।
- किसी प्रक्रिया को चरण-दर-चरण आगे बढ़ाता है।
शुरू करने के रास्ते
चक्र शुरू करने के तीन तरीके
आपके AI टूल से
Claude Code, Cursor या PO से जुड़ा कोई और AI टूल। आप नतीजा बताते हैं। वह प्लान बनाता है, क्रम तय करता है और याद करता है, फिर अंत में जो सीखा उसे सहेजता है।
चैट से
PO में बनी चैट उसी असिस्टेंट से बात करती है। हर संदेश के साथ मेल खाती स्किल, लागू होने वाले नोट और निर्णय, और जो चल रहा है वह जाता है।
अपने आप
प्लान तब भी चल सकता है जब कोई मौजूद न हो। वह तय समय पर या किसी घटना पर शुरू होता है, दो शुरुआतों के बीच एक ठहराव के साथ। शुरुआत के प्रकार हैं schedule, webhook, event और chat।
मेमोरी
PO याद रखता है कि आपने क्या तय किया और क्या सीखा
नोट, निर्णय और उनके बीच के जुड़ाव आपके प्रोजेक्ट के साथ रहते हैं। काम आने पर PO उन्हें दोबारा ढूँढ लेता है। स्क्रॉल करके देखें, मेमोरी कैसे बढ़ती है।
काल्पनिक उदाहरण: एक छोटा इवेंट प्रोजेक्ट। ग्राफ़ के नाम उदाहरण हैं, आपका डेटा नहीं। रंग और आकार प्रोडक्ट के ग्राफ़ वाले ही हैं।
1 / 5
आपकी फ़ाइलें बिंदु बन जाती हैं
PO प्रोजेक्ट में जो है, वहीं से शुरू करता है: डॉक्यूमेंट, स्प्रेडशीट, फ़ाइलें। हर एक नीला बिंदु है।
2 / 5
प्लान और टास्क जुड़ते हैं
प्लान और टास्क उसी चित्र में जुड़ जाते हैं। हर टास्क उन फ़ाइलों से जुड़ा होता है जिन्हें वह छूता है।
3 / 5
नोट और निर्णय जुड़े रहते हैं
जो आप सीखते हैं, वह नोट बनता है। जो तय करते हैं, वह निर्णय बनता है। दोनों फ़ाइलों से और एक-दूसरे से जुड़े रहते हैं।
4 / 5
मिलती-जुलती चीज़ें साथ आ जाती हैं
एक ही विषय की चीज़ें एक-दूसरे के पास आ जाती हैं। प्रोजेक्ट के मुख्य विषय एक नज़र में दिखते हैं।
5 / 5
PO जुड़ावों के सहारे जवाब ढूँढता है
आप सवाल पूछते हैं। PO मेल खाते नोट ढूँढता है (सियान)। फिर जुड़ावों के सहारे संबंधित चीज़ों तक पहुँचता है (बैंगनी), शब्द अलग हों तब भी।
अंदर की बात: जुड़ावों के नाम
प्रोडक्ट अपने ग्राफ़ के जुड़ावों को ये नाम देता है। PO इस्तेमाल करने के लिए इनकी ज़रूरत नहीं है।
- CONTAINSएक प्लान में उसके टास्क होते हैं।
- IMPORTSएक फ़ाइल दूसरी फ़ाइल का इस्तेमाल करती है।
- AFFECTSएक टास्क किसी फ़ाइल को छूता है।
- CO_CHANGEDदो फ़ाइलें, जो अक्सर साथ बदलती हैं, कोड के इतिहास में दिखता है।
- SYNAPSEनोट, निर्णय और फ़ाइलों के बीच का जुड़ाव। जिन जुड़ावों का कोई इस्तेमाल नहीं करता, वे धीरे-धीरे मिट जाते हैं।
आज़माएँ
देखें, असिस्टेंट PO के साथ कैसे काम करता है
कोई अनुरोध चुनें। आपको जवाब सीधी भाषा में दिखेगा, और परदे के पीछे असिस्टेंट PO को जो कॉल करता है, वे भी। किसी कॉल को खोलकर उसका ब्योरा देखें।
Two notes apply: the place must be close to a train station, and last year the menu had nothing vegetarian. I will write the plan around both.
The plan has 3 tasks in 2 waves. The shortlist and the date poll do not depend on each other, so they happen at the same time. Booking waits for both.
नकली डेमो: जवाब पहले से लिखे हैं और किसी सर्वर से संपर्क नहीं होता। कॉल और उनके आर्ग्युमेंट असली हैं।
शुरू करें
अपने असिस्टेंट को याददाश्त और एक प्लान दीजिए
ऑर्केस्ट्रेटर इंस्टॉल करें, MCP से Claude Code जोड़ें, और अपने पहले असिस्टेंट को कोई लाइन लिखने से पहले प्रोजेक्ट पढ़ने दें।
या टर्मिनल से शुरू करें
brew install this-rs/tap/project-orchestrator