// 05 · एजेंटिक फ्रेमवर्क

कितना तेज़ है पाइपलाइन रनर?

टूल डिस्पैच ओवरहेड, RAG रिट्रीवल लेटेंसी, मॉडल-कॉल रैपर लागत, HITL राउंड-ट्रिप वितरण, पाइपलाइन ऑर्केस्ट्रेशन स्टेप-टू-स्टेप। ताज़ा क्लोन से pytest benches/ के ज़रिए reproducible, इंजन बेंच के समान कन्वेंशन।

इंजन बनाम फ्रेमवर्क

यह पेज Python एजेंटिक फ्रेमवर्क मापता है, वह रनर जो पाइपलाइन चरण ऑर्केस्ट्रेट करता है, सीमित टूल कॉल डिस्पैच करता है, RAG रिट्रीवल प्रबंधित करता है, HITL के माध्यम से राइट गेट करता है, और मॉडल कॉल रैप करता है। इन-हाउस Rust ट्रेडिंग इंजन (310 ns पर स्टेट-कैश राइट, 14 µs पर पूर्ण पाइपलाइन) के लिए इंजन लेटेंसी देखें।

रनर आपको क्या देता है

// गवर्नेंस, केवल गति नहीं

नीचे की लेटेंसी साबित करती है कि रनर लीन है। ये गारंटियां हैं जो वास्तविक क्लाइंट के लिए एजेंट चलाना सुरक्षित बनाती हैं। इस पेज पर दस मापे गए हैं, बाकी यह है कि प्लेटफ़ॉर्म कैसे बनाया गया है।

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

0.6 µs

राइट्स में मानवीय स्वीकृतिहर राइट एनफोर्समेंट गेट (एक रिएक्टिव वॉचर स्टेट, प्रति-साइकिल राइट कैप, प्रति-टेनेंट कोटा, कॉस्ट कैप) से होकर गुजरती है, फिर ऑपरेटर की स्वीकृति की प्रतीक्षा करती है। रीड्स स्वतंत्र रूप से प्रवाहित होती हैं, राइट्स गेटेड होती हैं।

0.3 µs

प्रति-वर्कफ़्लो RAGप्रत्येक वर्कफ़्लो को हाइब्रिड रिट्रीवल के साथ अपना अलग वेक्टर स्टोर मिलता है, इसलिए एक क्लाइंट के दस्तावेज़ दूसरे के कॉन्टेक्स्ट में कभी नहीं आते।

0.28 ms

अपना मॉडल लाएंएक रैपर के पीछे 20+ प्रोवाइडर (Anthropic, OpenAI, Gemini, Mistral, DeepSeek, Qwen, साथ ही लोकल Ollama और LM Studio), सभी में एक समान आकार।

1.6 µs

लागत और टोकन अकाउंटिंगहर मॉडल कॉल को प्रति-मॉडल तालिका के अनुसार मूल्यांकित किया जाता है और एक चलते USD कुल में जोड़ा जाता है, ताकि आप क्लाइंट्स को बिल कर सकें और प्रति टेनेंट खर्च सीमित कर सकें।

0.4 µs

पूर्ण ऑब्ज़र्वेबिलिटीप्रत्येक टूल कॉल, मॉडल इनवोकेशन और पाइपलाइन रन के लिए एक OpenTelemetry स्पैन, जिसमें लागत, टोकन, लेटेंसी और त्रुटि कारण शामिल हैं। ऐसे एजेंट संचालित करें जिन्हें आप वास्तव में देख सकें।

0.3 µs

स्टैटिक कॉन्टेक्स्ट असेंबलीसिस्टम प्रॉम्प्ट, दिए गए नॉलेज डॉक्स और टूल स्कीमा को प्रत्येक टर्न के कॉन्टेक्स्ट ब्लॉक में पैक किया जाता है जो मॉडल को भेजता है, रोलिंग हिस्ट्री से अलग।

1.4 µs

