failproofai 1.0.1-beta.0 → 1.0.1

package/.next/standalone/docs-old/hi/agenteye/evaluator-skill.mdx

@@ -0,0 +1,171 @@
+---
+---
+title: "Failproof AI Observability Evaluator Agent Skill"
+description: "Go from \"I think our agent is sometimes bad\" to a deployed scoring service, with your coding agent doing both the deciding and the building."
+---
+
+*"मुझे लगता है हमारा agent कभी-कभी खराब है"* से लेकर deployed scoring service तक जाएं, आपके coding agent के साथ both the deciding और building दोनों कर रहे हों। **Failproof AI Observability evaluator skill** (`agenteye-evaluator`) एक *Agent Skill* है: instructions का एक छोटा folder जो एक coding agent जैसे Claude Code या Codex on demand load करता है। यह agent को सिखाता है कि कौन से quality dimensions आपके *agent* के लिए tracking के लायक हैं, फिर [evaluator service](/hi/agenteye/evaluation-suite) को write, test, और deploy करते हैं जो उन्हें score करता है।
+
+यह एक **hosted scorer नहीं है**, न ही एक registry जहां आप upload करते हैं, न ही एक plugin system। आपका evaluator आपका अपना HTTP service रहता है आपके अपने infrastructure पर, बिल्कुल जैसा [Evaluation suite](/hi/agenteye/evaluation-suite) guide में described है। skill केवल आपके agent को इसे अच्छे तरीके से बनाना सिखाती है, इसलिए जो कुछ भी यह करता है, आप खुद कर सकते हैं same code लिखकर।
+
+---
+
+## कठिन हिस्सा है कि क्या score करें यह तय करना
+
+SDK surface छोटा है — एक decorator और two models — और एक agent इसे [contract](/hi/agenteye/evaluation-suite#http-contract) से ही लिख सकता है। यहीं से evaluators fail नहीं होते। वे fail होते हैं क्योंकि वे गलत चीज़ को score करते हैं, और एक evaluator जो गलत चीज़ को score करता है वह कोई भी नहीं होने से बदतर है: यह एक dashboard produce करता है जिसे सब ignore करना सीख जाते हैं।
+
+तो skill का ज़्यादातर हिस्सा code exist करने से पहले का है। इसमें agent आपसे interview करता है (*"एक run describe करें जो अच्छा गया; अब एक जो बुरा गया"*), फिर आपके real sessions को [`agenteye` CLI](/hi/agenteye/cli) के through pull करता है और उन्हें end to end पढ़ता है। ये दोनों halves आमतौर पर disagree करते हैं, और gap ही वह point है: जो आप measure करना चाहते हैं बनाम जो आपके transcripts actually support कर सकते हैं। एक dimension तभी survive करता है जब वह events से **computable** हो और **discriminating** हो — अगर यह आपके good run और bad run दोनों पर 0.9 score करता है, तो यह कुछ नहीं सिखाता और cut हो जाता है।
+
+जो वापस आता है वह 2-4 dimensions का एक proposal है reasoning के साथ, जिसे आप कोई भी line लिखने से पहले sign off करते हैं।
+
+```mermaid
+flowchart TD
+    YOU["you: 'I want evals for my support bot'"] --> AGENT["coding agent (Claude Code / Codex)<br/>loads the agenteye-evaluator skill"]
+    AGENT -->|"interview: what does good vs bad look like?"| YOU
+    AGENT -->|"agenteye --json sessions / events"| DATA["your real sessions<br/>what actually happens"]
+    DATA --> DIMS["2-4 dimensions, you sign off"]
+    DIMS --> SVC["your evaluator service<br/>agenteye-evaluator SDK"]
+    SVC --> SCORES["scores land in the dashboard<br/>and agenteye evals"]
+```
+
+---
+
+## यह दूसरे evaluation pieces से कैसे संबंधित है
+
+चार docs scoring को cover करते हैं, और वे order में एक-दूसरे को hand off करते हैं:
+
+| Page | यह क्या है | इसे तब use करें जब |
+|---|---|---|
+| **[Evaluations](/hi/agenteye/evaluations)** | Feature: sessions grid पर scores, dashboards, re-evaluate | आप जानना चाहते हैं कि automatic scoring आपको क्या देता है |
+| **[Evaluation suite](/hi/agenteye/evaluation-suite)** | HTTP contract, SDK, server env vars | आप evaluator को खुद implement या debug कर रहे हैं |
+| **Evaluator skill** (यह doc) | Scorer को design *और* build करने का एक natural-language front door | आप "I want evals" से एक running service तक जाना चाहते हैं |
+| **[CLI skill](/hi/agenteye/cli-skill)** | `agenteye` CLI का एक natural-language front door | आप scores को पढ़ना चाहते हैं जो आपके पास पहले से हैं |
+| **[Python SDK skill](/hi/agenteye/python-sdk-skill)** | अपने agent को instrument करने का एक natural-language front door | आपका agent sessions emit नहीं कर रहा है — score करने के लिए कुछ नहीं है |
+
+### CLI skill के मुकाबले: build बनाम read
+
+दोनों skills intentionally non-overlapping हैं, और दोनों को install करना normal setup है — agent यह तय करता है कि आप क्या पूछते हैं इसके आधार पर:
+
+- **`agenteye-evaluator`** (यह doc) उस चीज़ को build करता है जो scores *produce* करता है। इसका job तब खत्म होता है जब scores पहली बार land करते हैं।
+- **[`agenteye-cli`](/hi/agenteye/cli-skill)** scores को पढ़ता है जो पहले से exist करते हैं (`agenteye evals`)। *"क्या quality इस हफ्ते drop हुई?"* इसका सवाल है, इस skill का नहीं।
+
+---
+
+## Prerequisites
+
+1. **`agenteye` CLI installed और logged in** (`pipx install agenteye`, फिर `agenteye login`)। Skill इसे दो बार use करती है: real sessions को pull करने के लिए जिसके against यह design करती है, और यह confirm करने के लिए कि आपके scores end में land हुए। आपके login को `events:read` की ज़रूरत है, प्लस उस final check के लिए `evaluations:read`। CLI skill की तरह, यह **नहीं** कर सकता emailed one-time-code login को complete करना आपके लिए।
+2. **Evaluator के लिए कहीं रहने के लिए जगह।** यह एक image में build हो जाता है और एक long-running service के रूप में run होता है, तो इसे एक real repo की ज़रूरत है, scratch file नहीं। Evaluators अक्सर अपने अपने repo में रहते हैं, agent से अलग जिसे scored किया जा रहा है — skill एक existing को look करती है और नए को scaffold करने से पहले पूछती है।
+3. **`agenteye-evaluator` SDK wheel** — अपने agent के `pip` commands type करना शुरू करने से पहले अगला section पढ़ें।
+
+---
+
+## इसे कहां से प्राप्त करें
+
+Skill Failproof AI के public skills collection में publish है:
+
+**[github.com/FailproofAI/skills](https://github.com/FailproofAI/skills)** → [`skills/agenteye-evaluator/`](https://github.com/FailproofAI/skills/tree/main/skills/agenteye-evaluator)
+
+Repository public है और skill को अपने credential की ज़रूरत नहीं है — यह केवल `agenteye` CLI को drive करता है session के साथ *जिसे* आप logged in थे, और *आपके* repo में code लिखता है। ध्यान दें कि यह अपने folder के रूप में ship होता है और `pipx install agenteye` package के inside **नहीं** है, तो इसे वहां न ढूंढें।
+
+## Skill को install करना
+
+सबसे तेज़ path [`skills`](https://skills.sh) CLI है, जो folder को fetch करता है और वहां drop करता है जहां आपका agent look करता है:
+
+```bash
+# Claude Code, यह project केवल
+npx skills add FailproofAI/skills --skill agenteye-evaluator -a claude-code
+
+# हर project (installs to ~/.claude/skills/)
+npx skills add FailproofAI/skills --skill agenteye-evaluator -a claude-code -g --copy
+
+# Codex इसकी जगह
+npx skills add FailproofAI/skills --skill agenteye-evaluator -a codex
+```
+
+फिर इसे किसी दूसरे skill की तरह manage करें:
+
+```bash
+npx skills list -a claude-code           # क्या installed है
+npx skills update agenteye-evaluator     # latest version pull करें
+npx skills remove agenteye-evaluator     # इसे हटाएं
+```
+
+हाथ से install करना पसंद हैं? एक Agent Skill सिर्फ एक folder है जिसमें `SKILL.md` है (plus optional references), तो इसे copy करना काम करता है:
+
+- **Claude Code**: `agenteye-evaluator/` folder को `~/.claude/skills/` में रखें (हर project) या `<your-repo>/.claude/skills/` में (केवल वह repo)। Claude Code इसे auto-discover करता है — `/skills` list से verify करें, या बस evals के लिए पूछें।
+- **Codex (OpenAI)**: Codex same `SKILL.md` को read करता है। Bundled `agents/openai.yaml` `allow_implicit_invocation: true` set करता है, तो Codex skill को auto-select करता है जब task match हो; अन्यथा इसे explicitly invoke करें `$agenteye-evaluator` के रूप में।
+
+---
+
+## SDK public PyPI पर नहीं है
+
+> **Warning:** Agent को SDK install करने देने से पहले यह पढ़ें।
+
+Skill public है; जिस SDK को यह drive करता है वह नहीं है। `agenteye-evaluator` केवल एक private release artifact के रूप में ship होता है, और `agenteye` के विपरीत, name public PyPI पर **unclaimed** है — तो एक bare `pip install agenteye-evaluator` एक stranger के package को pull कर सकता है उस service में जो आपके production transcripts को read करता है। यह एक supply-chain problem है, typo नहीं।
+
+Skill यह जानता है और इसकी जगह एक install ladder down करता है, पहले rung पर रुकता है जो apply होता है: monorepo source अगर आप AgentEye repo के inside हैं, अन्यथा GitHub Releases से private release wheel (needs access), और अगर न ही कोई reachable है तो यह **रुकता है और आपको अपने Failproof AI contact से wheel पूछने के लिए बताता है** improvising करने की बजाय।
+
+तो अगर आपका agent public PyPI से bare `pip install agenteye-evaluator` propose करता है, वह flag है कि skill कभी load नहीं हुई। वहीं रुकें और check करें कि यह installed है।
+
+---
+
+## आप इससे क्या पूछ सकते हैं
+
+एक real round-trip एक vague ask से शुरू होता है और code के साथ नहीं, signed-off design के साथ end होता है:
+
+```text
+you   ▸ मुझे हमारे support bot के लिए evals चाहिए। मुझे लगता है यह कभी-कभी
+        खराब है।
+
+agent ▸ कुछ लिखने से पहले: एक run describe करें जो अच्छा गया,
+        और एक जो बुरा गया।
+
+you   ▸ अच्छा: यह docs से answer करता है। बुरा: यह stuff बनाता है,
+        या हार मानता है और कहता है "contact support"।
+
+agent ▸ Running: agenteye --json sessions --status error --since 7d
+        5 sessions पढ़ रहे हैं, दो सहित जिन्हें आप bad कहेंगे।
+
+        आपके शब्द factuality और deflection कहते हैं। Transcripts
+        deflection पर सहमत हैं (5 में से 2 support hand-off के साथ
+        end होते हैं, और यह model_response.content में plain है),
+        लेकिन factuality को ground truth की ज़रूरत है जो आपके
+        events carry नहीं करते।
+
+        तो मैं तीन चीज़ें score करूंगा:
+          - deflection      rules, cheap, आपके दोनों runs को अलग करता है
+          - tool_efficiency rules, run-004 में retry loop को catch करता है
+          - groundedness    LLM judge: क्या हर claim जो यह retrieved है
+                            docs में है?
+
+        "factuality" को ground truth की ज़रूरत होगी जो हमारे पास
+        नहीं है; groundedness सबसे करीबी चीज़ है जो आपके transcripts
+        actually support कर सकते हैं। ये तीनों names के साथ ठीक है?
+        बाद में rename करने से history split हो जाता है।
+
+you   ▸ हां
+
+agent ▸ इस repo में कोई evaluator नहीं। क्या मुझे यहां एक scaffold
+        करना चाहिए, या क्या आपके पास कहीं और एक है?
+```
+
+वहां से यह पहले rules-based dimensions लिखता है (free, instant, deterministic), उन्हें एक real captured session के against test करता है जिसमें empty और never-finished ones भी शामिल हैं जो naive evaluators को crash करते हैं, और केवल subjective dimension पर एक LLM judge के लिए पहुंचता है। यह [dispatcher की limits](/hi/agenteye/evaluation-suite#configuring-the-server) को जानता है — 30s request timeout और 8 concurrent calls deployment-wide — तो अगर judge reliably fit नहीं होगा, तो यह `JobPending` के साथ async जाता है न कि आपके judge को cancelled और retried होने देता है पांच बार पांच बार लागत पर।
+
+फिर यह deploy करता है, दो server env vars set करता है, और `agenteye --json evals --session-id <id>` से confirm करता है कि scores actually land हुए। Scores landing ही एकमात्र proof है।
+
+---
+
+## देखने के लिए क्या है
+
+- **Dimension names करीब-करीब permanent हैं।** Score keys arbitrary strings हैं और platform जो कुछ भी आप send करते हैं उसे trend करता है, जिसका मतलब है कि कोई भी downstream एक bad choice को correct नहीं करता। बाद में rename करें और history split हो जाता है: old sessions old key को keep करते हैं और trend break हो जाता है। यही है कि skill को code लिखने से पहले explicit sign-off क्यों मिलता है — वह prompt को seriously लें।
+- **Fixtures real production transcripts हैं।** Real sessions के against design करने का मतलब है उन्हें disk पर pull करना, और उनमें customer data हो सकता है। Skill यह commit करने से पहले पूछती है कि क्या git में करें; अगर doubt हो तो `fixtures/` को repo के बाहर रखें और हर developer को अपने अपने pull करने दें।
+- **Agent एक service write और deploy करता है जो हर transcript को read करता है।** यह आपके रूप में कार्य करता है, bounded by आपके CLI login की permissions, लेकिन evaluator को review करें जैसे कोई अन्य code जो production data को touch करता है।
+
+---
+
+## अगले कदम
+
+- **[Evaluation suite](/hi/agenteye/evaluation-suite)**: HTTP contract, SDK, और server env vars जिन्हें skill configure करता है।
+- **[Evaluations](/hi/agenteye/evaluations)**: जहां scores show up होते हैं एक बार जब वे land करते हैं।
+- **[CLI skill](/hi/agenteye/cli-skill)**: sibling skill, scorer build करने की बजाय results read करने के लिए।
+- **[CLI](/hi/agenteye/cli)**: command reference जिसके against skill session data design करती है।

package/.next/standalone/docs-old/hi/agenteye/event-stream.mdx

@@ -0,0 +1,49 @@
+---
+title: "Event Stream"
+description: "जिस पल आपका agent कुछ करता है, आप उसे देखते हैं।"
+---
+
+जिस पल आपका agent कुछ करता है, आप उसे देखते हैं। Event Stream production में हर agent की live pulse है: कोई इंतज़ार नहीं, logs को grep करने की ज़रूरत नहीं, कोई अनुमान नहीं कि अभी क्या हुआ।
+
+![Live Event Stream: color-coded event rows जो real time में tail करते हैं, environment, agent, session, event type, और free text से filterable](/agenteye/images/events-stream.png)
+
+*आपके org के हर agent से हर event, सबसे नया पहले, जैसे-जैसे यह होता है अपडेट होता है।*
+
+## हर agent पर आपकी live pulse
+
+जब agent एक run शुरू करता है, model को call करता है, tool fire करता है, hook चलाता है, या error में फँसता है, तो row stream के top पर ठीक उसी पल दिखाई देता है। यह आपके संपूर्ण organization के हर agent से हर event को tail करता है, सबसे नया पहले, ताकि आपके पास हमेशा एक current picture हो, stale नहीं।
+
+इसका मतलब है कि कहीं log files को tail करने की ज़रूरत नहीं, machines के across grep करने की ज़रूरत नहीं, timestamps को हाथ से एक साथ जोड़ने की ज़रूरत नहीं। आप एक page खोलते हैं और आप पहले से ही production देख रहे हैं।
+
+Rows को type के अनुसार color-coded किया गया है, ताकि आप stream को एक नज़र में पढ़ सकें, हर line को parse करने की बजाय। एक नज़र में, हर row आपको यह दिखाता है:
+
+- **इसका type**, color-coded: `agent_start`, `model_response`, `tool_use`, `hook_completed`, `error`, और अधिक।
+- **एक-line summary** कि क्या हुआ, ताकि आपको शायद ही कभी सिर्फ gist पाने के लिए कुछ खोलने की ज़रूरत हो।
+- **Token counts** step के लिए।
+- **Context-window fill badge** जहाँ लागू हो, ताकि prompt growth और approaching compaction visible हों, वे काटने से पहले।
+
+इसे live देखने का मतलब है कि आप एक bad deploy, एक runaway loop, या errors का एक burst को तब पकड़ते हैं जब यह होता है, कल के log review में नहीं।
+
+## वह एक run खोजें जो मायने रखता है
+
+जब कुछ गलत दिखता है, तो आप firehose नहीं चाहते। आप वह single run चाहते हैं जो टूटा। Stream तेज़ी से filter होता है: environment द्वारा, agent द्वारा, session द्वारा, event type द्वारा, या free text द्वारा।
+
+Session id या agent id द्वारा filter करें अपने पहले event से अपने last event तक एक run को follow करने के लिए। Event type द्वारा filter करें एक single kind of activity को isolate करने के लिए, उदाहरण के लिए पूरे org में हर `error` एक view में। Filters को stack करें "everything, everywhere" से "this agent, in prod, erroring" तक कुछ clicks में narrow करने के लिए, फिर जो आप खोजते हैं उस पर act करें।
+
+Free-text search सीधे एक message, एक tool name, या एक id की ओर जाता है जो आपके पास पहले से है, इसलिए एक customer report seconds में exact run में बदल जाता है।
+
+## इसे कहाँ खोजें
+
+Event Stream आपका org home है। Sign in करें और यह पहली surface है जहाँ आप land करते हैं, `/<org-slug>/` पर, ताकि triage दूसरे पल से शुरू हो जाए जब आप पहुँचते हैं।
+
+इसके पीछे, आपके agents SDK के through events emit करते हैं, collector उन्हें आपके Failproof AI Observability server को ship करता है, और stream उन्हें tail करता है जैसे वे infrastructure में arrive करते हैं जो आप control करते हैं। जब आप raw trail की बजाय rolled-up view चाहते हैं, तो हर run के events Sessions पर एक single row में collapse हो जाते हैं, एक click दूर।
+
+यह raw source of truth है जिस पर हर दूसरी observe surface build होती है, इसलिए जब एक number कहीं और गलत दिखता है, तो stream वह जगह है जहाँ आप confirm करते हैं कि वास्तव में क्या हुआ।
+
+## संबंधित
+
+- [Sessions](/hi/agenteye/sessions): वही events हर run के लिए एक row में rolled up, एक git-style execution graph के साथ।
+- [Telemetry](/hi/agenteye/telemetry): आपके agents क्या send करते हैं और कैसे events stream तक पहुँचते हैं।
+- [Error tracking](/hi/agenteye/error-tracking): एक triage surface सब कुछ के लिए जो गलत हुआ।
+- [Alerts](/hi/agenteye/alerts): किसी भी threshold को paging rule में बदलें।
+- [CLI and agents](/hi/agenteye/cli-and-agents): आपके terminal से एक ही live trail।

package/.next/standalone/docs-old/hi/agenteye/hermes-capture.mdx

@@ -0,0 +1,53 @@
+---
+title: "Hermes session capture"
+description: "अपनी टीम के Hermes gateway sessions — Slack, Telegram, CLI, और scheduled runs — को AgentEye में ordinary sessions और events के रूप में लाएं।"
+---
+
+[Hermes](https://hermes-agent.nousresearch.com) आपकी टीम को जहां भी वह काम करती है वहां से उत्तर देता है — Slack, Telegram, CLI, scheduled runs। Hermes session capture इन सभी को AgentEye में ordinary sessions और events के रूप में लाता है, ताकि आपकी टीम जिस assistant से हर दिन बात करती है वह उतना ही observable हो जितना कि आप जो agents लिखते हैं।
+
+एक छोटा सा background collector Hermes के local session store को जब भी लिखा जाता है तब पढ़ता है और sessions को AgentEye को भेजता है। यह [Codex](/hi/agenteye/codex-capture) और [OpenClaw](/hi/agenteye/openclaw-capture) capture के समान ही काम करता है, और एक collector कई को एक साथ capture कर सकता है।
+
+---
+
+## यह क्या capture करता है
+
+मशीन पर हर Hermes session को capture किया जाता है, चाहे वह किसी भी channel से आया हो। प्रत्येक एक AgentEye [session](/hi/agenteye/sessions) बन जाता है; इसके user और assistant messages, tool calls, और tool results matching [events](/hi/agenteye/event-stream) बन जाते हैं।
+
+जिस channel से एक session शुरू हुआ — Slack, Telegram, CLI, या एक scheduled run — वह session पर रिकॉर्ड किया जाता है, ताकि आप उन्हें अलग बता सकें और एक बार में एक को filter कर सकें। इसके साथ session जिस model पर चला, जिस chat और person से शुरू किया गया, और जब एक session ने दूसरे को spawn किया, तो अपने parent की link भी आती है।
+
+Sessions तुरंत दिखाई देते हैं जब Hermes उन्हें शुरू करता है, चाहे कुछ भी कहा गया हो या नहीं, और एक turn का reply और उसके tool calls वास्तविक क्रम में रहते हैं। जब एक session समाप्त होता है तो आप यह भी जानते हैं कि यह क्यों समाप्त हुआ, इसकी लागत क्या थी, और इसने कितने tokens का उपयोग किया।
+
+---
+
+## इसे चालू करें
+
+Capture तब तक बंद रहता है जब तक आप इसे enable न करें। एक API key के साथ collector install करें जिसके पास `events:add` permission हो (देखें [API keys](/hi/agenteye/api-keys)), और Hermes capture को चालू करें:
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/FailproofAI/agenteye-collector/main/install.sh \
+  | sh -s -- --key <YOUR_API_KEY> --hermes-enabled
+```
+
+यह collector को install करता है, इसे एक background service के रूप में register करता है, और capturing शुरू करता है। पुष्टि करें कि यह चल रहा है:
+
+```bash
+agenteye-collector health
+```
+
+एक ही मशीन पर एक से अधिक agent को capture कर रहे हैं? एक ही command में प्रत्येक का flag जोड़ें — उदाहरण के लिए `--hermes-enabled --codex-enabled`।
+
+पहली बार चलाने पर, आपके मौजूदा Hermes sessions को एक बार backfill किया जाता है और नई activity फिर कुछ सेकंड के भीतर stream होती है। Hermes के अपने data को केवल पढ़ा जाता है — कभी भी संशोधित या deleted नहीं किया जाता है — और प्रत्येक message एक बार भेजा जाता है, restarts के बीच भी।
+
+`health` यह भी बताता है कि क्या collector ने जो कुछ भी capture किया वह वास्तव में AgentEye तक पहुंचा है। यदि कोई batch deliver नहीं किया जा सका तो उसे रखा जाता है और फिर से प्रयास किया जाता है न कि discarded किया जाता है, और check तब तक unhealthy रिपोर्ट करता है जब तक कुछ भी outstanding हो — तो "healthy" का अर्थ है आपका data पहुंचा, केवल यह नहीं कि process alive है।
+
+---
+
+## यह कहां दिखाई देता है
+
+Captured sessions **Sessions** में दिखाई देते हैं, और उनके events **Events** stream में, किसी भी अन्य agent के समान जिसे आप observe करते हैं — तो [session replay](/hi/agenteye/sessions), [search](/hi/agenteye/queries), [evaluations](/hi/agenteye/evaluations), और [alerts](/hi/agenteye/alerts) सभी उन पर काम करते हैं। उन्हें अपने आप पर देखने के लिए Hermes agent द्वारा filter करें।
+
+---
+
+## गोपनीयता
+
+Hermes sessions में पूरी transcript होती है — command output, file contents, और कुछ भी जो agent ने पढ़ा या लिखा था सहित — और इसमें secrets हो सकते हैं। Captured sessions को जैसे-तैसे भेजा जाता है, तो capture को केवल वहां enable करें जहां उस content को AgentEye में centralize करना appropriate हो, और collector को एक ऐसी key दें जो केवल `events:add` तक scoped हो। देखें [Security](/hi/agenteye/security) कि आपके data को कैसे अलग रखा जाता है।

package/.next/standalone/docs-old/hi/agenteye/incidents.mdx

@@ -0,0 +1,50 @@
+---
+title: "घटनाएँ"
+description: "जब कोई alert trigger होता है, तो सभी को दिखता है कि incident खुला है, इसका मालिक कौन है, और अब तक क्या हुआ है — एक ही attributed timeline पर।"
+---
+
+
+जब कोई alert trigger होता है, तो पहला सवाल हमेशा यही होता है "इस पर कौन काम कर रहा है?" Incidents इसका जवाब देते हैं: जिस पल कोई breach होता है, सभी को दिखता है कि incident खुला है, इसका मालिक कौन है, और अब तक बिल्कुल क्या हुआ है, साथ ही एक स्वच्छ, attributed record जिसे आप सीधे post-mortem को दे सकते हैं।
+
+![The Incidents inbox: alert-linked और manually opened incident cards, state के अनुसार grouped, हर एक के साथ severity badge और assignee](/agenteye/images/incidents.png)
+*The inbox open incidents को state के अनुसार grouped करता है और severity और assignee के अनुसार filter करता है, इसलिए आप वह देखते हैं जिसे अभी किसी की ज़रूरत है।*
+
+## एक नज़र में जानें कि किसके पास है
+
+चैट thread में "क्या कोई इस पर नज़र रख रहा है?" के सवाल का कोई और ज़वाब नहीं। एक breach automatically एक incident खोलता है और इसे shared inbox में डालता है, जो state के अनुसार grouped होता है। इसे acknowledge करें और आपका नाम इस पर होगा, इसलिए बाकी टीम को पता चलेगा कि इसे संभाला जा रहा है। Acknowledgement shared है: कई operators एक ही incident को ack कर सकते हैं और हर एक को अलग से record किया जाता है, इसलिए पूरा war room नामों से दिखता है, न कि एक दूसरे के ऊपर। Triage के लिए एक मालिक assign करें, और inbox को severity या assignee के अनुसार filter करें ताकि आप सिर्फ अपना काम देखें।
+
+## पूरी कहानी, एक ही timeline में
+
+जब incident ख़त्म हो जाता है, तो आपके पास पहले से ही write-up होता है। कोई भी incident खोलें और आपको breach का सबूत, इसके assignees और subscribers, coordinating के लिए एक comment thread, और एक append-only activity timeline मिलता है।
+
+![An incident detail view: parent alert और breach summary, assignees और subscribers, एक attributed activity timeline, और एक comment thread](/agenteye/images/incident-detail.png)
+*सब कुछ जो हुआ, क्रम में, हर पंक्ति इस पर हस्ताक्षर की गई है कि किसने इसे किया।*
+
+हर action (opened, acknowledged, resolved, आदि) उस timeline पर लिखा जाता है और कभी संपादित नहीं किया जाता। हर entry को attribute किया जाता है: उस operator को जिसने इसे किया, email से, या **automated** को उन चीज़ों के लिए जो Failproof AI Observability ने अपने आप की हैं, जैसे breach पर incident को खोलना। कुछ भी anonymous नहीं है और कुछ भी नष्ट नहीं होता, इसलिए post-mortem कम या ज़्यादा अपने आप लिख जाता है।
+
+## एक incident कैसे आगे बढ़ता है
+
+```mermaid
+stateDiagram-v2
+    [*] --> firing
+    firing --> acknowledged: an operator acks
+    firing --> resolved: an operator resolves
+    acknowledged --> resolved: an operator resolves
+    resolved --> [*]
+```
+
+- **Open (firing):** breach incident को खोलता है और आपके channels को एक बार page करता है। Repeated breaches एक ही incident में fold हो जाते हैं और इसके बजाय evidence को refresh करते हैं कि बार-बार आपको page न करें।
+- **Acknowledged:** एक operator इसे उठाता है। यह खुला रहता है, और बाद में breaches quietly evidence को update करते हैं।
+- **Resolved:** एक operator इसे बंद करता है। जब condition clear हो जाती है तो automatic resolution की योजना है लेकिन अभी enabled नहीं है, इसलिए एक incident तब तक खुला रहता है जब तक कोई इंसान इसे resolve न करे, जो सभी को ईमानदार रखता है कि वास्तव में क्या clear हुआ है। एक नया incident बाद में एक ही alert पर खुल सकता है।
+
+एक alert के पास एक बार में सबसे ज़्यादा एक open incident हो सकता है, इसलिए एक flapping rule आपको duplicates में दफ़न नहीं कर सकता। आप manually भी एक incident खोल सकते हैं: कोई alert न पकड़ने वाली चीज़ के लिए एक standalone, या एक existing alert के लिए एक, अगर आपके पास `incidents:write` है।
+
+## इसे कहाँ खोजें
+
+Incidents `/<org-slug>/incidents` पर रहते हैं। Viewing के लिए **`incidents:read`** की ज़रूरत है; manual incident खोलने के लिए **`incidents:write`** की ज़रूरत है; acknowledging, assigning, commenting, और resolving के लिए **`incidents:ack`** की ज़रूरत है। पुरानी keys जिन्होंने retired `alerts:ack` को granted किया है काम करती रहती हैं, क्योंकि इसे `incidents:ack` के रूप में honored किया जाता है, इसलिए आपके on-call rotation को re-issue करने की ज़रूरत नहीं है।
+
+## संबंधित
+
+- [Alerts](/hi/agenteye/alerts): वह नियम जो threshold breach होने पर ये incidents खोलते हैं।
+- [Error tracking](/hi/agenteye/error-tracking): हर failure को एक जगह देखें और एक को एक alert में promote करें।
+- [Audits](/hi/agenteye/audits): scheduled analyst जो उन failures को खोजता है जिन पर कोई rule नज़र नहीं रख रहा था।

package/.next/standalone/docs-old/hi/agenteye/observability.mdx

@@ -0,0 +1,23 @@
+---
+title: "Observe"
+description: "Observe सर्फेस वह जगह हैं जहां आप अपने एजेंटों को अभी क्या कर रहे हैं यह देख सकते हैं और किसी भी एक रन में ड्रिल डाउन कर सकते हैं।"
+---
+
+
+Observe सर्फेस वह जगह हैं जहां आप अपने एजेंटों को अभी क्या कर रहे हैं यह देख सकते हैं और किसी भी एक रन में ड्रिल डाउन कर सकते हैं। यहां सब कुछ लाइव है, आपके संगठन के स्कोप में है, और तारीख की रेंज, वातावरण, एजेंट, और सेशन के आधार पर फ़िल्टर किया जा सकता है, ताकि आप "कुछ गलत महसूस हो रहा है" से सटीक रन तक सेकंडों में पहुंच सकें।
+
+![लाइव इवेंट स्ट्रीम, प्रकार के अनुसार रंग-कोडित और वातावरण, एजेंट, और सेशन के आधार पर फ़िल्टर किया जा सकता है](/agenteye/images/events-stream.png)
+
+चार सर्फेस, प्रत्येक के साथ अपना-अपना पेज:
+
+- **[Event stream](/hi/agenteye/event-stream)**: हर एजेंट भर में हर रन की लाइव, प्रति-चरण ट्रेल, सबसे नया पहले। आपका संगठन होम और ट्राइएज के लिए पहला स्टॉप।
+- **[Sessions and execution graph](/hi/agenteye/sessions)**: वे इवेंट प्रति रन एक पंक्ति में रोल अप किए गए, साथ ही एक git-शैली की तस्वीर कि हर रन कैसे सामने आया।
+- **[Performance metrics](/hi/agenteye/telemetry)**: विलंबता हीट-मैप और आपके मॉडल, टूल्स, और हुक के लिए p50/p95/p99 महत्वपूर्ण संकेत, ताकि एक टेल स्पाइक माध्यिका से अलग दिखाई दे।
+- **[Error tracking](/hi/agenteye/error-tracking)**: सब कुछ के लिए एक ट्राइएज सर्फेस जो गलत हुआ, एक फायरिंग अलर्ट से रन तक एक क्लिक दूर जो टूट गया।
+
+## संबंधित
+
+- [Evaluations](/hi/agenteye/evaluations): हर रन को गुणवत्ता के लिए स्कोर करें।
+- [Alerts](/hi/agenteye/alerts): किसी भी थ्रेशहोल्ड को एक पेजिंग नियम में बदलें।
+- [Audits](/hi/agenteye/audits): Failproof AI Observability को सेशन भर में विफलता पैटर्न खोजने दें।
+- [CLI and agents](/hi/agenteye/cli-and-agents): आपके टर्मिनल से समान अवलोकनशीलता।

package/.next/standalone/docs-old/hi/agenteye/openclaw-capture.mdx

@@ -0,0 +1,50 @@
+---
+---
+title: "OpenClaw सत्र कैप्चर"
+description: "अपनी टीम के स्थानीय OpenClaw सत्रों को AgentEye में साधारण सत्रों और घटनाओं के रूप में प्राप्त करें — OpenClaw चलाने के तरीके में कोई परिवर्तन नहीं।"
+---
+
+यदि आपकी टीम [OpenClaw](https://docs.openclaw.ai) चलाती है, तो OpenClaw सत्र कैप्चर उन सत्रों को AgentEye में साधारण सत्रों और घटनाओं के रूप में लाता है, ताकि आप उन्हें खोज सकें, पुनः चला सकें और उन्हें आपके द्वारा देखी गई किसी भी अन्य चीज़ के साथ-साथ मूल्यांकन कर सकें। यह [Python SDK](/hi/agenteye/python-sdk) की पूरक है: SDK आपके द्वारा लिखे गए एजेंटों को साधन देता है, जबकि यह आपकी टीम द्वारा पहले से किए जा रहे OpenClaw कार्य को कैप्चर करता है — इसे चलाने के तरीके में कोई परिवर्तन नहीं।
+
+एक छोटा पृष्ठभूमि कलेक्टर OpenClaw के स्थानीय सत्र प्रतिलेखों को पढ़ता है क्योंकि वे लिखे जाते हैं और उन्हें AgentEye को भेजता है। यह [Codex कैप्चर](/hi/agenteye/codex-capture) के समान तरीके से काम करता है, और एक कलेक्टर एक साथ दोनों को कैप्चर कर सकता है।
+
+---
+
+## यह क्या कैप्चर करता है
+
+किसी मशीन के OpenClaw सेटअप में कॉन्फ़िगर किया गया प्रत्येक एजेंट उस मशीन के कलेक्टर द्वारा कैप्चर किया जाता है — कोई प्रति-एजेंट सेटअप नहीं है।
+
+प्रत्येक OpenClaw सत्र एक AgentEye [सत्र](/hi/agenteye/sessions) बन जाता है; इसके उपयोगकर्ता और सहायक संदेश, उपकरण कॉल और उपकरण परिणाम मिलान वाली [घटनाओं](/hi/agenteye/event-stream) बन जाते हैं।
+
+---
+
+## इसे चालू करें
+
+कैप्चर तब तक बंद है जब तक आप इसे सक्षम नहीं करते। `events:add` अनुमति वाली API कुंजी के साथ कलेक्टर को इंस्टॉल करें (देखें [API कुंजियाँ](/hi/agenteye/api-keys)), और OpenClaw कैप्चर चालू करें:
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/FailproofAI/agenteye-collector/main/install.sh \
+  | sh -s -- --key <YOUR_API_KEY> --openclaw-enabled
+```
+
+यह कलेक्टर को इंस्टॉल करता है, इसे एक पृष्ठभूमि सेवा के रूप में पंजीकृत करता है, और कैप्चरिंग शुरू करता है। पुष्टि करें कि यह चल रहा है:
+
+```bash
+agenteye-collector health
+```
+
+एक ही मशीन पर एक से अधिक एजेंटों को कैप्चर कर रहे हैं? प्रत्येक का ध्वज एक ही कमांड में जोड़ें — उदाहरण के लिए `--openclaw-enabled --codex-enabled`।
+
+पहली बार चलने पर, आपके मौजूदा OpenClaw सत्रों को एक बार बैकफिल किया जाता है और नई गतिविधि फिर कुछ सेकंड के भीतर स्ट्रीम होती है। OpenClaw की अपनी फाइलें केवल पढ़ी जाती हैं — कभी भी संशोधित, स्थानांतरित या हटाई नहीं जाती हैं — और प्रत्येक सत्र पुनः प्रारंभ के भीतर भी बिल्कुल एक बार भेजा जाता है।
+
+---
+
+## यह कहाँ दिखाई देता है
+
+कैप्चर किए गए सत्र **Sessions** में दिखाई देते हैं, और उनकी घटनाएं **Events** स्ट्रीम में, किसी भी अन्य एजेंट के समान जिसे आप देखते हैं — इसलिए [सत्र पुनः चलाना](/hi/agenteye/sessions), [खोज](/hi/agenteye/queries), [मूल्यांकन](/hi/agenteye/evaluations), और [अलर्ट](/hi/agenteye/alerts) सभी उन पर काम करते हैं। उन्हें अपने आप से देखने के लिए OpenClaw एजेंट द्वारा फ़िल्टर करें।
+
+---
+
+## गोपनीयता
+
+OpenClaw प्रतिलेख में पूर्ण सत्र होता है — जिसमें कमांड आउटपुट, फाइल सामग्री और कुछ भी शामिल है जो एजेंट ने पढ़ा या लिखा — और इसमें गोपनीय जानकारी हो सकती है। कैप्चर किए गए सत्रों को जैसा है वैसा भेजा जाता है, इसलिए केवल उन मशीनों और टीमों के लिए कैप्चर सक्षम करें जहाँ उस सामग्री को AgentEye में केंद्रीकृत करना उपयुक्त है, और कलेक्टर को केवल `events:add` के लिए निर्धारित कुंजी दें। [सुरक्षा](/hi/agenteye/security) के लिए देखें कि आपका डेटा कैसे अलग रखा जाता है।

package/.next/standalone/docs-old/hi/agenteye/overview.mdx

@@ -0,0 +1,107 @@
+---
+title: "Failproof AI: एजेंट्स की विफलताओं का अवलोकन"
+description: "Failproof AI Observability एक स्व-होस्टेड प्लेटफॉर्म है जो आपके AI एजेंट्स को प्रोडक्शन में देखने, मूल्यांकन करने और सुधारने के लिए है।"
+---
+
+Failproof AI Observability एक स्व-होस्टेड प्लेटफॉर्म है जो आपके AI एजेंट्स को प्रोडक्शन में देखने, मूल्यांकन करने और सुधारने के लिए है। यह आपके एजेंट्स द्वारा किए गए सभी काम को रिकॉर्ड करता है (प्रत्येक टूल कॉल, मॉडल अनुरोध, हुक और त्रुटि), प्रत्येक रन की गुणवत्ता को स्कोर करता है, और उन विफलताओं को सामने लाता है जिन्हें आप खोजने के लिए नहीं जानते थे, सभी एक डैशबोर्ड में जो आप अपने बुनियादी ढांचे के अंदर चलाते हैं।
+
+यदि आप AI एजेंट्स शिप करते हैं और यह अनुमान लगाने से थक गए हैं कि एक रन गलत क्यों हुआ, तो यह शुरू करने के लिए सही पृष्ठ है। यह समझाता है कि Failproof AI Observability आपको क्या देता है और कैसे चीजें एक साथ फिट होती हैं, इससे पहले कि आप कुछ भी इंस्टॉल करें।
+
+> **Failproof AI Observability एक enterprise उत्पाद है Failproof AI से।** इसे कार्य में देखना चाहते हैं? एक डेमो का अनुरोध करें: [nikita@befailproof.ai](mailto:nikita@befailproof.ai) को ईमेल करें।
+
+![एक Failproof AI Observability सेशन को git-शैली के execution ग्राफ़ के रूप में खींचा गया है, जिसके साथ इसकी event timeline है, जिसमें दाईं ओर प्रति-रन tools, मॉडल्स और hooks का विवरण है](/agenteye/images/session-detail.png)
+
+*हर एजेंट रन को git-शैली के execution ग्राफ़ (बाएं) के रूप में खींचा जाता है, इसके event timeline के बगल में। समानांतर sub-agents को प्रत्येक को अपनी लेन मिलती है; दाईं ओर की पट्टी रन के लिए tools, मॉडल्स, hooks और token spend को विभाजित करती है।*
+
+---
+
+## कार्य में देखें
+
+दो छोटे वीडियो उन दो चीजों को दिखाते हैं जिन्हें टीमें सबसे पहले प्राप्त करती हैं: एक रन को ट्रेस करना और विफलताओं को स्वचालित रूप से खोजना।
+
+<div style={{ position: "relative", width: "100%", paddingBottom: "56.25%", height: 0, overflow: "hidden", borderRadius: "12px", margin: "1.5rem 0" }}>
+  <iframe src="https://www.youtube.com/embed/VWxukZc5k7s?autoplay=1&mute=1&loop=1&playlist=VWxukZc5k7s&rel=0&playsinline=1" title="Watch: Agent Tracing by Failproof AI (2 min)" allow="autoplay; encrypted-media; picture-in-picture; fullscreen" allowFullScreen style={{ position: "absolute", top: 0, left: 0, width: "100%", height: "100%", border: 0 }}></iframe>
+</div>
+
+*एजेंट ट्रेसिंग: लक्ष्य से लेकर tools से अंतिम उत्तर तक, एक रन को चरण दर चरण फॉलो करें।*
+
+<div style={{ position: "relative", width: "100%", paddingBottom: "56.25%", height: 0, overflow: "hidden", borderRadius: "12px", margin: "1.5rem 0" }}>
+  <iframe src="https://www.youtube.com/embed/C5nHKGQIqZQ?autoplay=1&mute=1&loop=1&playlist=C5nHKGQIqZQ&rel=0&playsinline=1" title="Watch: Automatically find where your agent is failing (2 min)" allow="autoplay; encrypted-media; picture-in-picture; fullscreen" allowFullScreen style={{ position: "absolute", top: 0, left: 0, width: "100%", height: "100%", border: 0 }}></iframe>
+</div>
+
+*Failproof Audit: Failproof AI Observability को अपने लॉग्स को सेशन्स के पार खोदने और आपको बताने दें कि क्या ठीक करना है।*
+
+---
+
+## टीमें इसका उपयोग क्यों करती हैं
+
+- **देखें कि आपका एजेंट वास्तव में क्या करता है।** हर रन एक पठनीय, git-शैली के execution ग्राफ़ में बदल जाता है: कौन से tools समानांतर में चले, कौन से sub-agents शाखा बंद हो गए, यह कहां रुका और इसने क्या खर्च किया।
+- **गुणवत्ता रिग्रेशन को स्वचालित रूप से पकड़ें।** एक छोटी स्कोरिंग सेवा को कनेक्ट करें और Failproof AI Observability हर समाप्त रन को स्कोर करता है, इसलिए सहायकता में गिरावट या hallucinations में स्पाइक अपने आप दिखाई देता है।
+- **उन विफलताओं को खोजें जिनके लिए आपने कोई नियम नहीं लिखा है।** पुनरावर्ती audits आपके लॉग्स को सेशन्स के पार खोदते हैं और त्रुटि क्लस्टर, latency आउटलायर्स, कम स्कोर और फंसे हुए runs को खोजते हैं, फिर आपको ranked, evidence-backed खोजें देते हैं।
+- **जब यह महत्वपूर्ण हो तो पेज प्राप्त करें।** Threshold नियम त्रुटि दर, latency, cost या evaluator स्कोर पर फायर करते हैं और incidents खोलते हैं जिन्हें आप स्वीकार कर सकते हैं, assign कर सकते हैं और resolve कर सकते हैं।
+- **सादे अंग्रेजी में सवाल पूछें।** एक in-dashboard AI सहायक आपके अपने डेटा पर यह जवाब देता है कि इस सप्ताह prod में गुणवत्ता कैसी चल रही है। यह जो भी परिवर्तन करता है वह approval-gated है।
+- **अपना डेटा रखें।** Failproof AI Observability स्व-होस्टेड है: events, prompts और analytics उस बुनियादी ढांचे में रहते हैं जिसे आप नियंत्रित करते हैं।
+
+---
+
+## आप क्या प्राप्त करते हैं
+
+Failproof AI Observability तीन विचारों के चारों ओर संगठित है (**observe**, **analyze**, और **admin**), जो डैशबोर्ड के बाएं sidebar में प्रतिबिंबित हैं।
+
+**Observe** (जो हुआ उसकी कच्ची सच्चाई):
+
+- **[Event stream](/hi/agenteye/event-stream)**: हर रन की live, per-step trail (tool calls, model calls, hooks, errors)।
+- **[Sessions](/hi/agenteye/sessions)**: वे events रन के प्रति एक पंक्ति में रोल अप किए गए, प्रत्येक को स्कोर करने के लिए तैयार, एक git-शैली के execution ग्राफ़ के साथ।
+- **[Performance metrics](/hi/agenteye/telemetry)**: per-surface latency heat-maps और p50/p95/p99 vitals models, tools और hooks के लिए, इसलिए एक tail spike माध्य से अलग होकर दिखता है।
+- **[Error tracking](/hi/agenteye/error-tracking)**: सभी गलत चीजों के लिए एक triage surface, एक firing alert से एक क्लिक दूर।
+
+![Tools observe पृष्ठ: एक latency heat-map, एक percentile band और 24 समय bins पर एक tool-distribution bar](/agenteye/images/tools.png)
+
+*प्रत्येक observe surface एक sparkline और p50/p95/p99 vitals को एक latency heat-map और एक percentile band के साथ जोड़ता है। यहां दिखाया गया है: Tools।*
+
+**Analyze** (activity को जवाबों में बदलें):
+
+- **[Queries](/hi/agenteye/queries)** और **[dashboards](/hi/agenteye/dashboards)**: आपकी events और evaluations पर saved SQL, साझा, org-scoped dashboards में चार्ट किए गए।
+- **[Evaluations](/hi/agenteye/evaluations)**: आपकी अपनी evaluator सेवा द्वारा उत्पादित गुणवत्ता स्कोर, per-score reasoning के साथ।
+- **[Audits](/hi/agenteye/audits)**: पुनरावर्ती investigations जो sessions के पार विफलता पैटर्न को सामने लाते हैं।
+- **[Alerts](/hi/agenteye/alerts)** और **[incidents](/hi/agenteye/incidents)**: threshold नियम जो आपको पेज करते हैं, साथ ही एक incident workflow उन्हें triage करने के लिए।
+
+**Interfaces** (अपने डेटा तक अपने तरीके से पहुंचें):
+
+- **[CLI](/hi/agenteye/cli-and-agents)**: terminal या script से अपनी पूरी deployment चलाएं, और एक coding agent को इसे सादे अंग्रेजी में करने दें।
+- **[AI assistant](/hi/agenteye/assistant)**: डैशबोर्ड के अंदर सादे अंग्रेजी में अपने एजेंट्स के बारे में सवाल पूछें।
+- **REST API**: डैशबोर्ड और CLI जो करते हैं सब कुछ एक REST API द्वारा समर्थित है जिसे आप सीधे एक scoped [API key](/hi/agenteye/api-keys) के साथ कॉल कर सकते हैं — events ingest करें, sessions और evaluations query करें, और dashboards, alerts, audits, users और keys को manage करें, इसलिए आप Failproof AI Observability को अपने स्वयं के tooling में wire कर सकते हैं।
+
+**Admin** (अपनी टीम के लिए इसे चलाएं):
+
+- **[API keys](/hi/agenteye/api-keys)**: collector, dashboard और assistant के लिए scoped tokens।
+- **Users**: passwordless, email-based sign-in एक allowlist के साथ।
+- **Settings**: per-org configuration, including model context-window overrides के साथ।
+
+---
+
+## चीजें कैसे फिट होती हैं
+
+डेटा एक दिशा में बहता है, आपके एजेंट कोड से डैशबोर्ड तक: आपका एजेंट (Python SDK के via) events को agenteye-collector को emit करता है, जो उन्हें सर्वर को भेजता है, जो डैशबोर्ड को serve करता है। दो optional सेवाएं इसे पूरा करती हैं — एक स्कोरिंग सेवा (evaluations) और एक AI assistant सेवा (in-dashboard chat)।
+
+- **Python SDK**: आप अपने एजेंट में कुछ `agenteye.event.*` कॉल्स जोड़ते हैं; events को locally buffer किया जाता है।
+- **agenteye-collector**: हर एजेंट मशीन पर एक lightweight daemon जो events को batch करता है और सर्वर को भेजता है।
+- **Server**: आपके events को ingest करता है, आपके अपने databases में operational state रखता है, और REST API को serve करता है जिसे डैशबोर्ड, CLI और आपके स्वयं के integrations सभी use करते हैं।
+- **Dashboard**: जहां आप सबकुछ explore करते हैं।
+- **Optional services**: एक स्कोरिंग सेवा (evaluations), और एक AI assistant सेवा (in-dashboard chat)।
+
+docs में उपयोग की गई vocabulary के लिए (*event, session, evaluation, audit, finding, incident*), [Concepts](/hi/agenteye/concepts) देखें।
+
+---
+
+## Failproof AI Observability प्राप्त करना
+
+Failproof AI Observability एक enterprise उत्पाद है Failproof AI से, और यह Failproof AI Enforcement — policy और guardrail उत्पाद — के साथ काम करता है, Failproof AI ब्रांड के तहत। यह पूरी तरह से अपने स्वयं के environment में चलता है। यदि आपको packages तक access नहीं है अभी भी, एक डेमो का अनुरोध करें और हम आपको set up करेंगे: [nikita@befailproof.ai](mailto:nikita@befailproof.ai) को ईमेल करें।
+
+---
+
+## अगले कदम
+
+- [Concepts](/hi/agenteye/concepts): Failproof AI Observability vocabulary एक जगह पर।
+- [Observability](/hi/agenteye/observability): अपने एजेंट्स को जो करते हैं उसे follow करें, रन दर रन।
+- [Security](/hi/agenteye/security): कैसे Failproof AI Observability आपके डेटा को isolated रखता है और आपके नियंत्रण में।