Skip to content

Agent निर्णय: स्किल चुनना, फ़ंक्शन कॉल में बदलना ​

💡 एक वाक्य सारांश: Jev से Agent निर्णय संभालें — एक Choice 194 स्किलों की रैंकिंग करता है, दो गेट तय करते हैं कि कुछ कहना है या नहीं, प्राकृतिक भाषा के अनुरोध पैरामीटर हमेशा वैध रखने वाले टाइप किए गए फ़ंक्शन कॉल में बदलते हैं।

agent को कौन सी स्किल लोड करनी चाहिए, कौन सा फ़ंक्शन कॉल करना चाहिए — ऐसे प्रश्न LLM को दें, तो मिलता है एक ऐसा टेक्स्ट जिसे फिर पार्स करना पड़ता है; Jev को दें, तो मिलता है टाइप किया गया उत्तर + प्रायिकताएँ, निर्णय का अधिकार आपके कोड में रहता है।

आधिकारिक रूप से दो cookbook से इस Jev Agent निर्णय रेसिपी को खोला गया: Skill suggestion 194 स्किलों वाले agent के लिए स्किल जांच देता है, Function calling प्राकृतिक भाषा के ट्रेड अनुरोधों को सामान्य टाइप किए गए फ़ंक्शनों के कॉल में बदलता है। दोनों एक ही दर्शन साझा करते हैं: Jev निर्णय करता है, कोड फ़ैसला लेता है।

text
उपयोगकर्ता का इस टर्न का अनुरोध
        │
        ▼  TypeSafe अनुरोध 1 (रैंकिंग + गेट, एक ही state का समानांतर मूल्यांकन)
┌──────────────────────────────────────────────┐
│ एक Choice: 194 स्किलों में से कौन सी?               │
│   → probabilities ही रैंकिंग हैं, कोड टॉप-3 लेता है        │
│ तीन Noul: क्या कुछ करना है (तीन अलग-अलग पूछताछ)          │
│ एक Noul: क्या किसी विशिष्ट टूल / टेम्पलेट / विधि का नाम लिया गया?   │
└──────────────────────────────────────────────┘
        │
        ▼  कोड: gate ≥ 0.30 या named ≥ 0.50?
   नहीं ──┤── सुझाव: कुछ भी लोड न करें (और एक वाक्य «कोई संबंधित स्किल नहीं» भेजना होगा)
        │ हाँ
        ▼  TypeSafe अनुरोध 2 (केवल टॉप-3, पूरा विवरण + SKILL.md की शुरुआत के साथ)
┌──────────────────────────────────────────────┐
│ एक Choice: तीन में से असल में कौन सी?               │
│ तीन Noul: क्या यह स्किल सच में यह काम करती है? (हर एक अपना उत्तर देता है) │
└──────────────────────────────────────────────┘
        │
        ▼  कोड: सबसे अच्छा fits ≥ 0.30?
   नहीं ──┤── सुझाव: कुछ भी लोड न करें
        │ हाँ
        ▼
<skill_relevance> ब्लॉक roster के बाद जोड़ा जाता है → agent अपना निर्णय बनाए रखता है

agent के निर्णय से पहले एक और निर्णय क्यों रखें? आधिकारिक रूप से सीधे कहा गया: बड़े स्किल कैटलॉग वाला agent लगभग बिना जानकारी के चुनाव करता है — कैटलॉग इंडेक्स रूप में पहुँचता है, हर पंक्ति में एक स्किल, विवरण काटा जाता है ताकि बातचीत न रुके; 60 अक्षरों पर काटने के बाद, .pptx संपादित करने वाली Office स्किल और deck बनाने वाली वित्तीय स्किल दोनों «PowerPoint टूल» लगती हैं। जिस टर्न में कोई उपयुक्त स्किल है ही नहीं, वहाँ भी वह ज़बरदस्ती एक लोड कर सकता है, क्योंकि नामों की एक सूची खुद ही अंदाज़ा लगाने के लिए उकसाती है।

यह पाठ लगभग 20 मिनट का है। पेज के सभी परीक्षण आँकड़े आधिकारिक cookbook के रिकॉर्डिंग डेटा से हैं: स्किल सुझाव के लिए jev-1.14.0 (परीक्षित agent claude-haiku-4-5-20251001, 2026-10-30 रेंडरिंग), फ़ंक्शन कॉल के लिए jev-1.12; रिकॉर्डिंग फ़ाइलें आधिकारिक रिपॉज़िटरी के साथ जारी हैं, बिना key भी रिप्ले करके जाँची जा सकती हैं।

सीखने के बाद आप क्या कर सकते हैं ​

  • स्किल-आधारित agent में एक «कौन सी स्किल लोड करें» जांच जोड़ें: दो अनुरोध (पहले एक Choice 194 स्किलों की रैंकिंग, फिर टॉप-3 की समीक्षा), आधिकारिक परीक्षण में गलत लोडिंग 15.7% → 7.9%, बेकार लोडिंग 14.0% → 5.2%
  • suggest() लिखें: अधिकतम एक स्किल नाम लौटाए, suggestion_block() से <skill_relevance> ब्लॉक में लपेटकर system prompt में जोड़ें — agent के पास पूरा इंडेक्स और अपना निर्णय रहता है, सुझाव केवल यह कहता है कि «पहले कौन सी देखें»
  • प्राकृतिक भाषा के अनुरोधों को टाइप किए गए फ़ंक्शन कॉल में बदलें: closed_sets फ़ंक्शन सिग्नेचर पढ़ता है, Literal → Choice, list[Literal[...]] → हर सदस्य के लिए एक Noul, bool → Noul, 54 प्रश्न एक ही अनुरोध में पूछे जाते हैं, फ़ंक्शन में हमेशा सिग्नेचर के वैध मान ही जाते हैं
  • दो तरह के confidence उपयोग समझें: फ़ंक्शन कॉल का confidence = पूरी कॉल का सबसे अनिश्चित निर्णय (एक गलत पैरामीटर पूरा नुकसान करता है); स्किल चुनते समय जब केवल «सर्वोत्तम चुनना» हो तो सीधे सबसे अधिक प्रायिकता वाला विकल्प लें, हर जगह confidence सीमा लगाने की ज़रूरत नहीं

Jev का उपयोग क्यों करें, agent को खुद चुनने क्यों न छोड़ें? ​

क्षमताLLM इंडेक्स से खुद चुनता है / JSON जनरेट करता हैJev संरचित निर्णय
«deck बनाने वाली» और «deck बदलने वाली» में अंतर कर पाता है❌ इंडेक्स विवरण 60 अक्षरों पर काटा जाता है, दोनों .pptx स्किलें PowerPoint टूल पढ़ी जाती हैं, आधिकारिक परीक्षण में 15.7% गलत लोडिंग✅ समीक्षा अनुरोध पूरा विवरण + SKILL.md की शुरुआत 700 अक्षरों के साथ ले जाता है, deck अनुरोध pptx-author से microsoft-office पर पलट गया
उपयुक्त स्किल न होने पर चुप रह सकता है❌ नामों की सूची अंधे अंदाज़े के लिए उकसाती है, आधिकारिक परीक्षण में 14.0% ज़बरदस्ती लोडिंग✅ चार Noul द्वार पर, समीक्षा में सभी असफल हों तो सुझाव «कुछ भी लोड न करें» (5.2%)
फ़ंक्शन पैरामीटर वैध हैं❌ LLM JSON जनरेट करता है जिसे फिर पार्स किया जाता है, फ़ील्ड मान बनाए जा सकते हैं, पार्सिंग कोड बढ़ता जाता है✅ बंद-सेट पैरामीटर Choice / Noul में मैप होते हैं, आधिकारिक कथन: फ़ंक्शन में केवल वही मान जाते हैं जो फ़ंक्शन स्वीकार करता है
कितना भरोसा हो तो निष्पादित करें❌ LLM की स्वयं-घोषित confidence सिर्फ टेक्स्ट है, इसे फिर से parse करना पड़ता है✅ RLCD कैलिब्रेशन ट्रेनिंग (चिह्नित 0.2 वाली घटनाएँ लंबी रन में लगभग 20% बार होती हैं), confidence = सबसे कमज़ोर वह निर्णय, थ्रेशोल्ड से नीचे हो तो पुष्टि पर भेजें
नीति में बदलाव करना❌ prompt बदलो, पूरा दोबारा चलाओ, review के समय पलट नहीं पाते✅ दो थ्रेशोल्ड + प्रश्न की शब्दावली कोड के constants में केंद्रित हैं, आधिकारिक सलाह है कि एक फ़ाइल में रखें ताकि मानव-समीक्षा आसान हो

