SSD Nodes Learn Hosting plans →
गाइड Matt Connorलेखक: Matt Connor · अपडेट किया गया: 2026-10-21

AI agents के लिए self-hosted evals कैसे सेटअप करें

अपने AI agent के लिए खुद का eval loop बनाएं। इसमें real traces से golden cases, deterministic checks, LLM judge और हर commit पर pass rate ट्रैक करने की पूरी प्रक्रिया दी गई है।

AI agents के लिए self-hosted evals क्या हैं

AI agents के लिए self-hosted evals वे चार चीजें हैं जिन्हें आप अपने स्वयं के repository में रखते हैं: saved cases की एक file, एक script जो उन पर agent को run करती है, checks का एक set जो प्रत्येक उत्तर को grade करता है, और results की एक table जिसे आप query कर सकते हैं। इस सूची में किसी भी चीज़ के लिए vendor की आवश्यकता नहीं है। पूरा loop कुछ सौ lines का Python code और एक SQLite file है।

Agent demo में इसलिए काम कर गया क्योंकि आपने पाँच inputs खुद चुने थे। यह दूसरे सप्ताह में इसलिए खराब हो गया क्योंकि एक prompt line बदल गई, या model बदल गया, या tool description बदल गया, और किसी भी measurement ने इसे cover नहीं किया। एक eval loop "अब यह पहले से खराब लग रहा है" को "commit 4f1c9ab पर pass rate 60 में से 58 से घटकर 60 में से 51 हो गया" में बदल देता है।

इस loop में चार चरण होते हैं, और यह guide हर चरण के लिए एक section है: वास्तविक traces collect करना, दिलचस्प cases को promote करना, हर बदलाव पर हर case को grade करना, और pass rate को उसे उत्पन्न करने वाले commit के साथ store करना। यही loop तब भी काम करता है जब आप agent को किसी भी चीज़ पर run करें, और चलाने योग्य self-hosted agent frameworks मुख्य रूप से इस बात में भिन्न होते हैं कि वे आपको मुफ्त में कितना trace प्रदान करते हैं।

दूसरे सप्ताह में agent के विफल होने के कारण

एक agent में एक prompt, एक model, tool definitions का एक सेट, और run time पर प्राप्त किया गया context शामिल होता है। आपके application code में कोई बदलाव किए बिना ये चारों चीजें बदल सकती हैं, इसलिए सामान्य code review में कोई समस्या दिखाई नहीं देती।

सबसे आम कारण prompt में किया गया बदलाव है। आप किसी अशिष्ट उत्तर को रोकने के लिए एक वाक्य जोड़ते हैं। वह वाक्य उन inputs पर व्यवहार बदल देता है जिन्हें किसी ने retest नहीं किया, और traces में यह स्पष्ट रूप से दिखता है: पिछले सप्ताह के उसी प्रश्न के trace में एक create_refund tool call शामिल था, इस सप्ताह वाले में कोई नहीं है, और उत्तर के बजाय एक विनम्र माफी है। किसी भी चीज ने error नहीं दिया, इसलिए कोई alert जारी नहीं हुआ।

दूसरा कारण model है। हर run के साथ भेजे गए सटीक model string को record करें, claude-haiku-4-5-20251001 न कि कोई shorthand जिसे आप केवल याद रखते हैं, क्योंकि जिस दिन आपने model बदला और pass rate गिर गया, उसका निदान तभी संभव है जब model का नाम row में मौजूद हो।

तीसरा कारण tools हैं। tool के विवरण को फिर से लिखने से यह बदल जाता है कि model उसे कब call करने का निर्णय लेता है। यदि आपके tools MCP servers running on a VPS के माध्यम से आते हैं, तो schema एक अलग process में रहता है, इसलिए यह आपके repository में बिना किसी diff के बदल सकता है। चौथा कारण retrieval है: वही प्रश्न एक ऐसे index से टकराता है जिसे रात भर में rebuild किया गया था, और उत्तर नए document के अनुसार मिलता है।

पहले से एकत्रित traces से golden set तैयार करें

