सीधे कंटेंट पर जाएँ

कैसे चलता है

एक लक्ष्य से ऐसे प्लान तक, जिसे आप फ़ॉलो कर सकें

छह चरणों का एक चक्र। आप बताते हैं कि आपको क्या चाहिए। PO उसका प्लान बनाता है, टास्क का क्रम तय करता है, याद करता है कि प्रोजेक्ट क्या जानता है, काम चलाता है, उसे जाँचता है और जो सीखा उसे सहेजता है। हर चरण के नीचे आप तकनीकी ब्योरा खोल सकते हैं।

प्लान → क्रम → याद करना → रन → जाँच → सीख, फिर वापस याद करना पर। चरण 6 में जो सहेजा जाता है, अगले प्लान में चरण 3 वही याद करता है।

आज़माएँ: किसी चरण पर होवर या फ़ोकस करके उसे पढ़ें, चुनकर उस पर जाएँ

चक्र

चक्र, चरण-दर-चरण

स्क्रॉल करें: हर चित्र प्रोडक्ट की स्क्रीन की तरह बना है। उदाहरण एक टीम वीकेंड का है।

चरण 1 / 6: प्लान, रुकाव 5 / 5: मंज़ूर

आप बताते हैं कि क्या चाहिए, आपको प्लान मिलता है

आप नतीजा एक वाक्य में बताते हैं। असिस्टेंट उसे टास्क वाले प्लान में बदलता है। हर टास्क के चरण होते हैं, और हर चरण बताता है कि उसके पूरा होने की जाँच कैसे होगी।

अंदर की बात

नतीजा एक प्राथमिकता और उसकी शर्तों के साथ प्लान के रूप में सहेजा जाता है, फिर टास्क में बाँटा जाता है। हर टास्क बताता है कि वह किस पर निर्भर है और उसके चरण क्या हैं। हर चरण के साथ वह जाँच होती है जो साबित करती है कि वह पूरा हुआ।

प्लान, टास्क और चरण डेटा के रूप में सहेजे जाते हैं, चैट के खुले टेक्स्ट के रूप में नहीं। स्क्रीन और रनर एक ही स्थितियाँ पढ़ते हैं।

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) कोड ग्राफ़ से प्लान का मसौदा बनाता है।

आज़माएँ: कोई रुकाव चुनें, तीरों से आगे-पीछे जाएँ या चलाएँ दबाएँ; रुकने के बाद चित्र फिर स्क्रॉल का अनुसरण करता है

चरण 2 / 6: क्रम, रुकाव 5 / 5: अभी तैयार

जो टास्क एक-दूसरे पर निर्भर नहीं हैं, वे साथ चलते हैं

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") अगला बिना रुकावट वाला टास्क लौटाता है, सबसे ऊँची प्राथमिकता पहले।
  • रन फिर शुरू होने पर वेव दोबारा निकाली जाती हैं और पूरी हो चुकी वेव छोड़ दी जाती हैं।
Plan · dependency graph
Wave 13 in parallelWave 22 in parallelWave 31 taskT1 Venuesno prerequisiteT2 Availabilityno prerequisiteT3 Budgetno prerequisiteT4 Bookingafter T1, T2T5 Mealsafter T3T6 Share planafter T4

आज़माएँ: कोई टास्क चुनें, यह देखने के लिए कि वह किसका इंतज़ार करता है और किसे खोलता है

6 tasks3 waveswave 1 is ready now

आज़माएँ: कोई रुकाव चुनें, तीरों से आगे-पीछे जाएँ या चलाएँ दबाएँ; रुकने के बाद चित्र फिर स्क्रॉल का अनुसरण करता है

चरण 3 / 6: याद करना, रुकाव 5 / 5: सौंपा गया

असिस्टेंट देखता है कि प्रोजेक्ट पहले से क्या जानता है

हर टास्क से पहले असिस्टेंट वे नोट और निर्णय पढ़ता है जो लागू होते हैं। इसलिए वह वही सवाल बार-बार नहीं पूछता।

अंदर की बात

टास्क से पहले असिस्टेंट प्रोजेक्ट की मेमोरी पढ़ता है: नोट (चेतावनियाँ, दिशानिर्देश, पैटर्न), वजह के साथ निर्णय, और कोड प्रोजेक्ट में, उन फ़ाइलों के आसपास का कोड जिन्हें वह छुएगा। मतलब के आधार पर खोज सबसे करीबी मेल पहले ढूँढती है।

फिर 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 डिके।
Memory · recall
taskdirecthop 1hop 20.910.840.720.460.410.350.300.170.15

आज़माएँ: कोई नोड चुनें, एक्टिवेशन को टास्क तक वापस पीछा करने के लिए

Given to the assistant

  • The team prefers a quiet place
    0.91
    guidelinedirect match
  • The weekend is 14 and 15 June
    0.84
    decisiondirect match
  • Two people need vegetarian meals
    0.46
    gotcha1 hop
  • Last year the venue was too far from the station
    0.17
    guideline2 hops

आज़माएँ: कोई रुकाव चुनें, तीरों से आगे-पीछे जाएँ या चलाएँ दबाएँ; रुकने के बाद चित्र फिर स्क्रॉल का अनुसरण करता है

चरण 4 / 6: रन, रुकाव 5 / 5: वेव 2 शुरू

असिस्टेंट टास्क करते हैं, समूह-दर-समूह

हर टास्क अपने असिस्टेंट के पास जाता है। एक समूह के टास्क साथ चलते हैं, और अगला समूह इंतज़ार करता है।

अंदर की बात

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") एक को रोकता है।
  • जो असिस्टेंट किसी टास्क को सौंपता है, वह उसके लिए प्रदाता और मॉडल का नाम ले सकता है: plan(action: "delegate_task") में provider, model और task_class लगते हैं। प्रोजेक्ट ने उस प्रदाता को अनुमति दी होनी चाहिए।