क्रॉस-रन एजेंट टीम मेमोरीएजेंट टीम की वर्किंग मेमोरी रनों के बीच बनी रहती है और अगले रन पर रिस्टोर होती है, इसलिए लंबे समय तक चलने वाले एजेंट सेशन के पार अपना कॉन्टेक्स्ट बनाए रखते हैं।

53 µs

एजेंटिक क्रूमल्टी-पर्सोना एजेंट टीमें (मैक्रो, टेक्निकल, रिस्क, एक्ज़ीक्यूशन) कॉन्टेक्स्ट को पर्सोना से पर्सोना तक हस्तांतरित करती हैं, एक रिस्क वीटो और रिएक्टिव साइडकार के साथ जो रन के बीच में चेन को रोक सकते हैं।

1.2 µs

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

17 µs

क्रेडेंशियल आइसोलेशनप्रति-उपयोगकर्ता एन्क्रिप्टेड वॉल्ट। एजेंट शॉर्ट-लिव्ड टिकट के माध्यम से कार्य करते हैं और कभी भी कच्ची API कुंजियों को नहीं छूते, इसलिए किसी क्लाइंट के रहस्य उसी क्लाइंट तक सीमित रहते हैं।

AES-256

डिज़ाइन से मल्टी-टेनेंटप्रोजेक्ट-स्कोप्ड भूमिकाएं और प्रति-पाइपलाइन स्टेट आइसोलेशन। एक टेनेंट की एजेंट टीम दूसरे का डेटा पढ़, उसे रोक, या उसके विरुद्ध खर्च नहीं कर सकती। एक प्लेटफ़ॉर्म पर कई क्लाइंट चलाएं।

RBAC

समुदाय से जुड़ें