मूल्यांकन के मामलों (eval cases) को खुद न बनाएँ। उन्हें सीधे traffic से लें। यदि आप पहले से ही अपने agent के लिए self-hosted Langfuse tracing का उपयोग कर रहे हैं, तो प्रत्येक request उसके input, tool calls और output के साथ संग्रहीत होती है। यही वह कच्चा माल है जिसकी एक case को आवश्यकता होती है।

Public API के माध्यम से root observations की एक window export करें। यह basic authentication का उपयोग करता है, जिसमें आपका public key username के रूप में और secret key password के रूप में कार्य करता है।

export LF_HOST="https://langfuse.example.com"
curl -sS -u "$LF_PUBLIC_KEY:$LF_SECRET_KEY" \
  "$LF_HOST/api/public/v2/observations?limit=50&isRootObservation=true&fromStartTime=2026-07-01T00:00:00Z" \
  | jq '.data[0]'

किसी भी parsing को लिखने से पहले एक record को पढ़ें। पंक्तियाँ data के अंतर्गत आती हैं, लेकिन प्रश्न और उत्तर रखने वाले field के नाम इस बात पर निर्भर करते हैं कि आपका agent अपने spans को कैसे instrument करता है। इसलिए, जो आप वास्तव में देखते हैं उसे map करें, न कि वह जो आपने उम्मीद की थी। इसके बाद, evals/cases.jsonl में प्रति पंक्ति एक JSON object के रूप में cases को हाथ से लिखें:

{"id": "refund-double-charge", "tags": ["smoke"], "input": "I was charged twice for order 41822.", "must_call": ["lookup_order", "create_refund"], "must_not_include": ["I cannot help"], "rubric": "The reply confirms exactly one refund for order 41822 and states the amount."}

सेट को उपयोगी बनाए रखने के लिए पाँच नियम हैं:

  • शुरुआत करने के लिए 40 से 80 cases पर्याप्त हैं। 20 से कम होने पर, एक अस्थिर (flaky) case pass rate को 5 अंक तक बदल देता है, और बिना किसी कारण के ऊपर-नीचे होने वाले आंकड़ों को नजरअंदाज कर दिया जाता है।
  • आपके द्वारा ठीक की गई प्रत्येक production bug को उसी दिन एक case बना दें। यही वह आदत है जो सेट को सही दिशा में विकसित करती है।
  • प्रति case केवल एक व्यवहार (behaviour) रखें। यदि कोई case refund की राशि और tone दोनों की जाँच करता है, तो विफल होने पर आपको यह पता नहीं चलेगा कि समस्या कहाँ है।
  • id कभी नहीं बदलता, क्योंकि इसी id के माध्यम से आज के run की तुलना पिछले महीने के run से की जाती है।
  • commit करने से पहले redact करें। यह फ़ाइल git में जाती है, इसलिए ग्राहकों के नाम और ऐसे किसी भी order number को हटा दें जो आपके नहीं हैं।

सबसे पहले deterministic checks के साथ ग्रेडिंग करें, क्योंकि ये मुफ्त हैं

जिसका भी सही उत्तर निश्चित है, उसके लिए एक साधारण assertion का उपयोग करें। इसमें किसी model call, लागत या अस्पष्टता की आवश्यकता नहीं होती। Deterministic checks संरचनात्मक regressions को पकड़ लेते हैं, और यही वे त्रुटियाँ हैं जो आपके agent के आसपास के सिस्टम को बाधित करती हैं: जैसे JSON का parse न होना, tool का कभी कॉल न किया जाना, प्रतिबंधित वाक्यांश का वापस आना, या उत्तर में किसी स्रोत का उल्लेख न होना।

केवल एक function आपके agent के बारे में जानकारी रखता है। harness में बाकी सब कुछ सामान्य (generic) है।

import json, os, urllib.request

def run_agent(case):
    req = urllib.request.Request(
        os.environ["AGENT_URL"],
        data=json.dumps({"input": case["input"]}).encode(),
        headers={"content-type": "application/json"},
    )
    with urllib.request.urlopen(req, timeout=120) as resp:
        return json.load(resp)