आपकी मौजूदा दुविधा ​

  • 「agent पर 194 स्किल्स लगी हैं, इंडेक्स में हर विवरण सिर्फ 60 अक्षरों का है——मौजूदा deck में बदलाव करने को कहा, तो उसने नई deck बनाने वाली स्किल लोड कर ली; जिन टर्न में कोई उपयुक्त स्किल ही नहीं थी, वहाँ भी उसने ज़बरदस्ती एक लोड कर ली」
  • 「फ़ंक्शन कॉल LLM से JSON बनवाकर parse करने पर टिकी है, पैरामीटर मान कभी-कभी गढ़ लिए जाते हैं, फ़ील्ड नाम मेल नहीं खाते, और parsing कोड परत दर परत मोटा होता जा रहा है」
  • 「चाहते हैं कि मॉडल खुद तय करे 『अगला कदम क्या हो』, जवाब टेक्स्ट का एक टुकड़ा होता है, थ्रेशोल्ड, retry, fallback सब prompt में बिखरे हैं, review के समय पलट नहीं पाते」

यह तरीक़ा कब अपनाएँ ​

जब आपको चाहिए:

  • agent की स्किल / टूल कैटलॉग इतना बड़ा हो कि विवरण कटने लगें, और ग़लत लोड व बेकार लोड विश्वसनीयता खा रहे हों
  • उपयोगकर्ता की प्राकृतिक भाषा की रिक्वेस्ट को पहले से मौजूद typed फ़ंक्शन के कॉल में बदलना, पैरामीटर निश्चित सूची से आएँ
  • 『क्या करना चाहिए』 का थ्रेशोल्ड साफ़-साफ़ कोड में रखना, नीति बदलने के लिए prompt दोबारा न लिखना पड़े

और नहीं चाहते:

  • पूरी कैटलॉग का पूरा टेक्स्ट system prompt में ठूँसना——आधिकारिक मूल शब्द: इससे स्किल चयन ख़राब हो जाता है और सत्र के बाक़ी हिस्से में context rot आ जाता है
  • हर टर्न में एक पूरी LLM जनरेशन कॉल का ख़र्च न्यायाधीश के तौर पर अतिरिक्त चुकाना
  • LLM के थूके JSON को parse करना

🎒 शुरू करने से पहले की तैयारी ​

  • पूरा कर लिया Choice बहुविकल्पीय प्रश्न: पता है criteria विकल्प map और probabilities——इस पृष्ठ की पहली रिक्वेस्ट ही 194 विकल्पों वाला एक Choice है (सीमा 255)
  • पूरा कर लिया समानांतर प्रश्न और स्पेकुलेटिव फ़ैन-आउट: पता है कि 「कोड को अगली रिक्वेस्ट बनाने के लिए पिछला जवाब चाहिए」 तभी असली dependency मानी जाती है——इस पृष्ठ की दोनों रिक्वेस्ट आधिकारिक तीन सच्ची दूसरी-रिक्वेस्ट केसेज़ में से एक हैं
  • चला लियाइंस्टॉलेशन और पहली रिक्वेस्ट: .venv में typesafe-sdk है, TYPESAFE_API_KEY environment variables में है
  • (वैकल्पिक, बिना key पुनरुत्पादन) आधिकारिक डेटा डाउनलोड करें: typesafe-public-examples रिपॉज़िटरी के cookbooks/skill_suggestion डायरेक्टरी के नीचे hermes_roster.json, requests.json, json_cache.json, और cookbooks/function_calling डायरेक्टरी के नीचे trader.py, dispatch.py, spec.json, json_cache.json——आधिकारिक कोड जैसा है वैसा ही चलाएँ, एक भी key नहीं चाहिए
  • स्किल सुझाव का पूरा वास्तविक परीक्षण (चरण 4) चलाना हो तभी ANTHROPIC_API_KEY चाहिए: परीक्षण के तहत agent Anthropic मॉडल है; सिर्फ़ चरण 2, 3 का suggest() करना हो तो TYPESAFE_API_KEY अकेला काफ़ी है
  • इस पृष्ठ के आँकड़ों का स्रोत जानना: स्किल सुझाव रिकॉर्डिंग jev-1.14.0 (2026-10-30 रेंडर) से है, फ़ंक्शन कॉल रिकॉर्डिंग jev-1.12 से; आप अभी live चलाएँगे तो jev-latest (फ़िलहाल jev-1.14.0 की ओर इशारा) उपयोग होगा, संभावनाएँ अलग होंगी——अपने lock किए संस्करण के हिसाब से थ्रेशोल्ड ठीक करें

मेरे साथ करें ​

चरण 1: स्किल कैटलॉग और नंगे agent का बेसलाइन समझना (60 अक्षर इंडेक्स की विफलता-शैली) ​

क्यों: आधिकारिक रूप से पहले 「agent खुद चुने」 की विफलता-शैली सामने रखी गई: Hermes की 194 स्किल्स इंडेक्स रूप में system prompt में जाती हैं, हर पंक्ति में एक स्किल, विवरण 60 अक्षरों पर कटा हुआ।

पहले दोनों cookbook का डेटा working directory में खींचें (dependencies दो पंक्तियों में जुट जाती हैं: दोनों तरफ़ की आधिकारिक pip पंक्तियों में मूलतः typesafe-sdk नहीं था, यहाँ जोड़ा गया है):

bash
mkdir agent-decisions && cd agent-decisions
base=https://raw.githubusercontent.com/typesafe-ai/typesafe-public-examples/main/cookbooks
curl -sLO $base/skill_suggestion/hermes_roster.json
curl -sLO $base/skill_suggestion/requests.json
curl -sLO $base/skill_suggestion/json_cache.json
curl -sLO $base/function_calling/trader.py
curl -sLO $base/function_calling/dispatch.py
curl -sLO $base/function_calling/spec.json
curl -sLO $base/function_calling/json_cache.json
pip install typesafe-sdk anthropic matplotlib ipython polars numpy 'cooksafe>=0.2.0,<0.3.0'

hermes_roster.json NousResearch/hermes-agent की एक pin किए commit पर 194 स्किल्स है: हर रिकॉर्ड में name, category, इंडेक्स जैसा कटा विवरण, पूरा विवरण, और SKILL.md की शुरुआत है। लोड करें और आधिकारिक सांख्यिकी आउटपुट देखें (आधिकारिक Step 1 यूनिट से अंश):

python
import json
from collections import defaultdict
from pathlib import Path

ROSTER = json.loads(Path("hermes_roster.json").read_text(encoding="utf-8"))
BY_NAME = {skill["name"]: skill for skill in ROSTER}

def render_index() -> str:
    """The body of <available_skills>: skills grouped by category, both sorted by name."""
    by_category = defaultdict(list)
    for skill in ROSTER:
        by_category[skill["category"]].append(skill)
    lines = []
    for category in sorted(by_category):
        skills = sorted(by_category[category], key=lambda s: s["name"])
        if len(skills) == 1:  # a one-skill category is a single top-level row
            lines.append(f"  - {skills[0]['name']}: {skills[0]['description']}")
            continue
        lines.append(f"  {category}:")
        lines.extend(f"    - {skill['name']}: {skill['description']}" for skill in skills)
    return "\n".join(lines)

widths = [len(skill["description"]) for skill in ROSTER]
print(f"{len(ROSTER)} skills in {len({s['category'] for s in ROSTER})} categories")
print(f"index description: {sum(widths) / len(widths):.0f} characters on average, "
      f"{max(widths)} at most")

आपको यह दिखना चाहिए(आधिकारिक रिलीज़):

text
194 skills in 32 categories
index description: 55 characters on average, 60 at most

requests.json 452 सिंगल-टर्न रिक्वेस्ट है: 280 ठीक एक स्किल से कवर होती हैं (145 अलग स्किल्स), 172 किसी स्किल से कवर नहीं होतीं। कवर की गई रिक्वेस्ट Claude Sonnet 5 ने हर स्किल के अपने SKILL.md से लिखीं; 172 न कवर वाली सब 「अंधेरा अंदाज़ा लगाने पर दंड」 के लिए लिखी गई हैं——84 रोज़मर्रा की रिक्वेस्ट, 42 ऐसी तकनीकी प्रश्न जिनके लिए कोई स्किल नहीं है (explain what a monad is), 46 ऐसी जो कैटलॉग में न होने वाली चीज़ माँगती हैं (कैटलॉग सिर्फ़ X कवर करते समय post this to Mastodon)।

नंगे agent का बेसलाइन (452 रिक्वेस्ट एक-एक कर चलाई गईं, परीक्षण के तहत मॉडल pin किया गया claude-haiku-4-5-20251001):

text
wrong loads    15.7%   (280 covered requests)
needless loads 14.0%   (172 uncovered requests)

of 26 wrong first picks, 11 came from the right skill's own category