मेट्रिक	स्टेटस	p50	मापा गया	नोट और पुनरुत्पादन
`tool_dispatch (0-arg)` per call	मापा गया	0.60 µs p95 0.60 · p99 1.10 µs · n=10000	2026-06-20	Runner-side cost of dispatching a zero-arg scoped tool: name lookup, ToolResponse wrap. Excludes the tool's own work + any network. पुनरुत्पादित करें: `pytest benches/bench_tool_dispatch.py::test_tool_dispatch_0arg -s`
`tool_dispatch (5-arg)` per call	मापा गया	0.70 µs p95 0.70 · p99 0.90 µs · n=10000	2026-06-20	Same path, 5-element input dict, median operator-registered shape. पुनरुत्पादित करें: `pytest benches/bench_tool_dispatch.py::test_tool_dispatch_5arg -s`
`tool_dispatch (20-arg)` per call	मापा गया	1.00 µs p95 1.10 · p99 1.30 µs · n=10000	2026-06-20	Wide-arg dispatch, long-tail tools like melaya_create_order with all optional risk params filled in. पुनरुत्पादित करें: `pytest benches/bench_tool_dispatch.py::test_tool_dispatch_20arg -s`
`pipeline_step_transition (linear)` per step, 10-step chain	मापा गया	0.22 µs p95 0.23 · p99 0.24 µs · n=2000	2026-06-20	Time from one pipeline step completing to the next being invoked, in a linear chain. Pure runner overhead (graph walk + variable binding + await). पुनरुत्पादित करें: `pytest benches/bench_pipeline_orchestration.py::test_pipeline_linear -s`
`pipeline_step_transition (parallel)` per step, 10-step fanout	मापा गया	3.32 µs p95 3.64 · p99 5.88 µs · n=2000	2026-06-20	Same transition cost in a parallel fanout via asyncio.gather. Higher than linear here: at N=10 the gather’s scheduling setup dominates, and it only drops below linear once steps block on real I/O. पुनरुत्पादित करें: `pytest benches/bench_pipeline_orchestration.py::test_pipeline_parallel -s`
`registry_boot` per cold boot · register-only	मापा गया	4.36 ms p95 5218.80 · p99 6368.90 µs · n=30	2026-06-20	The runtime walks its tool + crew modules at boot. The bench measures the introspect+register step on 250 synthetic tools (production adds Python import-time on top, this number is register-only). पुनरुत्पादित करें: `pytest benches/bench_registry_boot.py -s`
`rag_retrieve (10k chunks)` per query, top-5	मापा गया	281.10 µs p95 447.10 · p99 782.10 µs · n=2000	2026-06-20	embed(query) + brute-force kNN + chunk hydration over a 10k-chunk in-memory index. A production ANN index is 1.5-3× faster. पुनरुत्पादित करें: `pytest benches/bench_rag_retrieval.py::test_rag_retrieval_10k -s`
`rag_retrieve (100k chunks)` per query, top-5	मापा गया	5.52 ms p95 8450.40 · p99 9662.40 µs · n=2000	2026-06-20	Same path, 10× larger corpus. Brute force is O(N·D) so expect ~10-15× growth in p50 vs the 10k bench. पुनरुत्पादित करें: `pytest benches/bench_rag_retrieval.py::test_rag_retrieval_100k -s`
`model_wrapper_overhead` per LLM turn (network mocked)	मापा गया	1.60 µs p95 2.00 · p99 2.80 µs · n=1000	2026-06-20	Runner overhead around a model API call: prompt assembly, message-history pack, post-response routing. Provider HTTP boundary mocked to isolate runner cost from network. पुनरुत्पादित करें: `pytest benches/bench_model_wrapper_overhead.py -s`
`context_assembly` per turn	मापा गया	1.40 µs p95 1.60 · p99 1.80 µs · n=5000	2026-06-20	Builds the static context block a turn sends the model: system prompt + granted knowledge docs + tool schemas. Distinct from rolling history (model_wrapper) and RAG retrieval. पुनरुत्पादित करें: `pytest benches/bench_context_assembly.py -s`
`session_memory` per save + load	मापा गया	53.00 µs p95 76.30 · p99 113.30 µs · n=5000	2026-06-20	Cross-run working-memory persistence: serialize a 50-turn crew memory to the session store and restore it on the next run. In-process store, so no DB latency is included. पुनरुत्पादित करें: `pytest benches/bench_session_memory.py::test_session_memory_roundtrip -s`
`cost_tracking` per model call	मापा गया	0.40 µs p95 0.40 · p99 0.60 µs · n=10000	2026-06-20	Records one model call's token usage against a price table and updates the running USD total plus per-model breakdown. This is what enables per-tenant billing and spend caps. पुनरुत्पादित करें: `pytest benches/bench_cost_tracking.py -s`
`tracing_overhead` per span	मापा गया	0.30 µs p95 1.10 · p99 1.40 µs · n=10000	2026-06-20	Per-span observability tax: open an OpenTelemetry-style span, stamp the gen_ai / cost / latency attributes, close, and hand to the exporter. What enabling tracing adds per traced operation. पुनरुत्पादित करें: `pytest benches/bench_tracing_overhead.py -s`
`crew_orchestration` per 4-persona run	मापा गया	1.20 µs p95 2.00 · p99 2.10 µs · n=2000	2026-06-20	A 4-persona crew (macro, technical, risk, execution) hands context persona to persona, with the risk persona armed to veto and halt the chain mid-run. Pure orchestration overhead. पुनरुत्पादित करें: `pytest benches/bench_crew_orchestration.py -s`
`prompt_injection_scan` per untrusted input	मापा गया	17.40 µs p95 26.40 · p99 30.50 µs · n=10000	2026-06-20	The prompt-injection scan run on untrusted content (RAG-retrieved docs, tool outputs) before it reaches the model: weighted pattern match against injection / jailbreak / exfiltration markers, then allow / flag / block. Wired into rag.py and the tool-output postprocess. पुनरुत्पादित करें: `pytest benches/bench_prompt_injection.py -s`
`hitl_gate_overhead` per write attempt	मापा गया	0.30 µs p95 0.40 · p99 0.40 µs · n=10000	2026-06-20	The synchronous safety checks run before every write is queued for approval: sidecar-state read (a reactive watcher that can halt a run), per-cycle write cap, per-tenant daily quota, running cost cap. The trading-grade-discipline machinery, measured, distinct from the human wait below. पुनरुत्पादित करें: `pytest benches/bench_hitl_gate_overhead.py -s`
`hitl_approval_round_trip` human-bound	केवल विधि	method documented	n/a	Time from 'approval requested' to 'approval received', median over real operator sessions. Dominated by human attention; cannot be benched synthetically. Methodology documented; awaiting a 30-day production telemetry cut. पुनरुत्पादित करें: `see results/hitl_round_trip/methodology_only.json`
`concurrent_agent_executions` platform limit	कॉन्फ़िग	50	-	Configurable per-workspace cap on simultaneous agent runs (default 50); backpressure queues the rest. A deployment config knob, not a measurement. पुनरुत्पादित करें: `configured in deployment, not benched`