def deterministic(case, result):
    text = result.get("output", "")
    called = [c["name"] for c in result.get("tool_calls", [])]
    failures = []
    for tool in case.get("must_call", []):
        if tool not in called:
            failures.append(f"tool not called: {tool}")
    for phrase in case.get("must_not_include", []):
        if phrase.lower() in text.lower():
            failures.append(f"forbidden phrase: {phrase}")
    if len(called) > case.get("max_tool_calls", 12):
        failures.append(f"too many tool calls: {len(called)}")
    return failures

tool budget को उस सूची में बनाए रखें। यदि कोई agent आज 3 calls में एक केस हल करता है और कल 11 calls में, तो यह एक regression है, भले ही अंतिम उत्तर सही हो, क्योंकि आप उसके द्वारा की गई प्रत्येक call के लिए भुगतान करते हैं।

LLM as judge, और इसके गलत होने के चार तरीके

जो भी assertions से बच जाता है, उसे एक ऐसे grader की आवश्यकता होती है जो उसे पढ़ सके। LLM judge एक दूसरा model call है: यह प्रश्न, agent का उत्तर और एक मापदंड (criterion) प्राप्त करता है, फिर एक निर्णय (verdict) देता है। यह जांचने का एकमात्र व्यावहारिक तरीका है कि "क्या उत्तर वही है जो user ने पूछा था"।

एक judge को उपयोगी बनाने के लिए चार नियम हैं:

  • बाइनरी (Binary) निर्णय लें, कभी भी 1 से 10 का स्कोर न दें। एक scale लगभग हर चीज़ के लिए 7 और 8 देती है, इसलिए संख्या कभी नहीं बदलती और आप उससे कुछ नहीं सीख पाते।
  • प्रति call एक ही मापदंड रखें। refund की राशि के बारे में पूछें, या tone के बारे में, दोनों एक साथ नहीं।
  • जब भी किसी मामले में अपेक्षित उत्तर (expected answer) हो, तो उसे judge को दें। एक reference के आधार पर grading करना, abstract में grading करने की तुलना में कहीं अधिक आसान कार्य है।
  • output के आकार (shape) को बाध्य करें और उसे सख्ती से parse करें।
from anthropic import Anthropic

client = Anthropic()  # reads ANTHROPIC_API_KEY from the environment


def judge_prompt(case, output):
    return (
        "You grade one answer against one criterion.\n"
        "Reply with JSON only, in this exact shape:\n"
        '{"verdict": "pass", "confidence": "high", "reason": "one short sentence"}\n'
        f"Criterion: {case['rubric']}\n"
        f"Question: {case['input']}\n"
        f"Answer: {output}\n"
        "Length is not a criterion. Judge only the criterion above."
    )


def judge(case, output, model):
    msg = client.messages.create(
        model=model,
        max_tokens=200,
        messages=[{"role": "user", "content": judge_prompt(case, output)}],
    )
    return json.loads(msg.content[0].text)

अब विफलता के तरीके (failure modes) देखें। प्रत्येक का एक test है जिसे आप आज दोपहर चला सकते हैं, और उन्हें चलाना महत्वपूर्ण है, क्योंकि एक अनियंत्रित judge ऐसे अंक देता है जो सटीक दिखते हैं लेकिन उनका कोई अर्थ नहीं होता।

Length bias (लंबाई का पूर्वाग्रह)। लंबे उत्तर अधिक बार पास होते हैं। इसे test करें: judge द्वारा विफल किए गए दस उत्तर लें, प्रत्येक में दो पैराग्राफ का आत्मविश्वासपूर्ण filler जोड़ें जो कोई नया तथ्य नहीं जोड़ते, और उन्हें फिर से judge करें। कोई भी निर्णय जो pass में बदल जाता है, वह length bias है, और rubric ही वह चीज़ है जिसे ठीक करने की आवश्यकता है।

Self-preference (स्व-वरीयता)। एक judge अक्सर अपने ही model family के output को दूसरे की तुलना में अधिक उदारता से grade करता है। इसे test करें: एक ही 30 उत्तरों को दो अलग-अलग families के judges के साथ grade करें और case-by-case आधार पर निर्णयों की तुलना करें। जहाँ वे असहमत हों, वहां आप स्वयं case को पढ़ें।