दोनों मीट्रिक त्रुटि-दर हैं, जितना कम उतना अच्छा: wrong load यह है कि कवर की गई रिक्वेस्ट में पहली skill_view कॉल कवर करने वाली स्किल नहीं थी (बिल्कुल लोड न होना भी गिना जाता है); needless load यह है कि न कवर वाली रिक्वेस्ट में skill_view कॉल हुआ। 26 ग़लत लोड में 11 सही स्किल के ही category में पड़े——agent ने मोटे तौर पर सही जगह देखी, मुश्किल कई एक-जैसे दिखने वालों को अलग करना है।

💡 यही 「ग़लत परत पर पूछने」 का रूप है

आधिकारिक Agent Skill का SKILL.md बात सीधे कहता है: ऐसे प्रश्न जो Jev से सीधे फ़ैसला करवाते हैं (「क्या इस टिकट को escalate करना चाहिए?」「agent का अगला कदम क्या हो?」) आमतौर पर दिखाते हैं कि प्रश्न ग़लत परत पर पूछा गया है——फ़ैसले को उसकी dependencies वाले निर्णयों में तोड़ें, फ़ैसला खुद कोड में लिखें, दिखने वाला और परखने लायक़। पूरा दर्शन देखें साथ Claude Code के विकास में, इस पृष्ठ पर पूरा यही किया गया है: Jev रैंकिंग और जाँच करता है, कोड के पास थ्रेशोल्ड और 「हाँ कहें या नहीं」 का फ़ैसला है।

  • मैं बता सकता हूँ कि दोनों बेसलाइन त्रुटि-दरें क्या मापती हैं, और 26 ग़लत लोड में से 11 सही स्किल के ही category से आने का क्या मतलब है

चरण 2: पहली रिक्वेस्ट——एक Choice 194 स्किल्स की रैंकिंग, चार Noul द्वार पर ​

क्यों: रैंकिंग और 「इस टर्न में स्किल चाहिए या नहीं」 दोनों निर्णय एक ही state साझा करते हैं, आधिकारिक रूप से उन्हें एक ही रिक्वेस्ट में रखा गया——Choice की probabilities ही रैंकिंग हैं, चार Noul द्वार का काम करती हैं।

एक Choice में 194 विकल्प आराम से समा जाते हैं (सीमा 255); आधिकारिक रूप से यह भी कहा गया: कुछ गुना और बड़ा हो तो खंडों में रैंक करें, खंड-विजेताओं की दोबारा रैंकिंग करें। विकल्पों के criteria के लिए वही इंडेक्स विवरण उपयोग करें जो agent खुद देखता है (वही टेक्स्ट), प्रश्न का instructions मूल इस प्रकार है:

python
CHOICE_INSTRUCTIONS = (
    "Which of these skills, if any, is the right one to load to help with the "
    "user's latest request?"
)

द्वार चार Noul हैं: तीन अलग-अलग नज़रियों से पूछती हैं 「इस टर्न में कुछ करना है क्या」, और एक पूछती है 「किसी ठोस तरीक़े का नाम लिया गया है क्या」——किसी टर्न में स्किल चाहिए होने के सिर्फ़ दो कारण हैं: या तो उपयोगकर्ता की फ़ाइलों / खाते / डिवाइस पर कुछ करना है, या किसी स्किल के पास मौजूद तरीक़े का नाम लिया गया है (meme टेम्पलेट, Suno प्रॉम्प्ट)।

python
GATE_QUESTIONS = {
    "acts_on_user_system": (
        "Is the assistant being asked to act on the user's files, accounts, devices, "
        "or online services, rather than only to explain or advise?"
    ),
    "would_follow_documented_procedure": (
        "Would a careful expert answering this consult a specific documented procedure "
        "or set of commands, rather than answering from general understanding?"
    ),
    "prose_suffices": (
        "Could a knowledgeable generalist fully satisfy this request in prose, with "
        "no tools, no documentation, and no access to the user's files or accounts?"
    ),
}
INVERTED = {"prose_suffices"}  # a yes here points away from needing a skill
NAMED_QUESTION = (
    "Does the request ask for a specific named tool, format, template, or method to be "
    "used, rather than for general help?"
)

GATE_THRESHOLD = 0.30   # mean of the three action nouls; at or above it, a skill is wanted
NAMED_THRESHOLD = 0.50   # the "names a method" noul; at or above it, a skill is wanted too

def build_state(request: str) -> dict:
    return {"request": request, "recent_context": ""}

@json_cache
def rank_wide(request: str) -> dict:
    """Request 1: rank all 194 skills, and score the request for whether a skill applies."""
    questions = {
        "which": Choice(
            instructions=CHOICE_INSTRUCTIONS,
            criteria={skill["name"]: skill["description"] for skill in ROSTER},
        )
    }
    for key, text in GATE_QUESTIONS.items():
        questions[f"gate::{key}"] = Noul(instructions=text)
    questions["named"] = Noul(instructions=NAMED_QUESTION)
    response = client.system_one(
        state=build_state(request), questions=questions, model=TYPESAFE_MODEL
    )
    ranked = sorted(
        response.answers["which"].probabilities.items(), key=lambda kv: -kv[1]
    )
    values = {
        key.removeprefix("gate::"): answer.noul
        for key, answer in response.answers.items()
        if key.startswith("gate::")
    }
    oriented = [(1.0 - v) if k in INVERTED else v for k, v in values.items()]
    return {
        "ranked": ranked[:12],
        "gate": sum(oriented) / len(oriented),
        "named": response.answers["named"].noul,
    }

def needs_skill(wide: dict) -> bool:
    """Either reason is enough: an action is wanted, or a named method is asked for."""
    return wide["gate"] >= GATE_THRESHOLD or wide["named"] >= NAMED_THRESHOLD

तीन design बिंदुओं पर नज़र रखने लायक़ है:

  • क्रिया-प्रश्न पूछता है 「कुछ करना है या नहीं」, नहीं पूछता 「विषय क्या है」. विषय-प्रश्न explain what a monad is और स्किल चाहिए वाली रिक्वेस्ट को अलग नहीं कर पाता——दोनों सॉफ़्टवेयर हैं।
  • prose_suffices एक उलटा प्रश्न है: इसका yes जवाब देना ठीक इसका संकेत है कि किसी कौशल की ज़रूरत नहीं है, इसलिए 1.0 - v लेकर औसत में डालें।
  • named औसत में नहीं जाता, अलग से दरवाज़ा खोलता है। आधिकारिक मूल शब्द: तीन क्रिया उत्तर इसे outvote कर देंगे; जिस राउंड में कोई विधि नाम ली जाती है लेकिन हाथ नहीं आता (meme बनाना), वहाँ सिर्फ़ यही उसे बचा सकता है।

needs_skill सत्यता-सारणी के दो इनपुट हैं: क्रिया गेट का औसत ≥ 0.30 या नाम-लेना ≥ 0.50, कोई भी एक पार हो तो आगे बढ़ें; दोनों नीचे हों तो कुछ भी लोड न करने की सलाह दें।

आधिकारिक चार DEMO अनुरोधों पर एक बार चलाएँ (आउटपुट आधिकारिक प्रकाशित मान हैं):

text
"Can you save this recipe as a new note in my 'Recipes' folder in Notes.app so "
  action 0.83, names a method 0.88 -> suggest   (0.14s)
    0.990  apple-notes                           Manage Apple Notes via memo CLI: create, search, edit.
    0.010  computer-use                          Drive the desktop background-first; escalate on signal.
    0.000  apple-reminders                       Apple Reminders via remindctl: add, list, complete.

"I've got a client pitch deck as a .pptx template - I need to duplicate slide 4"
  action 0.73, names a method 0.64 -> suggest   (0.25s)
    0.730  pptx-author                           Build PowerPoint decks headless with python-pptx.
    0.270  microsoft-office                      Create, read, and edit Word, PowerPoint, and Excel files.
    0.000  apple-notes                           Manage Apple Notes via memo CLI: create, search, edit.

"Post this announcement to my Mastodon account."
  action 0.86, names a method 0.61 -> suggest   (0.1s)
    0.280  xurl                                  X/Twitter via xurl CLI: raw post search, posting, DM, media.
    0.240  social-media-content-calendar         Plan multi-platform social campaigns: briefs to posting.
    0.190  computer-use                          Drive the desktop background-first; escalate on signal.

"Can you make me a Gru's Plan meme about a developer's plan to refactor the cod"
  action 0.12, names a method 0.87 -> suggest   (0.12s)
    1.000  meme-generation                       Create meme PNGs from templates with Pillow text overlay.
    0.000  apple-notes                           Manage Apple Notes via memo CLI: create, search, edit.
    0.000  apple-reminders                       Apple Reminders via remindctl: add, list, complete.