टियर	हार्डवेयर	कॉन्फ़िग	tool_dispatch p50	pipeline_step p50	registry_boot	rag_retrieval_10k p50
A. Production	Xeon Plat 8369B (Ice Lake-SP)	Ubuntu 22.04, pinned core, perf gov, py3.12	awaiting	awaiting	awaiting	awaiting
B. Modern Linux server	Xeon Gold 6438 / EPYC 9354	Ubuntu 22/24, perf gov, py3.12	3-8 µs	10-25 µs	1-3 s	0.5-2 ms
C. Apple Silicon	M2 / M3 / M4 MacBook	macOS 14+, arm64, py3.12	2-6 µs	8-20 µs	0.8-2 s	0.4-1.5 ms
D. Modern desktop *	i9-13900H (Raptor Lake-H)	Win11, py3.12.4, unpinned	0.6-1.0 µs	0.22 µs	4.4 ms	0.28 ms

परिदृश्य	अलग मेमोरी ड्राइवर	पीक RSS	स्टेटस
`Idle floor` s0_idle	runner floor + drift / orphan gate	40 MB 637 commit	मापा गया
`LLM-agnostic baseline` s1_baseline	orchestration heap, real dispatch path	40 MB 637 commit	मापा गया
`RAG (Qdrant) 10k` s2_rag_qdrant	Qdrant index in-runner; embedder remote	1254 MB 1925 commit	मापा गया
`RAG 100k + doc ingest` s2b_rag_100k	doc-extraction transient peak	2056 MB 2926 commit	मापा गया
`web_search fast path` s3a_websearch_fast	curl_cffi TLS, no browser (~0)	52 MB 647 commit	मापा गया
`web_search stealth rescue` s3b_websearch_browser	Chromium tree (bimodal)	610 MB 1064 commit	मापा गया
`aiml HF tool` s_aiml	in-process torch (the one local model load)	740 MB 2158 commit	मापा गया
`WSS ingress watcher` s11_wss	in-runner ring buffers	45 MB 642 commit	मापा गया
`python_repl code-exec` s12_coderepl	child interpreter + sci-stack (peak)	173 MB 2016 commit	मापा गया
`remotion render` s13_render	Node + 2nd render-Chromium (peak)	910 MB 2032 commit	मापा गया
`MCP stdio servers` s15_mcp	per-server child process	92 MB 680 commit	मापा गया
`long-context compaction` s16_compaction	saw-tooth history; reclaim proof	42 MB 640 commit	मापा गया
`streaming assembly` s17_streaming	SSE / token accumulation	41 MB 638 commit	मापा गया
`huge tool output` s18_tooloutput	multi-MB transient (peak)	40 MB 642 commit	मापा गया
`concurrency validation` s_conc	gates the capacity fit	140 MB 2534 commit	मापा गया

कितना तेज़ है पाइपलाइन रनर?

रनर आपको क्या देता है

फ़्रेमवर्क बेंचमार्क सूट में क्या शामिल है

एक कमांड में यह सब पुनरुत्पादित करें

हार्डवेयर-टियर अपेक्षाएं

मेमोरी फुटप्रिंट और क्षमता