Position bias (स्थान का पूर्वाग्रह)। यदि आप दो उत्तरों, A और B, की तुलना करने के लिए judge का उपयोग करते हैं, तो क्रम बदलें और इसे फिर से चलाएं। swap करने पर निर्णय का बदल जाना यह दर्शाता है कि pairwise comparison उस rubric के लिए अभी सुरक्षित नहीं है।

Rubric drift (मापदंड का भटकना)। अस्पष्ट मापदंड सहमत judges पैदा करते हैं। "क्या उत्तर सहायक है" लगभग किसी भी चीज़ को पास कर देता है। "क्या उत्तर refund की राशि को dollars में बताता है" केवल उसी को पास करता है जिसे आप वास्तव में चाहते थे। प्रत्येक मापदंड को तब तक फिर से लिखें जब तक कि वह उस तथ्य का नाम न ले ले जिसकी जांच की जा रही है।

एक सुरक्षा उपाय इन चारों को कवर करता है। हाथ से label किए गए 30 cases रखें, और हर बार जब आप judge model या judge prompt बदलते हैं, तो अपने labels के विरुद्ध judge का score निकालें। यदि यह दस में से एक से अधिक case पर आपसे असहमत है, तो किसी भी pass rate पर भरोसा करने से पहले rubric को ठीक करें। judge code है, इसलिए इसे code की तरह versioned और review किया जाता है।

सस्ते मॉडल से ग्रेडिंग करें, फिर frontier मॉडल पर जाएँ

हर commit पर सबसे महंगे मॉडल से हर केस को जज करना ही वह कारण है जिससे eval का खर्च उस एजेंट से अधिक हो जाता है जिसे वह टेस्ट कर रहा है। ग्रेडर्स को उनकी कीमत के अनुसार क्रमबद्ध करें, और जैसे ही उत्तर स्पष्ट हो जाए, रुक जाएँ।

चार्टCost to judge 1,000 eval cases, list prices, October 2026
इस चार्ट के पीछे का डेटा
[
  {
    "label": "Haiku 4.5, Batch API",
    "usd_per_1000_judge_calls": "0.90"
  },
  {
    "label": "Haiku 4.5",
    "usd_per_1000_judge_calls": "1.80"
  },
  {
    "label": "Sonnet 5",
    "usd_per_1000_judge_calls": "3.60"
  },
  {
    "label": "Opus 5",
    "usd_per_1000_judge_calls": "9.00"
  }
]

ये आंकड़े प्रति जज कॉल लगभग 1,200 इनपुट टोकन और 120 आउटपुट टोकन मानते हैं, जो एक प्रश्न, एक उत्तर और एक मानदंड के लिए एक यथार्थवादी आकार है। 1,000 केस को जज करने की लागत Claude Haiku 4.5 पर 1.80 अमेरिकी डॉलर और Claude Opus 5 पर 9.00 है। जब तक आप इसे गुणा नहीं करते, तब तक यह अंतर मामूली लगता है। 60 केस का एक सेट, जिसे हर commit पर जज किया जाता है, और यदि सप्ताह में 40 commits हों, तो यह nightly job चलने से पहले ही प्रति सप्ताह 2,400 जज कॉल हो जाते हैं।

eval कार्य पर एक छूट स्पष्ट रूप से लागू होती है। Eval रन इंटरैक्टिव नहीं होते हैं, इसलिए Batch API एसिंक्रोनस डिलीवरी के बदले इनपुट और आउटपुट दोनों कीमतों को आधा कर देता है, जो चार्ट की पहली पंक्ति है। Prompt caching इस आकार के जज के लिए मददगार नहीं है। इसके मल्टीप्लायर वास्तविक हैं (पाँच मिनट का कैश राइट बेस इनपुट का 1.25 गुना खर्च करता है, और कैश रीड इसका दसवां हिस्सा खर्च करता है), लेकिन प्रॉम्प्ट के कैश किए गए हिस्से को एक न्यूनतम लंबाई तक पहुँचना होता है: Claude Haiku 4.5 पर 4,096 टोकन, Claude Sonnet 5 पर 1,024 और Claude Opus 5 पर 512 टोकन। 1,200 टोकन वाली जज कॉल Haiku की न्यूनतम सीमा से काफी कम है, और API बिना कैशिंग के और बिना कोई एरर दिए छोटे प्रॉम्प्ट को प्रोसेस कर देता है, इसलिए न तो कोई कैश राइट होता है, न कैश हिट और न ही कोई बचत। Opus 5 पर केवल कम से कम 512 टोकन का साझा प्रीफिक्स ही योग्य होगा, और judge_prompt में दिए गए फिक्स्ड निर्देश उससे काफी छोटे हैं, क्योंकि रूब्रिक हर केस के साथ बदलता रहता है। ये अक्टूबर 2026 तक Anthropic की लिस्ट कीमतें हैं।