चारों अलग-अलग एक बात बताते हैं: Notes अनुरोध में कोई अस्पष्टता नहीं है, शीर्ष पर जो है वही सही है; deck अनुरोध में दो .pptx कौशल आगे हैं, लेकिन 60 अक्षरों के विवरण में deck बनाने वाला pptx-author पहले आता है—एक ऐसे अनुरोध के लिए जो मौजूदा deck को बदलना चाहता है, यही ग़लती का संकेत है; Mastodon अनुरोध में क्रिया गेट 0.86 होते हुए भी आगे निकलता है (पोस्ट करना एक क्रिया है), लेकिन शीर्ष xurl X पर पोस्ट करने वाला कौशल है—रैंकिंग उस चीज़ को नहीं बचा सकती जो कैटलॉग में है ही नहीं; meme अनुरोध में क्रिया गेट 0.12 बहुत नीचे है, पूरा दरवाज़ा named 0.87 खोलता है, और शीर्ष पर ठीक meme कौशल है।

💡 यही Jev का अनन्य मूल्य है

रैंकिंग (एक Choice) और गेट (चार Noul) एक ही अनुरोध में एक ही state पर समानांतर, स्वतंत्र मूल्यांकन करते हैं—प्रश्न जोड़ने से प्रतिक्रिया समय लगभग नहीं बढ़ता, सिर्फ़ कुछ प्रश्नों के token खर्च होते हैं। आधिकारिक रिकॉर्डिंग में पहला अनुरोध 0.1–0.25 सेकंड। "हर राउंड में एक LLM न्यायाधीश बैठाने" से तुलना करें: उसमें रैंकिंग और जाँच दोनों के लिए पूरी जनरेशन कॉल देनी पड़ती है, साथ ही न्यायाधीश का थूका टेक्स्ट पार्स करना पड़ता है। एक अनुरोध में कई प्रश्नों की क्रियाविधि देखें समानांतर प्रश्न और सट्टा फैन-आउट।

💡 चीनी सामग्री के प्रति सावधानी

आधिकारिक स्पष्टीकरण: अंग्रेज़ी Jev की मुख्य प्रशिक्षण भाषा है; चीनी समेत अन्य भाषाएँ चलती हैं लेकिन सटीकता कम होती है। ऊपर के सभी प्रश्नों को अंग्रेज़ी मूल रूप में रखने की सलाह है (आधिकारिक शब्दावली परीक्षण से गुज़री है); चीनी अनुरोधों के लिए कौशल सुझाव देने हों तो पहले अपने डेटा पर एक बैच चलाएँ, प्रायिकता वितरण देखें और तब दहलीज़ तय करें।

आपको यह दिखना चाहिए: चारों DEMO के गेट / रैंकिंग ऊपर की तालिका से मेल खाते हैं (कैश रीप्ले में बिट-दर-बिट समान; live चलाने पर प्रायिकताओं में अंतर आएगा, दिशा आपके लॉक किए संस्करण के अनुसार मान्य होगी)।

चरण 3: दूसरा अनुरोध—शीर्ष तीन की पुनः जाँच, सबके निराश होने की अनुमति ​

क्यों: यह आधिकारिक तीन "सच्चे दो-अनुरोध" केसों में से एक है: कोड को पहले अनुरोध की रैंकिंग मिलनी ही चाहिए, तभी दूसरे अनुरोध के विकल्प बन पाते हैं—शीर्ष तीन में से हर एक के साथ पूरा विवरण और SKILL.md की शुरुआत।

समानांतर प्रश्न का सिद्धांत है "जो साथ पूछे जा सकें, साथ पूछो", फिर यहाँ दूसरा अनुरोध क्यों भेजा जाता है? क्योंकि दूसरे प्रश्न के विकल्प पहले प्रश्न के उत्तर पर निर्भर हैं: हर उम्मीदवार के साथ description_full और body की शुरुआत के 700 अक्षर (roster फ़ाइल में हर प्रविष्टि 1600 अक्षर संग्रहीत करती है) भेजने हैं, और ये लंबे टेक्स्ट पता चलने के बाद ही—कि शीर्ष तीन कौन हैं—criteria में जुड़ सकते हैं। आधिकारिक primitives दस्तावेज़ इस cookbook को सच्चा दो-अनुरोध नाम देता है: एक अनुरोध में सभी कौशलों की रैंकिंग, फिर शीर्ष तीन का पूरा टेक्स्ट लेकर बेहतर सबूत के सामने दोबारा निर्णय।

python
SHORTLIST = 3       # candidates carried from the first request into the second
EXCERPT_CHARS = 700  # SKILL.md characters each candidate brings; the roster file stores 1600
FITS_THRESHOLD = 0.30  # a shortlist whose best "does this fit" noul is under this is dropped

RERANK_INSTRUCTIONS = (
    "Exactly one of these skills is the right one to load for the user's latest "
    "request. Which one? Read what each actually does, not just its name."
)

def rerank_questions(names, excerpt):
    questions = {
        "which": Choice(
            instructions=RERANK_INSTRUCTIONS,
            criteria={
                name: f"{BY_NAME[name]['description_full']} — {BY_NAME[name]['body'][:excerpt]}"
                for name in names
            },
        )
    }
    for name in names:
        questions[f"fits::{name}"] = Noul(
            instructions=(
                f"Does the skill '{name}' do the specific thing the user's request asks "
                f"for? It is described as: {BY_NAME[name]['description_full']}"
            )
        )
    return questions

@json_cache
def rerank(request, names, excerpt):
    """Request 2: the same Choice over a shortlist, plus one absolute noul per candidate."""
    response = client.system_one(
        state=build_state(request),
        questions=rerank_questions(names, excerpt),
        model=TYPESAFE_MODEL,
    )
    return {
        "winner": response.answers["which"].choice,
        "fits": {
            key.removeprefix("fits::"): answer.noul
            for key, answer in response.answers.items()
            if key.startswith("fits::")
        },
    }

fits तीनों Noul अपने-अपने उत्तर देते हैं और सब नीचे हो सकते हैं—वे और which अलग-अलग बातें तय करते हैं: which तय करता है "तीन में से कौन", fits तय करता है "आख़िर कहना है या नहीं"। चारों DEMO को पूरा चलाएँ (आधिकारिक प्रकाशित मान):

text
"Can you save this recipe as a new note in my 'Recipes' folder in Notes.app so "
  was apple-notes -> apple-notes   (0.11s)
    fits 0.81  apple-notes
    fits 0.50  computer-use
    fits 0.02  apple-reminders

"I've got a client pitch deck as a .pptx template - I need to duplicate slide 4"
  was pptx-author -> microsoft-office   (0.11s)
    fits 0.77  pptx-author
    fits 0.76  microsoft-office
    fits 0.01  apple-notes

"Post this announcement to my Mastodon account."
  was xurl -> nothing fits   (0.07s)
    fits 0.10  xurl
    fits 0.27  social-media-content-calendar
    fits 0.28  computer-use

"Can you make me a Gru's Plan meme about a developer's plan to refactor the cod"
  was meme-generation -> meme-generation   (0.16s)
    fits 0.84  meme-generation
    fits 0.03  apple-notes
    fits 0.01  apple-reminders

.pptx का नामचीन दृश्य दूसरे अनुरोध में पलटता है: दो कौशल अलग होकर अपना-अपना पूरा टेक्स्ट लाते हैं, और deck अनुरोध pptx-author से पलटकर मौजूदा फ़ाइलें संपादित करने वाले microsoft-office पर आता है। ध्यान दें कि इसके fits दोनों नीचे नहीं हैं (0.77 / 0.76—दोनों deck पर कुछ-न-कुछ कर सकते हैं), लेकिन यह प्रश्न "कौन" नहीं तय करता; पलटाव Choice से आया।

Mastodon अनुरोध दूसरे प्रश्न पर रुक जाता है: तीनों मिलते-जुलते कौशलों में से कोई सचमुच यह काम नहीं करता, सबसे अच्छे का fits 0.28 भी 0.30 से नीचे है, पूरा समूह छोड़ दिया जाता है—यह अनुरोध दोनों बार गेट में घुसा, फिर भी अंत में कुछ भी लोड न करने की सलाह बनी; यही "सबके निराश होने की अनुमति" का अर्थ है।

दोनों अनुरोधों और दोनों दहलीज़ों को एक फ़ंक्शन में समेटें—पूरी रेसिपी बस इतनी ही है:

python
def suggest(request: str) -> tuple[str, ...]:
    """At most one skill name for a request, or () for "nothing here applies"."""
    wide = rank_wide(request)
    if not needs_skill(wide):
        return ()
    shortlist = tuple(name for name, _ in wide["ranked"][:SHORTLIST])
    result = rerank(request, shortlist, EXCERPT_CHARS)
    if max(result["fits"].values()) < FITS_THRESHOLD:
        return ()
    return (result["winner"],)

def suggestion_block(names: tuple[str, ...]) -> str:
    """What gets appended after the roster, in the suggestion."""
    body = (
        f"Relevant to the current request: {', '.join(names)}. Ignore this if it does not "
        "fit what the user actually asked for."
        if names
        else "No skill in the roster appears relevant to this request."
    )
    return f"\n\n<skill_relevance>\n{body}\n</skill_relevance>"