आज़माएँ: कोई रुकाव चुनें, तीरों से आगे-पीछे जाएँ या चलाएँ दबाएँ; रुकने के बाद चित्र फिर स्क्रॉल का अनुसरण करता है

चरण 5 / 6: जाँच, रुकाव 5 / 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: सीख, रुकाव 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 में बनी चैट उसी असिस्टेंट से बात करती है। हर संदेश के साथ मिलते स्किल, लागू होने वाले नोट और निर्णय, और जो चल रहा है वह जाता है। किसी प्लान, टास्क, नोट या निर्णय की ओर इशारा करने के लिए # टाइप करें। आप हर बातचीत का इंजन चुनते हैं, डिफ़ॉल्ट Claude Code या कोई दूसरा इंजन (अल्फ़ा), या उसे ऑटो पर रखते हैं और PO मॉडल चुनता है; आपका खुद चुना मॉडल कभी नहीं बदला जाता। बातचीत के ऊपर की टाइमलाइन दिखाती है कि क्या चला और कितनी देर। असिस्टेंट व्यस्त हो तो आपका भेजा संदेश सर्वर की रखी कतार में रहता है, इसलिए बातचीत बदलने या रीलोड करने पर वह खोता नहीं। नेटिव इंजन, Codex और ACP में सर्वर रीस्टार्ट से कटी बारी अपने आप फिर शुरू होती है; Claude Code की बारी एक दिखने वाली त्रुटि के साथ बंद हो जाती है और आपका अगला संदेश बातचीत को आगे बढ़ाता है।

अपने आप

प्लान तब भी चल सकता है जब कोई मौजूद न हो। वह तय समय पर या किसी घटना पर शुरू होता है, दो शुरुआतों के बीच एक ठहराव के साथ। शुरुआत के प्रकार हैं schedule, webhook, event और chat।

मेमोरी

PO याद रखता है कि आपने क्या तय किया और क्या सीखा

नोट, निर्णय और उनके बीच के जुड़ाव आपके प्रोजेक्ट के साथ रहते हैं। काम आने पर PO उन्हें दोबारा ढूँढ लेता है। स्क्रॉल करके देखें, मेमोरी कैसे बढ़ती है।

  1. 1

    आपकी फ़ाइलें बिंदु बन जाती हैं

    PO प्रोजेक्ट में जो है, वहीं से शुरू करता है: डॉक्यूमेंट, स्प्रेडशीट, फ़ाइलें। हर एक नीला बिंदु है।

  2. 2

    प्लान और टास्क जुड़ते हैं

    प्लान और टास्क उसी चित्र में जुड़ जाते हैं। हर टास्क उन फ़ाइलों से जुड़ा होता है जिन्हें वह छूता है।

  3. 3

    नोट और निर्णय जुड़े रहते हैं

    जो आप सीखते हैं, वह नोट बनता है। जो तय करते हैं, वह निर्णय बनता है। दोनों फ़ाइलों से और एक-दूसरे से जुड़े रहते हैं।

  4. 4

    एक ही विषय की चीज़ें एक-दूसरे के पास आ जाती हैं। प्रोजेक्ट के मुख्य विषय एक नज़र में दिखते हैं।

  5. 5

    आप सवाल पूछते हैं। PO मेल खाते नोट ढूँढता है (सियान)। फिर जुड़ावों के सहारे संबंधित चीज़ों तक पहुँचता है (बैंगनी), शब्द अलग हों तब भी।

मेमोरी

काल्पनिक उदाहरण: एक छोटा इवेंट प्रोजेक्ट। ग्राफ़ के नाम उदाहरण हैं, आपका डेटा नहीं। रंग और आकार प्रोडक्ट के ग्राफ़ वाले ही हैं।

अंदर की बात: जुड़ावों के नाम

प्रोडक्ट अपने ग्राफ़ के जुड़ावों को ये नाम देता है। PO इस्तेमाल करने के लिए इनकी ज़रूरत नहीं है।

  • CONTAINSएक प्लान में उसके टास्क होते हैं।
  • IMPORTSएक फ़ाइल दूसरी फ़ाइल का इस्तेमाल करती है।
  • AFFECTSएक टास्क किसी फ़ाइल को छूता है।
  • CO_CHANGEDदो फ़ाइलें, जो अक्सर साथ बदलती हैं, कोड के इतिहास में दिखता है।
  • SYNAPSEनोट, निर्णय और फ़ाइलों के बीच का जुड़ाव। जिन जुड़ावों का कोई इस्तेमाल नहीं करता, वे धीरे-धीरे मिट जाते हैं।

आज़माएँ

देखें, असिस्टेंट PO के साथ कैसे काम करता है

कोई अनुरोध चुनें। आपको जवाब सीधी भाषा में दिखेगा, और परदे के पीछे असिस्टेंट PO को जो कॉल करता है, वे भी। किसी कॉल को खोलकर उसका ब्योरा देखें।

Chat · team-weekendनकली डेमो
Organize a weekend in June for my team of 12. We want a quiet place near a train station.

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 से अपने असिस्टेंट को जोड़ें, और अपने पहले एजेंट को कोई लाइन लिखने से पहले प्रोजेक्ट पढ़ने दें।

ऐप मुफ़्त है। आप सिर्फ़ वही AI चुकाते हैं जो आप पहले से इस्तेमाल करते हैं, जैसे आपकी अपनी Claude Code सदस्यता या किसी और मॉडल की कुंजी। देखें कितना खर्च आता है

या टर्मिनल से शुरू करें

brew install this-rs/tap/project-orchestrator