सीढ़ी (क्रम में):

  • हर केस पर Deterministic चेक। API की कोई लागत नहीं।
  • उन केस पर छोटा मॉडल जज जो उन चेक से पास हो गए।
  • frontier जज केवल वहाँ जहाँ छोटा जज फेल कहे, या कम आत्मविश्वास के साथ पास कहे।
  • सप्ताह में एक बार, छोटे सैंपल पर मानवीय समीक्षा।
CHEAP = "claude-haiku-4-5-20251001"
STRICT = "claude-opus-5"


def grade(case, result):
    hard = deterministic(case, result)
    if hard:
        return False, "deterministic", "; ".join(hard)
    first = judge(case, result["output"], CHEAP)
    if first["verdict"] == "pass" and first["confidence"] == "high":
        return True, CHEAP, first["reason"]
    second = judge(case, result["output"], STRICT)
    return second["verdict"] == "pass", STRICT, second["reason"]

अक्टूबर 2026 तक, Anthropic इन दोनों जजों को legacy मॉडल के रूप में सूचीबद्ध करता है जो अभी भी उपलब्ध हैं। इसका deprecations पेज Claude Haiku 4.5 के लिए 15 अक्टूबर, 2026 से पहले की रिटायरमेंट तिथि नहीं देता है, इसलिए लंबे समय तक सस्ते जज पर निर्भर रहने से पहले उस पेज को चेक करें, और जज मॉडल बदलने को किसी अन्य बदलाव की तरह ही मानें: पहले 30 हैंड-लेबल वाले केस को फिर से रन करें।

यह ग्रेडिंग की सटीकता को लागत के लिए ट्रेड-ऑफ करता है, इसलिए मान लेने के बजाय इस ट्रेड-ऑफ को मापें। महीने में एक बार, पूरे सेट को सख्त जज के साथ भी ग्रेड करें और दोनों कॉलम की तुलना करें। यदि वे मुट्ठी भर से अधिक केस पर असहमत हैं, तो आपका रूब्रिक छोटे मॉडल के लिए बहुत ढीला है, और रूब्रिक ही वह चीज है जिसे आपको ठीक करना है। एजेंट स्वयं क्या खर्च करता है, इसे नियंत्रित करना एक अलग कार्य है, जो VPS पर AI एजेंट के लिए लागत नियंत्रण में कवर किया गया है।

अपने सिस्टम में समय के साथ pass rate को ट्रैक करें

यदि आप pass rate को किसी commit के साथ नहीं जोड़ सकते, तो वह केवल एक अनुमान है। प्रत्येक run के लिए प्रति case एक row स्टोर करें, जिसमें उस row के भीतर commit और model की जानकारी हो।

CREATE TABLE IF NOT EXISTS results (
  run_id      TEXT NOT NULL,
  ran_at      TEXT NOT NULL,
  git_sha     TEXT NOT NULL,
  agent_model TEXT NOT NULL,
  case_id     TEXT NOT NULL,
  passed      INTEGER NOT NULL,
  graded_by   TEXT NOT NULL,
  reason      TEXT
);
SELECT run_id, git_sha, agent_model,
       count(*) AS cases,
       round(100.0 * sum(passed) / count(*), 1) AS pass_pct
FROM results
GROUP BY run_id
ORDER BY ran_at DESC
LIMIT 10;