print(suggestion_block(suggest(DEMO[1])))
print(suggestion_block(suggest(DEMO[2])))

आपको यह दिखना चाहिए:

text
<skill_relevance>
Relevant to the current request: microsoft-office. Ignore this if it does not fit what the user actually asked for.
</skill_relevance>

<skill_relevance>
No skill in the roster appears relevant to this request.
</skill_relevance>

विजेता का नाम system prompt की सिर्फ़ एक पंक्ति में जाता है। agent के पास पूरा सूचकांक और अपना निर्णय बना रहता है; वह पंक्ति सिर्फ़ बताती है "पहले कौन-सी देखें"। दोनों शब्दावली-सूक्ष्मताएँ परीक्षण से निकली हैं (आधिकारिक मूल शब्द):

  • सलाह में "नज़रअंदाज़ किया जा सकता है" लिखा है: सलाह को और कसने पर ग़लत सलाह की मानने की दर भी साथ बढ़ती है—और एक ग़लत सलाह, सलाह न होने से भी बदतर है।
  • कोई सलाह न हो तब भी एक वाक्य "कोई संबंधित कौशल नहीं" भेजें: कुछ न भेजें तो roster का अपना वह निर्देश—"ज़्यादा लोड करना बेहतर"—बिना मुक़ाबले के रह जाता है।

साथ ही स्थान पर ध्यान दें: सलाह-ब्लॉक roster के बाद जुड़ता है, उसके भीतर नहीं—roster टेक्स्ट हर राउंड में समान रहे, तभी prefix caching काम कर पाती है।

  • मैं बता सकता हूँ कि दोनों अनुरोध क्या-क्या करते हैं और दो बार क्यों भेजना ज़रूरी है (दूसरे प्रश्न के विकल्प पहले प्रश्न के उत्तर से तय होते हैं)
  • Mastodon अनुरोध दोनों बार गेट पार करता है, फिर भी अंत में कुछ भी लोड न करने की सलाह बनती है—मैं बता सकता हूँ कि किस प्रश्न ने इसे रोका

चरण 4: हिसाब-किताब—452 अनुरोधों का तीन-भुजा मापन ​

क्यों: आधिकारिक तौर पर 452 अनुरोध तीन-तीन बार चलाए गए; तीनों भुजाएँ सिर्फ़ एक बात में अलग हैं: system prompt में roster के अलावा और क्या भरा गया।

system prompt में क्या भरा गया
agent alone (बेसलाइन)कुछ भी नहीं
agent with a suggestionsuggest() से लौटाया गया सलाह-ब्लॉक
agent given the answerसही कौशल का नाम; कोई कवरिंग कौशल न हो तो "nothing applies"

तीसरी भुजा फ़र्श है: किसी भी वास्तविक सिस्टम को पहले से कवरिंग कौशल का पता नहीं होता, इसलिए यह पहली दो भुजाओं के लिए निचली सीमा खींचती है—कोई भी कितना भी अच्छा चयन-तरीक़ा इससे नीचे नहीं जा सकता।

text
run         wrong loads  needless loads
baseline          15.7%           14.0%
TypeSafe           7.9%            5.2%
oracle             3.2%            4.1%

baseline -> TypeSafe:  2.0x fewer wrong loads, 2.7x fewer needless ones

आधिकारिक सारांश: ग़लत लोडिंग आधे से भी ज़्यादा कटी (15.7% → 7.9%), "काटे-मारे सूचकांक से अंदाज़ा" और "सीधा उत्तर पाना" के बीच के अंतर का आधे से ज़्यादा हिस्सा बंद हुआ; बेकार लोडिंग लगभग दो-तिहाई कटी (14.0% → 5.2%), अपने हिस्से का अंतर लगभग पूरा बंद हो गया।

क़ीमत भी सामने रखी गई: 280 कवरिंग अनुरोधों में सलाह ने 29 सुधारे, 7 बिगाड़े। कुछ अनुरोधों में agent ख़ुद पहले से सही था, एक आत्मविश्वासी ग़लत सलाह लगते ही वह भटक गया—आधिकारिक रूप से इसे राउंड से पहले एक सलाह रखने की क़ीमत कहा गया।

आपको यह दिखना चाहिए: तीन पंक्तियों और दो कॉलमों वाली त्रुटि-दर तालिका पिछली बार जैसी ही (कैश रिप्ले बिट-दर-बिट समान; live रन आपके लॉक किए गए संस्करण के अनुसार)।

  • मैं बता सकता हूँ कि तीनों भुजाएँ किसमें अलग हैं, oracle भागीदार नहीं बल्कि फ़्लोर क्यों है
  • मुझे पता है 7.9% मुफ़्त नहीं आता: 29 ठीक हुए, 7 बिगड़े, इसलिए सलाह के शब्दों में 「नज़रअंदाज़ किया जा सकता है」 जुड़ना चाहिए

चरण 5: फ़ंक्शन कॉल में बदलाव — closed_sets हस्ताक्षर पढ़ता है, 54 प्रश्न एक ही अनुरोध में ​

क्यों: उसी दर्शन का दूसरा अनुप्रयोग: फ़ंक्शन की एक पंक्ति भी नहीं छेड़ी जाती, बस एक spec जोड़ी जाती है — हर पैरामीटर के लिए एक प्रश्न, हर विकल्प के लिए एक पंक्ति का विवरण, हर फ़ंक्शन के लिए एक विवरण, साथ ही फ़ंक्शन चुनने का एक प्रश्न।

आधिकारिक रूपक सीधा है: आप 「बड़ा कप, बर्फ़, ओट मिल्क लाटे, बिना चीनी」 माँगते हैं, बैरिस्टा आपके मूल शब्द नहीं लिखता, बल्कि कप पर चार विकल्प टिक करता है। यह cookbook ट्रेडिंग API के साथ यही करता है — एक वाक्य अंदर, फ़ंक्शन का नाम और पैरामीटर मान बाहर, हर एक के साथ विश्वास-स्तर:

text
"plot rolling correlation between nvda and spy for the past month"
    rolling_correlation(symbol='NVDA', benchmark='SPY', window='1mo')   confidence 0.91

"compare nvda amd and msft over the past three months"
    compare_returns(symbols=['NVDA', 'AMD', 'MSFT'], window='3mo')      confidence 0.94

"show me apple daily with volume"
    plot_price(symbol='AAPL', resolution='1d', include_volume=True)     confidence 0.75

"what tickers do you have"
    list_symbols()                                                     confidence 1.00

trader.py में दस साधारण फ़ंक्शन हैं। जिन पैरामीटरों के मान निश्चित सूचियों से आते हैं, वे टाइप एनोटेशन में पहले से ही Literal हैं—closed_sets हस्ताक्षर पढ़कर भरने-योग्य पैरामीटरों को तीन आकारों में बाँटता है:

python
def plot_price(
    symbol: Literal["SPY", "NVDA", "AMD", "AAPL", "MSFT", "TSLA"],
    style: Literal["line", "candles"] = "line",
    resolution: Literal["1m", "5m", "15m", "1h", "1d"] = "15m",
    window: Literal["1d", "1w", "1mo", "3mo"] = "1w",
    include_volume: bool = False,
    moving_average: Literal["9", "20", "50"] | None = None,
    log_scale: bool = False,
): ...
आकृतिप्रकार एनोटेशनकिस प्रश्न में बदलता है
choiceLiteral[...]एक Choice, विकल्प ही वैध मान हैं
setlist[Literal[...]]हर सदस्य के लिए एक Noul ({} प्लेसहोल्डर की जगह सदस्य का नाम आता है)
flagboolएक Noul, ≥ 0.5 चालू माना जाता है

अन्य प्रकार—मुक्त पाठ, संख्या, तिथि—कोई प्रश्न नहीं बनाते, फ़ंक्शन का डिफ़ॉल्ट मान वैसे ही लागू रहता है: top_movers का तीसरा पैरामीटर limit: int = 3 कभी प्रश्न नहीं बनाता, हमेशा डिफ़ॉल्ट मान 3 ही रहता है।

spec में spec.json मौजूद है, जो एक वाक्य में बता देता है कि «उपयोगकर्ता का ऐसा कहने का क्या मतलब है»—Literal केवल "1mo" और "3mo" ये दो स्ट्रिंग देता है, यह नहीं बता सकता कि «this quarter» का तात्पर्य दूसरे से है। आधिकारिक रूप से एक और वाक्य छोड़ा गया है: spec LLM को सिग्नेचर से आपके लिए लिखने दे सकता है। rolling_correlation के दो समान-स्रोत पैरामीटरों के रोल-प्रश्न शब्दशः देखने लायक हैं:

json
"symbol": {
  "question": "Which stock is the user asking about - the one being measured, named first?",
  "options": { "SPY": "SPY, the S&P 500 index ETF, the market as a whole", "…": "…" }
},
"benchmark": {
  "question": "Which stock is it being compared against - the second one named, the yardstick?",
  "stated": "Does the user name a second symbol to compare against?",
  "options": { "SPY": "SPY, the S&P 500 index ETF, the market as a whole", "…": "…" }
}

symbol और benchmark एक ही छह-में-से-एक पूल से खींचते हैं, रोल-प्रश्नों के ज़रिए अपनी-अपनी जगह पर आते हैं—«जो मापा जा रहा है, जो पहले नाम लिया गया» बनाम «जो दूसरे नंबर पर नाम लिया गया, बेंचमार्क पैमाना»। विकल्पों की कुंजी ही वह स्ट्रिंग है जो फ़ंक्शन प्राप्त करता है, मैपिंग परत की ज़रूरत हट जाती है।

stated पैरामीटर को वैकल्पिक बनाता है: यह दूसरा हाँ/ना प्रश्न है, जो पूछता है «क्या कमांड में इस पैरामीटर का उल्लेख हुआ या नहीं»। उल्लेख न होने पर (0.5 से नीचे), पूरा पैरामीटर नहीं भरा जाता और फ़ंक्शन का अपना डिफ़ॉल्ट लागू होता है।

Dispatcher spec से सभी प्रश्न एक ही बार में बना देता है। इसके बादहर कमांड बस एक अनुरोध है: फ़ंक्शन चयन और दसों फ़ंक्शनों के सभी पैरामीटर एक साथ भेजे जाते हैं, कोड केवल चुने गए फ़ंक्शन के उत्तर पढ़ता है—प्रश्न «कौन-सा फ़ंक्शन चुना गया» से पहले ही सब पूछ लिए जाते हैं, यह सट्टा फैन-आउट की चरम रूप है:

python
assistant = Dispatcher(SPEC, TOOLS, client)   # SPEC 来自 spec.json,TOOLS 来自 trader.py
print(f"{len(assistant.questions)} questions per command, among them:")
for qid in ("__tool__", "plot_price.style", "plot_price.style?", "compare_returns.symbols.NVDA"):
    question = assistant.questions[qid]
    print(f"  {qid:<30}{question['type']:<8}{str(question['instructions'])[:64]}")

आपको यह दिखना चाहिए(आधिकारिक रिलीज़):

text
54 questions per command, among them:
  __tool__                      choice  What is the user asking the trading assistant to do?
  plot_price.style              choice  Does the user want a plain line or candles?
  plot_price.style?             noul    Does the user say how the chart should be drawn, such as a line,
  compare_returns.symbols.NVDA  noul    Does the user want NVDA in the comparison?

दस फ़ंक्शनों में कुल 28 भरने-योग्य पैरामीटर, साथ में फ़ंक्शन चयन और प्रत्येक stated प्रश्न, हर कमांड के लिए 54 प्रश्न एक ही अनुरोध में पूछे जाते हैं। प्रश्न «विचार» लिखते हैं, «उपयोगकर्ता जो शब्द बोल सकता है» नहीं: मिलान अर्थ से होता है—is amd tracking nvidia lately rolling_correlation से मेल खाता है, जबकि tracking और lately ये दोनों शब्द spec.json में कहीं नहीं आते।

आधिकारिक 14 कमांड चलाएँ (आउटपुट आधिकारिक रिलीज़ मान हैं):

text
  "show nvda 1h"
      plot_price(symbol='NVDA', resolution='1h')                        confidence 0.78   tool 1.00
  "plot rolling correlation between nvda and spy for the past month"
      rolling_correlation(symbol='NVDA', benchmark='SPY', window='1mo') confidence 0.91   tool 1.00
  "when during the day does nvda trade the most"
      intraday_pattern(symbol='NVDA')                                   confidence 0.53   tool 1.00
  "what moved today"
      top_movers(window='1d', direction='gainers')                      confidence 0.90   tool 0.90
  "what tickers do you have"
      list_symbols()                                                    confidence 1.00   tool 1.00
  "how did the market do this week"
      market_summary(window='1w')                                       confidence 0.96   tool 0.99
  "candles for tesla with a 20 period moving average"
      plot_price(symbol='TSLA', style='candles', moving_average='20')   confidence 0.69   tool 0.97
  "compare nvda amd and msft over the past three months"
      compare_returns(symbols=['NVDA', 'AMD', 'MSFT'], window='3mo')   confidence 0.94   tool 1.00
  "how volatile is tsla"
      volatility(symbol='TSLA')                                         confidence 0.96   tool 1.00
  "biggest losers today"
      top_movers(window='1d', direction='losers')                       confidence 0.98   tool 0.98
  "worst drawdown for nvda this quarter, and chart it please"
      drawdown(symbol='NVDA', window='3mo', plot=True)                  confidence 0.84   tool 0.84
  "spy stats for the last month"
      summary_stats(symbol='SPY', window='1mo')                         confidence 0.88   tool 0.88
  "show me apple daily with volume"
      plot_price(symbol='AAPL', resolution='1d', include_volume=True)   confidence 0.75   tool 0.85
  "is amd tracking nvidia lately"
      rolling_correlation(symbol='AMD', benchmark='NVDA')               confidence 0.82   tool 0.82

दो लंबी कमांड से मूल्य सबसे साफ़ दिखता है: rolling correlation ने एक वाक्य में चार पैरामीटर भरे, symbol और benchmark अपनी-अपनी जगह पर; compare कमांड ने तीन ticker सेट में रखे और दूसरे तीन को बाहर रखा।

  • मैं बता सकता हूँ कि तीन बंद-सेट आकृतियाँ किस प्रश्न में मैप होती हैं, और limit: int 54 प्रश्नों में क्यों नहीं आता
  • मुझे पता है कि spec की विकल्प कुंजियाँ सीधे वही स्ट्रिंग क्यों हैं जो फ़ंक्शन प्राप्त करता है

चरण 6: confidence पढ़ें—सबसे कमज़ोर निर्णय पूरी कॉल की पकड़ तय करता है ​

क्यों: फ़ंक्शन कॉल का confidence पूरी कॉल के उस निर्णय की बात करता है जिस पर सबसे कम पकड़ है, सभी निर्णयों के गुणनफल की नहीं—एक गलत पैरामीटर परिणाम बर्बाद करने के लिए काफ़ी है।

आधिकारिक मूल शब्द: गुणनफल दूसरे प्रश्न का उत्तर देता है («क्या हर हिस्सा सही है»), और पैरामीटर जितने अधिक उतना वह गिरता जाता है, चाहे असल में कोई निर्णय संदिग्ध हो या न हो। min आपको कमज़ोर कड़ी सीधे दिखाता है। is amd tracking nvidia lately के पैरामीटर-दर-पैरामीटर हिसाब (आधिकारिक रिलीज़ मान):

text
"is amd tracking nvidia lately"  ->  rolling_correlation(symbol='AMD', benchmark='NVDA')   confidence 0.82
  symbol      'AMD'                     p 0.87   AMD 0.87  NVDA 0.13  AAPL 0.00
  benchmark   'NVDA'                    p 0.78   NVDA 0.92  AMD 0.08  AAPL 0.00
  window      omitted, default stands   p 0.96
  resolution  omitted, default stands   p 0.99
  weakest argument: benchmark

window और resolution दोनों छोड़े गए—lately न कितनी दूर पीछे देखने को कहता है, न कौन-सा bar, इसलिए rolling_correlation अपने डिफ़ॉल्ट पर चलता है: एक महीना, घंटे की लाइनें। यही stated का उपयोग है: इसके बिना Choice को एक विंडो निर्दिष्ट करने के लिए मजबूर किया जाता, और वह पूरे आत्मविश्वास के साथ निर्दिष्ट करता।

confidence 0.82 सबसे कमज़ोर benchmark से आया है (p 0.78)। निष्पादित करें या नहीं, उपयोगकर्ता से पूछ लें «NVDA से तुलना करें क्या»—यह जानकारी सीधे उपयोगी है—थ्रेशोल्ड आपके कोड में तय होता है।

अंत में दोनों परिदृश्यों को एक ही सिद्धांत से जोड़ें। स्किल चुनने वाले आधे हिस्से में, आधिकारिक Agent Skill के एक अक्सर-पूछे जाने वाले प्रश्न की बात ठीक उलटी है: अगर केवल «सर्वोत्तम चुनना» ही मकसद है, तो सीधे सबसे अधिक संभावना वाला विकल्प ले लें, हर जगह confidence थ्रेशोल्ड लगाने की ज़रूरत नहीं; सांख्यिकीय एल्गोरिदम की ज़रूरत हो तो probabilities लें। दो अनुरोध जो द्वारपाली करते हैं वह «कहें या न कहें» है—वह द्वार Noul संभावना से ही लगाया गया है, Noul में कोई अलग confidence तो होता ही नहीं।