sqlite3 evals/results.db < evals/schema.sql के साथ schema लोड करें, फिर sqlite3 -box evals/results.db < evals/passrate.sql के साथ trend पढ़ें। 60 cases पर प्रतिदिन होने वाले runs का एक वर्ष का डेटा लगभग 22,000 rows का होता है, इसलिए यह स्टोर कभी भी एक अलग प्रोजेक्ट नहीं बनता। Running SQLite in production on a VPS उन सेटिंग्स को कवर करता है जो तब महत्वपूर्ण हो जाती हैं जब यह फाइल कई मशीनों के बीच साझा की जाती है।

runner किसी व्यक्ति के लिए भी वही जानकारी प्रिंट करता है:

run 2026-08-05T09:14:22Z  sha 4f1c9ab  model claude-sonnet-5  58/60 pass (96.7%)
FAIL refund-double-charge  deterministic: tool not called: create_refund
FAIL pto-policy-question   judge(opus): reply gives no dollar amount

suite को उन बदलावों पर चलाएं जो किसी agent को खराब कर सकते हैं, जिसका अर्थ है prompt edits, model changes और tool changes; न कि repository में हर commit पर। एक pre-push hook fast subset को कवर करता है:

cat > .git/hooks/pre-push <<'EOF'
#!/bin/sh
python3 evals/run.py --set smoke || exit 1
EOF
chmod +x .git/hooks/pre-push

Full runs धीमे होते हैं और उन्हें schedule पर चलना चाहिए। एक nightly systemd service and timer on the VPS पूरे सेट को deployed prompt के विरुद्ध चलाता है, जो उन बदलावों को पकड़ता है जो आपकी repository के बाहर से आते हैं, जैसे कि कोई hosted tool जिसका व्यवहार बदल गया हो।

मानवीय समीक्षा, संपूर्ण के बजाय नमूना आधारित

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

तीन मिनट प्रति मामले के हिसाब से पंद्रह मामले प्रति सप्ताह 45 मिनट का समय लेते हैं। यह उन rubric में सुधार लाता है जहाँ आप और Judge असहमत हैं, साथ ही उन विफलता प्रकारों के लिए नए मामले सामने लाता है जिनकी किसी ने कल्पना भी नहीं की थी। मानवीय फैसले को उसी तालिका में लिखें जहाँ graded_by को human पर सेट किया गया हो, ताकि Judge और मानव के बीच सहमति एक याददाश्त के बजाय एक query बन जाए।

eval harness में क्या खराब होता है

anthropic.RateLimitError पहले पूर्ण रन पर। एक साथ साठ केस चलाने से आपके टियर की रिक्वेस्ट या टोकन सीमा पार हो जाती है। concurrency को चार वर्कर्स तक सीमित करें, और nightly रन को Batch API पर ले जाएँ।

json.JSONDecodeError: Expecting value: line 1 column 1 (char 0) जज की ओर से। मॉडल ने गद्य में उत्तर दिया, या अपने JSON को कोड फेंस में लपेट दिया। एक बार पुनः प्रयास करें, फिर केस को त्रुटि के रूप में दर्ज करें। किसी parse failure को कभी भी पास न मानें, क्योंकि जो सूट त्रुटियों को पास में बदल देता है, वह 100% की ओर बढ़ता है जबकि एजेंट का प्रदर्शन खराब होता जाता है।

Flaky केस। एक ही इनपुट एक रन पर पास होता है और अगले पर फेल, क्योंकि एजेंट अपने आउटपुट को सैंपल करता है। flaky केस को तीन बार चलाएं और केस को हटाने के बजाय अनुपात दर्ज करें। जो केस तीन में से दो बार पास होता है, वह एक वास्तविक robustness बग है, और ग्राहक इसे ढूंढ ही लेगा।

Golden set का खराब होना। कोई सूट को ग्रीन करने के लिए अपेक्षित उत्तर को एडिट कर देता है। evals/cases.jsonl के diffs की समीक्षा उतनी ही सावधानी से करें जितनी एजेंट के diffs की, क्योंकि वह फाइल ही आपकी सही परिभाषा है।