आपको दिखना चाहिए: पैरामीटर-दर-पैरामीटर विभाजन ऊपर की तालिका से मेल खाता है; weakest argument: benchmark पंक्ति पूरी कॉल में सबसे संदेहास्पद पैरामीटर बताती है।

  • मैं बता सकता हूँ कि confidence min क्यों लेता है गुणनफल नहीं, और stated छोड़े जाने पर डिफ़ॉल्ट मान कहाँ से आता है

📋 जादुई Prompt ​

इस पृष्ठ का «Prompt» API के लिए प्रश्नों और निर्णय-कोड का टेम्पलेट है—कॉपी करें, 【】 प्लेसहोल्डर बदलें (? वाले वैकल्पिक हैं) और उपयोग करें।

📝 स्किल रैंकिंग प्रश्न-समूह (एक Choice + चार Noul) ​

अपेक्षित प्रभाव: «कौन-सी स्किल लोड करें» को रैंकिंग + द्वारपाली दो समूहों में बाँटा जाता है, एक ही अनुरोध में सभी उत्तर मिल जाते हैं।

python
QUESTIONS = {
    "which": Choice(
        instructions="【这些技能里哪个适合用户的这一轮请求?】",
        criteria={【技能名】: 【一行索引描述】},  # 194 个也放得下,上限 255
    ),
    "gate::acts": Noul(
        instructions="【用户是要对文件 / 账户 / 设备 / 线上服务动手,还是只要解释或建议?】",
    ),
    "gate::procedure": Noul(
        instructions="【认真回答这个问题的专家要不要查一份具体流程或命令集?】",
    ),
    "gate::prose": Noul(
        instructions="【一个什么都接触不到的通才,纯靠文字能把这请求答满意吗?】",  # 反向题:yes = 不需要技能
    ),
    "named": Noul(
        instructions="【请求点名了具体工具、格式、模板或方法吗?】",
    ),
}
# 必填项:state = {"request": 【用户这轮的原话】, "recent_context": 【近期对话,可为空串】}
# 选填项:闸门题按你的领域改问法,但保持「问动作,不问主题」?
# 输出规范:probabilities 降序取前三;gate = 三道动作题的均值(prose 取 1-p 再平均);named 单独读
# 约束条件:
# ✅ 问「要不要动手」,别问「主题是什么」——主题题分不开 explain what a monad is
# ✅ 官方英文原文经过了 452 请求实测,中文化前先用自己的数据验证
# ❌ 不要问「该不该建议技能」——那是代码的活,改政策不该改问题

✅ दो थ्रेशोल्ड का सुझाया निर्णय (सत्य-सारणी समापन) ​

अपेक्षित प्रभाव: दोनों संभावना-समूह «अधिकतम एक स्किल नाम» बन जाते हैं, पूरी नीति दिखाई देने वाले स्थिरांकों में रहती है।

python
GATE_THRESHOLD = 【0.30】   # 三道动作 Noul 的均值,官方给这套请求挑的起点
NAMED_THRESHOLD = 【0.50】  # 「点名了方法」单独开门,不进平均
FITS_THRESHOLD  = 【0.30】  # 复查里最好的 fits 低于它就整组放弃
SHORTLIST = 【3】            # 第一道带进第二道的候选数

def suggest(request):
    wide = rank_wide(request)
    if not (wide["gate"] >= GATE_THRESHOLD or wide["named"] >= NAMED_THRESHOLD):
        return ()                        # 两个理由都不成立:什么都不建议
    shortlist = top(wide["ranked"], SHORTLIST)
    result = rerank(request, shortlist)  # 第二道:选项 = 前三的全文,真二请求
    if max(result["fits"].values()) < FITS_THRESHOLD:
        return ()                        # 允许全员落选
    return (result["winner"],)
# 必填项:三个阈值——官方说明它们是起点,不是默认值
# 选填项:建议块措辞保留「可以忽略」,并给「没有建议」也发一句话?
# 输出规范:至多一个技能名,或 ();包进 <skill_relevance> 块加在 roster 之后
# 约束条件:
# ✅ 建议块加在 roster 之后,别改 roster 文本——prefix caching 靠它逐回合一致
# ✅ 阈值、问题措辞集中在一个文件里,方便人审(官方 Agent Skill 的建议)
# ❌ 不要把建议写死成命令——自信的错误建议比没有更糟(实测弄坏 7 个本来对的)

🔧 फ़ंक्शन कॉल spec टेम्पलेट (एक फ़ंक्शन एक प्रविष्टि) ​

अपेक्षित प्रभाव: सिग्नेचर के बंद-सेट पैरामीटरों को एक-एक करके «विचार पूछने» वाले प्रश्न मिलते हैं, फ़ंक्शन में जाने वाला मान हमेशा वैध रहता है।

json
{
  "question": "【用户想让这个助手做什么?(挑函数的那道题)】",
  "functions": {
    "【函数名】": {
      "description": "【用户想要这个函数做什么,一段话】",
      "arguments": {
        "【参数名】": {
          "question": "【这个参数用户要什么——按想法问,不按参数名问】",
          "stated": "【用户说没说这个参数?】",
          "options": {
            "【合法值,即 Literal 成员】": "【这个值是什么意思,一行】"
          }
        }
      }
    }
  }
}
# 必填项:每个 Literal 参数一条;list[Literal] 的 question 里放 {} 占位(每成员一道 Noul)
# 选填项:可选参数配 stated;bool 参数不需要 options(一道 Noul ≥ 0.5 为开)?
# 输出规范:Dispatcher 一次建 54 道问题(本页示例规模),每条命令一次请求
# 约束条件:
# ✅ 选项键 = 函数收的字符串,省掉映射层
# ✅ spec 可以让 LLM 从签名帮你写(官方原话),写完人审一遍
# ❌ 不要拿参数名当问题("Which resolution?")——没给命令任何可匹配的东西

चेकपॉइंट ✅ ​

  • मैं बता सकता हूँ कि दोनों अनुरोध क्या करते हैं: पहले में एक Choice 194 स्किलों की रैंकिंग + चार Noul द्वारपाली; दूसरा केवल शीर्ष तीन देखता है, पूर्ण विवरण के साथ पुनः जाँचता है, सबका असफल होना स्वीकार्य है
  • मुझे पता है कि दूसरा अनुरोध भेजना ही क्यों ज़रूरी है: दूसरे के विकल्प (शीर्ष तीन का पूरा पाठ) पहले अनुरोध की रैंकिंग के बाद ही बन सकते हैं—आधिकारिक तीन वास्तविक दो-अनुरोध केसों में से एक
  • मैं तीन-भुजा वास्तविक परीक्षण दोहरा सकता हूँ: गलत लोडिंग 15.7% → 7.9% (आधे से भी ज़्यादा कटी), बेकार लोडिंग 14.0% → 5.2% (लगभग दो-तिहाई); oracle फ़्लोर 3.2% / 4.1%
  • मैं फ़ंक्शन कॉल की तीन बंद-सेट आकृतियाँ बता सकता हूँ: Literal → Choice, list[Literal[...]] → प्रति सदस्य एक Noul, bool → Noul; संख्या और मुक्त पाठ नहीं पूछे जाते, डिफ़ॉल्ट बना रहता है
  • मुझे पता है कि फ़ंक्शन कॉल में confidence सबसे कमज़ोर निर्णय (min) लेता है गुणनफल नहीं, और यह भी कि स्किल चुनते समय «केवल सर्वोत्तम चुनें» हो तो हर जगह थ्रेशोल्ड लगाने की ज़रूरत नहीं

सावधानी की याद दिलाते हैं ​

❌ Jev से सीधे पूछना कि «agent का अगला कदम क्या होना चाहिए» ​

SKILL.md के मूल शब्द: ऐसे प्रश्न आम तौर पर बताते हैं कि गलत परत पर पूछा जा रहा है। सही तरीका निर्णय को उसके आधारभूत निर्णयों में तोड़ना है—रैंकिंग, एक्शन द्वारपाली, नाम-द्वारपाली, fits—निर्णय Jev को दें, फ़ैसला (दो थ्रेशोल्ड + सत्य-सारणी) कोड में लिखें, दिखाई दे, परीक्षण-योग्य हो। इस पृष्ठ के दो अनुरोध और चार स्थिरांक पूरा उदाहरण हैं।

❌ हर जगह confidence थ्रेशोल्ड लगाना ​

आधिकारिक Agent Skill के अक्सर-पूछे जाने वाले प्रश्नों की सूची में यह शामिल है: केवल «सर्वोत्तम चुनना» ही मकसद हो तो सीधे सबसे अधिक संभावना वाला विकल्प ले लें। सांख्यिकीय एल्गोरिदम की ज़रूरत हो तो probabilities लें। इस पृष्ठ की द्वारपाली Noul संभावना से ही चलती है (Noul का कोई अलग confidence नहीं); फ़ंक्शन कॉल पक्ष का confidence ही «पकड़ का स्तर» के रूप में उपयोग होता है, और वह भी केवल सबसे कमज़ोर निर्णय का।

❌ विषय-प्रश्न को द्वारपाली बनाना ​

«क्या यह सॉफ़्टवेयर से संबंधित है» explain what a monad is और स्किल की ज़रूरत वाले सॉफ़्टवेयर अनुरोध को अलग नहीं कर सकता—दोनों सॉफ़्टवेयर हैं। एक्शन-प्रश्न पूछता है «उपयोगकर्ता की फ़ाइलों, खातों, उपकरणों, ऑनलाइन सेवाओं पर कोई काम करना है या नहीं», यही अलग कर पाता है। उलटे प्रश्न (prose_suffices) में 1-p लेकर औसत में डालना न भूलें।

❌ पैरामीटर नाम को प्रश्न बनाना ​

"Which resolution?" की आधिकारिक आलोचना: कमांड को मिलाने के लिए कुछ नहीं दिया गया। विचार पूछें: "How far back is the user asking about - today, the past week, the past month, or the past three months?"—इसी से this quarter 3mo पर गिरेगा, और lately ईमानदारी से कुछ भी नहीं भरेगा।

उन्नत तकनीकें (वैकल्पिक) ​

🔧 अपनी स्वयं की स्किल निर्देशिका की ओर इशारा करें। आधिकारिक मूल शब्द: hermes_roster.json बदल दें बस—ऊपर हर प्रश्न केवल name, description, description_full, body ये चार फ़ील्ड पढ़ता है, suggest() में Hermes-विशेष कुछ और नहीं है।

📚 बड़ी कैटलॉग का क्या होगा। आधिकारिक रूप से कहा गया है: इस स्केल के लिए एक Choice पर्याप्त से ज़्यादा है; कुछ गुना बड़ा होने पर रैंकिंग को खंडों में बाँटें, और खंड-विजेताओं को चरण 3 की तरह फिर से रैंक करें। Rerank cookbook (सर्च और मैचिंग) वही दो-चरणीय रास्ता—पहले छोटी लिस्ट, फिर री-स्कोरिंग—अपनाता है, सिर्फ़ सस्ती पहली चरण BM25 से बदल दी गई है।

⏳ ज़ीरो-की रिप्ले के सारे आँकड़े। दोनों cookbook के कॉल अपने-अपने json_cache.json में दर्ज हैं, इनपुट को की बनाकर, रिप्ले में एक भी रिक्वेस्ट नहीं जाती; कैश फ़ाइल हटाते ही सब लाइव चलता है। स्किल सुझाव की प्रकाशित रिकॉर्डिंग jev-1.14.0 + claude-haiku-4-5-20251001 (2026-10-30 रेंडर) से है, फंक्शन कॉल jev-1.12 से।

🚀 coding agent से ये लिखवाएँ। TypeSafe Agent Skill इंस्टॉल करें, इस पेज को उसे सौंप दें और उसी के मुताबिक़ करवाएँ:

bash
claude plugin marketplace add typesafe-ai/skills
claude plugin install typesafe@typesafe-ai

आधिकारिक सलाह है कि प्रश्न और थ्रेशोल्ड कॉन्स्टेंट एक ही फ़ाइल में रखें ताकि मानव-समीक्षा आसान हो—इस पेज के GATE_THRESHOLD / NAMED_THRESHOLD / FITS_THRESHOLD और चार गेट प्रश्न ठीक वही चीज़ें हैं जो उस एक फ़ाइल में जानी चाहिएँ। देखें साथ Claude Code डेवलपमेंट।

इस पाठ का सार ​

✅ स्किल सुझाव = दो रिक्वेस्ट + दो थ्रेशोल्ड: पहली चरण एक ही Choice से सभी 194 स्किलों की रैंकिंग, चार Noul गेट रखते हैं (तीन एक्शन-प्रश्न पूछते हैं «हाथ डालना है या नहीं», एक पूछता है «नाम लिया गया है या नहीं»); दूसरी चरण सिर्फ़ टॉप तीन देखती है, हर एक में पूरा विवरण + SKILL.md के शुरुआती 700 अक्षर, fits सब नीचे हों तो पूरा समूह छोड़ दिया जाता है। आउटपुट ज़्यादा-से-ज़्यादा एक स्किल नाम, <skill_relevance> ब्लॉक roster के बाद जुड़ता है।

✅ वास्तविक परिणाम और क़ीमत: ग़लत लोडिंग 15.7% → 7.9%, बेकार लोडिंग 14.0% → 5.2%; oracle फ़्लोर 3.2% / 4.1% बताता है कि चाहे कितना भी बेहतर करें, «सीधे जवाब दे देने» से आगे नहीं जा सकता। 280 कवरेज रिक्वेस्ट में 29 ठीक और 7 बिगाड़ने का सुझाव—सुझाव की शब्दावली में «नज़रअंदाज़ किया जा सकता है» शिष्टाचार नहीं है।

✅ फंक्शन कॉल = एक spec + एक रिक्वेस्ट: closed_sets सिग्नेचर पढ़कर बंद-सेट पैरामीटर को choice / set / flag तीन आकारों में बाँटता है; 54 प्रश्न एक ही रिक्वेस्ट में पूछे जाते हैं, कोड सिर्फ़ चुने गए फंक्शन के जवाब पढ़ता है। फंक्शन में हमेशा Literal के वैध मान ही जाते हैं; संख्या, फ्री टेक्स्ट नहीं पूछे जाते, डिफ़ॉल्ट बना रहता है।

✅ confidence सबसे कमज़ोर लिया जाता है: पूरे कॉल का भरोसा सबसे कम भरोसे वाले निर्णय से तय होता है (min, गुणनफल नहीं); stated जिन पैरामीटर के बारे में नहीं कहा गया उन्हें पूरी तरह छोड़ देता है, फंक्शन का डिफ़ॉल्ट लागू होता है; weakest() बताता है कि किस पैरामीटर पर शक करना चाहिए।

मुख्य कॉन्फ़िग फ़ील्ड की समीक्षा:

फ़ील्डइस पेज का मानविवरण
SHORTLIST3पहली चरण से दूसरी चरण में ले जाए जाने वाले उम्मीदवारों की संख्या
EXCERPT_CHARS700हर उम्मीदवार के साथ लाए जाने वाले SKILL.md के शुरुआती अक्षरों की संख्या (roster फ़ाइल में हर प्रविष्टि में 1600 संग्रहित)
GATE_THRESHOLD0.30तीनों एक्शन Noul का औसत रेखा पार करे तो «स्किल चाहिए»
NAMED_THRESHOLD0.50«तरीक़े का नाम लिया गया» अलग से दरवाज़ा खोलता है, औसत में नहीं जाता
FITS_THRESHOLD0.30समीक्षा में सबसे अच्छे fits इससे नीचे हों तो पूरा समूह छोड़ दिया जाता है
MEMBER / STATED0.5set सदस्य के सेट में जाने / वैकल्पिक पैरामीटर भरे जाने की दहलीज़
TYPESAFE_MODELjev-1.14.0 (स्किल) / jev-1.12 (फंक्शन कॉल)आधिकारिक रिकॉर्डिंग संस्करण; लाइव चलाने पर अपना संस्करण ID लॉक करें
AGENT_MODELclaude-haiku-4-5-20251001परीक्षण किया गया agent, आधिकारिक टिप्पणी: पिन करने से स्कोर स्थिर रहता है

संबंधित ट्यूटोरियल:

अगले पाठ की झलक ​

इस पाठ का harness तय करता है «कौन-सा टूल कॉल करें, कौन-सी स्किल चुने», अगला पाठ harness में मेमोरी जोड़ता है: बेसिक मेमोरी सिस्टम: Jev तय करे क्या याद रखना है।

आप सीखेंगे:

  • कॉल के बाद एक Noul गेट तय करता है «क्या इस रिक्वेस्ट ने याद रखने लायक़ ग्राहक-तथ्य बताया है», P ≥ 0.5 होने पर ही संग्रहित
  • मेमोरी साधारण Python डिक्शनरी में जाती है, कॉल से पहले state में मिला दी जाती है—ask_with_memory() और ask() समान पैरामीटर, समान रिटर्न वैल्यू, बदलने पर बाक़ी कोड नहीं बदलना पड़ता
  • आधिकारिक परीक्षण: बाद के टिकट रूटिंग 3/6 से 6/6, हर कॉल में सिर्फ़ एक अतिरिक्त रिक्वेस्ट
  • आधिकारिक परिभाषा वाला harness संकल्पना: मॉडल के इर्द-गिर्द उसे अतिरिक्त क्षमताएँ (tool calls, लूप में चलाना) देने वाला कोड—इस पेज का Dispatcher ठीक वही है जो मॉडल को tool calls देता है
gaodong.aiAboutPrivacyContact

Independent tutorials, not affiliated with any product mentioned. Product names and trademarks belong to their owners. Check official pages for prices and policies.