एक सूट जो कभी फेल नहीं होता। एक महीने तक 100% पर स्थिर पास रेट का मतलब है कि सेट ने प्रोडक्ट को ट्रैक करना बंद कर दिया है। हाल के दस ट्रेसेस निकालें, उन ट्रेसेस को ढूंढें जिन्हें एजेंट ने खराब तरीके से हैंडल किया, और उन्हें जोड़ें। फिर जानबूझकर कुछ खराब करें और पुष्टि करें कि रन रेड हो जाता है, जो कि वह चेक है जिसे mutation testing एक टेस्ट सूट पर लागू होती है और यही एकमात्र तरीका है यह जानने का कि आपके सेट में अभी भी दम है।

FAQ

AI एजेंट eval सेट में कितने केस होने चाहिए?

40 से 80 के साथ शुरुआत करें और वास्तविक विफलताओं से सेट को बढ़ाएं। लगभग 20 केस से नीचे, एक अस्थिर परिणाम पास दर को 5 पॉइंट तक बदल देता है, इसलिए संख्या जानकारी देने में सक्षम नहीं रहती। कुछ सौ से अधिक होने पर, हर रन वास्तविक पैसा और समय खर्च करता है जबकि मामूली केस बहुत कम कवरेज जोड़ते हैं। जो माप मायने रखता है वह संख्या नहीं है: यह आपके ज्ञात प्रोडक्शन विफलता प्रकारों का हिस्सा है जो सेट में कम से कम एक बार दिखाई देते हैं।

क्या मैं अपने एजेंट को ग्रेड करने के लिए LLM जज पर भरोसा कर सकता हूँ?

केवल तभी जब आपने इसे अपने स्वयं के लेबल के मुकाबले मापा हो। अपने हाथ से ग्रेड किए गए 30 केस रखें, और जब भी आप जज मॉडल या जज प्रॉम्प्ट बदलें, तो उनके मुकाबले जज को स्कोर करें। जज लंबाई का पूर्वाग्रह (length bias) दिखाते हैं, जहाँ पैडेड उत्तर अधिक बार पास होते हैं, और स्वयं-वरीयता (self-preference), जहाँ उनके अपने मॉडल परिवार के आउटपुट को अधिक बेहतर ग्रेड दिया जाता है। दोनों परीक्षण योग्य हैं: एक विफल उत्तर को पैड करें और उसे फिर से जज करें, या उसी उत्तर को किसी अन्य परिवार के जज से ग्रेड करें। यदि जज दस में से एक से अधिक केस पर आपके लेबल से असहमत है, तो रूब्रिक उपयोग करने के लिए बहुत अस्पष्ट है।

कौन सा मॉडल eval को ग्रेड करना चाहिए?

सस्ते से ग्रेड करें और फिर आगे बढ़ें। Deterministic assertions की कोई लागत नहीं होती, इसलिए वे हर केस पर सबसे पहले रन होते हैं। एक छोटा मॉडल स्पष्ट पास को संभाल लेता है। केवल फेल और कम-आत्मविश्वास वाले फैसले ही frontier मॉडल के पास जाते हैं। अक्टूबर 2026 की लिस्ट कीमतों पर, 1,000 केस को जज करने की लागत Claude Haiku 4.5 के साथ लगभग 1.80 अमेरिकी डॉलर और Claude Opus 5 के साथ लगभग 9.00 होती है, और क्योंकि eval रन एसिंक्रोनस होते हैं, Batch API किसी भी आंकड़े को आधा कर देता है।

क्या eval प्रोडक्शन मॉनिटरिंग की जगह लेते हैं?

नहीं, क्योंकि वे अलग-अलग सवालों के जवाब देते हैं। एक eval सूट आपको बताता है कि क्या कोई बदलाव जिसे आप शिप करने वाले हैं, वह केस के एक निश्चित सेट को बेहतर या बदतर बनाता है। ट्रेसिंग और मॉनिटरिंग आपको बताते हैं कि वास्तविक उपयोगकर्ता अभी क्या सामना कर रहे हैं, जिसमें वे इनपुट भी शामिल हैं जिन्हें कोई केस कवर नहीं करता। वे एक-दूसरे को फीड करते हैं: ट्रेस नए केस प्रदान करते हैं, और eval सूट यह तय करता है कि क्या आपका फिक्स वास्तव में काम कर गया।

क्या यह लेख उपयोगी था?