# एआई अनुशासन के रूप में: “मुझे लगता है कि मुझे छोड़ देना चाहिए"

एआई कार्य प्रवाहित करता है और SWACAT को ड्राइव करता है

<datetime class="hidden">2025-11-19T18:00</datetime>

<!--category-- AI, Software Engineering, Development -->
> **मुझे यह एक उचित उत्पाद में बदल करने के लिए भुगतान करते हैं?** मुझे एक लाइन ड्रॉप: [स्केल्ट.gowown+ds@ gmail.com](mailto:scott.galloway+dse@gmail.com)

## जो विचार सब कुछ शुरू करता है

**क्यों एक मानव मस्तिष्क 20 डिग्री पर वास्तविक समय चला जाता है, और हमारे सबसे उत्तम एआई मॉडलों को नाश्ते के बारे में बात करने के लिए सिर्फ मुझे परेशान करने की जरूरत है?**

आधुनिक BLLMs एक विशाल टाइटम की तरह होने का उद्देश्‍य कर रहे हैं - स्मृति के टन, प्रदर्शन के टन, लेकिन **अकेले**. काम करने के लिए एक इंसान सहज रूप से काम करता है, वे शक्ति के विभिन्न पदार्थ के माध्यम से स्मृति के दस इंच का उपयोग करते हैं. यह सही नहीं हो सकता है अगर मस्तिष्क 20 mags पर काम करता है.

यहाँ वे क्या लापता हैं: मस्तिष्क ग्रे क्लीटल की एक भी किरण नहीं है - यह है **विशिष्ट उपतंत्रों के ढेर** दर्शन, आंदोलन, स्मृति भंडार (परों में!), कि caltix.sss. वे ऐसा नहीं कर रहे हैं. वे एक विशाल विचार इंजन की तरह कर रहे हैं एक विशाल विचार इंजन sfffffars में बोल रहे हैं. उनका भंडार अनुकूल नहीं है. वे विशेषज्ञ उपतंत्रों का निर्माण नहीं कर रहे हैं. **वे अपूर्ण हैं.**

मैं एक मनोवैज्ञानिक होने के लिए इस्तेमाल किया, तो मुझे इस तरह के सामान के बारे में लगता है. और यहाँ मूल सिद्धांत है मैं चारों ओर hans:

**"Cowociocon जटिल mulon. "**

आपका मस्तिष्क फिर से एक कदम लेने के लिए तैयार नहीं करता है। यह है कि तेजी से, बेकार, स्वचालित उपभोग के लिए। यह जटिल समस्याओं को सुलझाने के लिए मजबूर कर देता है। Rafffons एक ही तरह की आवश्यकता करता है: यह बहुत महँगी मॉडलों के साथ अनुरोध करता है, वास्तव में जटिल मॉडलों के सामने काम करने के लिए वास्तव में आसान नहीं है।

## एलीवेटर पोंछना प्रभाव

**क्या होगा यदि आपके एआई कार्य फूल को पता चल गया था यह एआई की जरूरत नहीं थी और अपने आप को एक पायथन स्क्रिप्ट में बदल गया?** Rance करता है कि. यह बनाने के काम को जांच योग्य उपकरणों के रूप में काम करता है एक RG उपप्रयोग में। जब पैटर्न स्पष्ट हो जाता है, तो यह तत्काल पायथन के साथ कॉल करता है। जब आपको अधिक सुविधाओं की जरूरत होती है, यह ओ-प्रयोगीक रूप से, विशिष्ट रूप से जाँच करता है। जब, यह आप से विभाजित समस्याओं से दूर हो जाता है। एक छोटे से मॉडल के लिए, यह एक छोटे से कनेक्ट मॉडल। एक छोटे से कनेक्ट करने के लिए, यह हमेशा के लिए चला जाता है कि कैसे काम करता है।

[TOC]

## परिचय

अधिकांश एआई तंत्र आज मेरे पहले पीएचपी स्क्रिप्ट का चक्कर लगाने के तरह बना रहे हैं 2003-फफ्लिक, unpretable, और जब वे तोड़, आप के बारे में ज्यादा मौका मिल गया है उन्हें एक अनजान अमरीकी को समझाने के रूप में.

जब वे असफल हो जाते हैं, आप नहीं बता सकते क्यों. जब वे बहाव (और वे) *होगा*, आप आग पर उत्पादन जब तक पता नहीं है. जब तक आप उन्हें सुधार करने की जरूरत है? एक वर्ग में वापस. डिजिटल Casssss.

एक बेहतर तरीका है. क्या होगा अगर हर एआई उपकरण एक दिन से सही सॉफ्टवेयर के रूप में बनाया गया था - परीक्षण, अनुबंध, विशेषताएँ, और जवाबदेही के साथ? जब Waks दस्तक आती है तब बंद नहीं किया.

यहाँ है कैसे एआई इंजीनियरिंग काम करना चाहिए जब यह बड़ा हो जाता है.

## विषय - सूची

## समस्या: एआई अब भी जंगली पश्‍चिम है

मैं इस तरह की कल्पना कर रहा हूँ क्योंकि मुझे लगता है कि एक चित्र के साथ आप एक चित्र का रंग लगाने के लिए,

```mermaid
graph TD
    A[Traditional AI Development] --> B[Write Prompt]
    B --> C[Hope for Best]
    C --> D{Does it work?}
    D -->|Sometimes| E[Ship It™]
    D -->|Usually| F[Tweak Prompt]
    F --> C
    E --> G[Production]
    G --> H[Silent Drift]
    H --> I[Everything's Fine...]
    I --> J[Until It's Not]
    J --> K[Panic]
    K --> L[No Audit Trail]
    L --> M[Start Again]

    style K stroke:#f96
    style L stroke:#f96
    style M stroke:#f96
```

ध्वनि परिचित है? यह है कि कैसे अधिकांश एआई सिस्टम बनाया जाता है। यह पूरी तरह से केले है।

## क्या बात इसे अलग बनाती है?

यहाँ एक निर्मित एआई "टोल" की तरह लग रहा है मेरी व्यवस्था में - सीधे पाइप मैं से, कोई सिगरेट और दर्पण:

![औज़ार फ़ोल्डर स्ट्रक्चर](tools_folder.png)

```
flag_potential_violations_base/
├─ flag_potential_violations_base_plan.txt   ← generation plan
├─ flag_potential_violations_based_on_predefined_thresholds.feature   ← BDD spec
├─ interface.json                            ← declared IO contract
├─ specification.md                          ← intent & description
├─ main.py                                   ← implementation (generated)
├─ test_main.py                              ← unit + BDD tests
├─ locust_flag_potential_violations_base.py  ← load/performance tests
└─ node_runtime.py                           ← runtime integration (a mock of it's tool call for testing use)
```

यही कारण है कि फ़ोल्डर संरचना है कि एक उपहास मैं आप को प्रभावित करने के लिए मैदान में नहीं किया है. यही है कि यह है. *बहुत ही उत्पन्न किया आउटपुट*.. हर एक फ़ाइल. एआई से स्वयं को.

**प्रत्येक नोड है:**

libiggy गुण
| ------------- | ----------------------------------------- |
ADDD जाँच जन्म हालत से अस्तित्व में है
योग्यताएँ हमेशा साबित हो सकती हैं कि यह क्यों किया गया
एलैक्ज़ैंडर एवोविक्स की तुलना में सुधार किया जा सकता है
बेनकोचिक बेचेबल parf/ लोड परीक्षण शामिल हैं
[ पेज 23 पर तसवीर]

यह आसान नहीं है इंजीनियरिंग. **एआई को अनुशासित सॉफ्टवेयर की तरह बनाया गया है**- जिस तरह आप वास्तव में उत्पादन में भरोसा कर सकते हैं, बिना जाँच की जाँच के हर 5 मिनट के.

और यहाँ वास्तव में चतुर सा है: **वे सिर्फ पायथन स्क्रिप्ट हैं**. सही है, उबाऊ, जाँचयोग्य पायथन स्क्रिप्ट. लेकिन वे एक RG-G- आधारित गणित- आधारित उपप्रयोग में रहते हैं जहां हर उपकरण के लक्षण अपनी पहचान का हिस्सा बन जाते हैं. तंत्र काम स्तर से प्रभावशाली रूप से कम यूटिलिटी स्क्रिप्ट को रोकने के लिए सक्षम है.

**क्या होगा यदि आपके एआई-वेन कार्य फूल ने यह वास्तव में एआई की जरूरत नहीं थी?** यह होता है. एक कार्य फूल कुछ बार चलाता है, पैटर्न स्पष्ट हो जाता है, और तंत्र जानता है कि "यह सिर्फ डेटा परिवर्तन है, मैं क्यों एक TLM कहते हैं?" तो यह एक शुद्ध पायथन स्क्रिप्ट बनाता है. अगली बार जब आप एक ही निवेदन कर रहे हैं? **इंस्टैंट**. न तो कोई संकेत, ना ही देर की कोई निशानियाँ. बस उबाऊ, तेजी से, गणना योग्य पायथन.

या शायद आपको और अधिक की ज़रूरत हो. शायद कि काम के प्रवाह को एक अतिरिक्त वैध जाँच की आवश्यकता हो. मेरी तंत्र में, नया काम है **जब आवश्यक हो तो सिर्फ जोड़ा गया**. सिस्टम सिर्फ उन नए भागों को उपकरण के रूप में तैयार करता है - शायद मौजूदा लोगों पर आधारित हो सकता है - पर पूरी तरह से नए, लेकिन हमेशा के लिए अनुमानित रूप से, हमेशा जाँच. कोई भी पाररिंग कोड में नहीं. "ठीक है" कोड में सिर्फ न्यूनतम व्यवहारात्मक उपकरण आप सही समस्या को हल करने के लिए आप अभी देख रहे हैं.

एक उपकरण का उन्नयन करें (एक दिशा में, जांचशील ढंग से, और प्रत्येक कार्य फूल जो इसे तत्काल लाभों का उपयोग करता है. किसी भी प्रकार के परिवर्तन के लिए नहीं. सिर्फ बेहतर उपकरण ही हर चीज़ के लिए उपलब्ध हैं)

## यह वास्तव में कैसे कार्य करता है:

यहाँ थोड़ा और कोई नहीं कर रहा है. "Aes" उपकरण एक एकल मॉडल नहीं है - यह एक मॉडल है **विशिष्ट निर्देशों की टीम**, ध्यान से धुन लगाकर शुरू करने वाले हर व्यक्‍ति एक उचित सॉफ्टवेयर इंजीनियरिंग टीम की तरह काम करता है ।

**किनारा का फूल:**

1. **विशेष केस जांच** "क्या यह एक आम कार्य है जो हम पहले से ही संभाल है?" ( भविष्य में, इन सामान्य पैटर्नों को स्वचलित जोड़ने के लिए trating होगा)
2. **कार्य सूची** - एक बहुत अच्छा है कि मैं एक 7B मॉडल का उपयोग करता हूँ, कुछ शानदार नहीं है. "मैं इसे कैसे तोड़ सकता हूँ? हर भाग के लिए कौन से औज़ार मौजूद हैं?
3. **समानांतर बनाम अनुक्रम योजना** - तय करता है कि समानांतर vs में क्या चला सकते हैं
4. **औज़ार कॉल बनाता है** - आउटपुट `call_tool("tool_name", prompt)` - यह फ्रेमता के लिए केईएम है
5. **RAG देखें** - क्या "ool_name" मौजूद है? यदि हाँ, इसका उपयोग करें. यदि नहीं, तो यह अनिवार्य रूप से अगली उदाहरण के लिए निर्देश बन जाता है
6. **रिकर्सिव देक** - कि अगले एक ही गिरावट करता है, कम से कम, इकाई के लिए सभी नीचे कदम करने योग्य कदम

**यह सफलता है.** कार्य आणविक ऑपरेशन के लिए नीचे गिर जाते हैं - जैसा मैंने 30 साल से निर्माण सॉफ्टवेयर के दौरान करना सीखा. छोटा स्थानीय स्थानीय है. **पर्याप्त अच्छा** कोड पीढ़ी के लिए जब कार्य छोटा होता है और ओवरसियर विस्तृत कार्यान्वयन निर्देश प्रदान करता है.

यहाँ उन निर्देशों का एक वास्तविक उदाहरण है. अध्यक्ष सिर्फ "विरामकार" नहीं कहता है - यह प्रदान करता है:

- सटीक एल्गोरिदम (क्लासिक प्रकार + गंभीर पथ)
- परिभाषा के साथ डाटा संरचना
- इनपुट/ आउट ख़ाका के साथ फंक्शन हस्ताक्षर
- परफ़ॉर्मेंस सीमाएँ (OV+E) समय, ओ(V) जगह
- सुरक्षा सीमा (max००० कार्य)
- वांछित इनपुट तथा आउटपुट सहित जांच स्थिति पूरा करें
- JSON इनपुट/ आउट फॉर्मेट्स

7B मॉडल उस तत्व से ठोस कोड लिख सकता है क्योंकि यह कुछ भी बनाने के लिए कहा नहीं जा रहा है - बस एक विस्तृत रूपरेखा लागू करें. **यही कारण है कि** क्यों इस तंत्र में कोड पीढ़ी के लिए छोटे मॉडल काम करते हैं.

जब WER काम फूल चलाता है, यह अभी भी RG के द्वारा गतिशील है. यदि एक नया, बेहतर उपकरण प्रकट होता है कि एक ही परीक्षण चला जाता है? यह स्वचालित उपयोग किया जाता है. और अगली बार याद आता है.

मैं तुम्हें एक और आरेख के साथ बनावट दिखाने के लिए, ज़ाहिर है कि मैं अपनी मदद नहीं कर सकता।

```mermaid
graph TB
    subgraph "RAG-Based Tool Substrate"
        A[Semantic Intent] --> B[Plan Generation]
        B --> C[Contract Definition]
        C --> D[Code Generation]
        D --> E[Test Generation]
        E --> F[Fitness Evaluation]
        F --> G{Passes?}
        G -->|Yes| H[RAG Storage]
        G -->|No| I[Evolutionary Improvement]
        I --> D
        H --> J[Tool Specification + Code]
    end

    subgraph "Dynamic Composition"
        J --> K[Workflow Assembly]
        K --> L[Tool Discovery via RAG]
        L --> M[Runtime Execution]
        M --> N{Tool Upgrade?}
        N -->|Yes| H
        N -->|No| O[Continue]
    end

    style H stroke:#9f6
    style J stroke:#9f6
    style L stroke:#6cf
```

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

यह एक आत्म-तुलन औज़ार है कि समय पर स्मार्ट हो जाता है.

### स्मृति समस्या: ड्राइव कैसे करें सीखना बन्द करना

**सामान्य एआई का प्रयोग "कंक अध्ययन" के निकट होता है.** हर बार जब वे काम करते हैं, वे एक परीक्षा का सामना कर रहे हैं - सभी संदर्भ पढ़ रहे हैं, समस्या को सुलझा रहे हैं, समाधान. यह एक बार आप कार में मिलता है हर बार अपने प्रदर्शन करने के लिए किया जा रहा है. जब आप एक कार में मिलता है, तो आप गाड़ी नहीं चला जाता. *जाँच* (हालाँकि वह एआई समाधान के साथ एक और समस्या है) अपने वास्तविक *सबक*यह समझाने की कोशिश कीजिए कि आपके घर के पास आने से पहले हर सुबह क्या होता है ।

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

**वास्तव में मानसिक रूप से याद है.** जब यह एक समस्या को हल करता है, यह समाधान को एक परीक्षण के रूप में जमा करता है, यह एक परीक्षण, घोषणा उपकरण है. अगले समय में? यह सिर्फ इसे प्रयोग करता है. कोई फिर से सीखना. कोई फिर से सीखना नहीं. "मुझे अपने सभी संदर्भ फ़ाइलों को फिर से पढ़ें." यह कल चला गया, यह जानता है कि यह कहाँ बदल रहा है.

इस संबंधों को मैं सीधे विचारों में डाल दिया गया है के बारे में अपने सेप्टिक श्रेणी में - विशिष्ट रूप से:

- **[भाग 8: सभी औज़ार नीचे](/blog/semanticintelligence-part8)** स्वयं के लिए पाक-साफ़ औज़ारों के लिए
- **[पार्ट ९: स्व- सेवा औज़ार](/blog/semanticintelligence-part9)** वंशीय विकास के लिए,
- **[भाग १०: डायनर कुक](/blog/semanticintelligence-part10)** काम के लिए चित्र का रंग

प्रत्येक नोड पहले ही मौजूद है:

- एक विशेषताएँ (इसलिए आप जानते हैं कि यह क्या है) *मतलब* करने के लिए
- एक अनुबंध (सो आप जानते हैं कि यह क्या है) *असल में* यह है
- रनर कोड (शॉकिंग, मुझे पता है)
- परीक्षण जो आगे बढ़ना चाहिए (यह नहीं "हम परीक्षण बाद में जोड़ेंगे" बकवास)
- एक लोड टेस्ट टैंक (क्योंकि "यह मेरे लैपटॉप पर काम किया" एक तैनाती रणनीति नहीं है)
- मौजूदा के लिए एक कारण (कोई zmazuuue कोड अपने कोड को नीच रखने)

यही कारण है कि सबसे अधिक पैमाने पर एआई - अधिक संकेत नहीं, बड़े मॉडल नहीं, कोई और खूनी चैट रैपर की जरूरत है।

## अनंतता: औज़ार वैकल्पिक हैं, LLMs वैकल्पिक हैं

यहाँ थोड़ा है कि वास्तव में मामलों को है: **औज़ार और प्रतीक वैकल्पिक हैं**.. सिस्टम जहाज एक तयशुदा LLLM के साथ, और यह शुरू से सब कुछ काम कर सकता है अगर यह करने के लिए है. लेकिन उपकरण इसे एक सिर शुरू दे.

**पुस्तकालय पुस्तकों की तरह उपकरणों के बारे में सोचो.** कुछ JSON फ़ाइलें हैं जो तर्क के लिए प्रेरित हैं (संग्रेड), स्वयं विश्लेषण, स्वयं एक-दूसरे पर निर्भर करता है. कई पायथन स्क्रिप्ट (संत्रिक, तंत्रिका - तंत्रिका - उपयोग करने के लिए सीखने के लिए सक्षम हैं. कुछ लोग तो टेम्पलेट के लिए तैयार हैं (संत्र बनाने के लिए, कोड बनाने के लिए एक नया लूप उपकरण बनाने के लिए तैयार हैं, जब मुझे टाइप करना है.

**वे सभी अपने - अपने काम में लगे रहते हैं ।**

आप नहीं है *आवश्यकता है* पुस्तकालय. प्रणाली चीजों को अपने स्वयं से बाहर आंकड़ा कर सकते हैं. लेकिन होने के लिए 200 किताबें होना चाहिए "को कैसे करना है." जब यह JSON का विश्लेषण करने की जरूरत है, यह पहले सिद्धांतों से JSON की व्याख्या करने के लिए नहीं है, यह एक उपकरण है। जब यह मशीन सीखने की जरूरत होती है, यह निर्माताओं को लागू करने के लिए लागू करने के लिए लागू नहीं होती है। जब यह अपनी खुद की जरूरत होती है, यह अपने उपकरण की जरूरत होती है। जब यह खुद की जरूरत होती है, तो यह अपने स्वयं को हल करने के लिए सक्षम करने के लिए सक्षम करने के लिए सक्षम करता है।

तंत्र कर सकते हैं:

- **बहुत सेLM प्रयोग करें** या बस एक या किसी कार्य के लिए नहीं जब वे पायथन के लिए साझा कर रहे हैं
- **विशेषज्ञ उपकरण** या उन्हें चलते-फिरते ही पकड़ ले,
- **एमसीपी उपकरण के साथ कार्य करें** - करीब 200 औज़ारों के साथ जहाज जिनमें ~10 MCP एकीकरण शामिल है. एक उपकरण नए MCP सेवाओं को खोज सकता है और उन्हें लपेट सकता है. लेकिन आप शून्य उपकरण के साथ शुरू कर सकते हैं और यह स्वयं बूट करना होगा.
- **शुरू से ही निर्माण करें** - काफी समय दिया और गणना. औज़ार सिर्फ इसका मतलब यह नहीं है

```mermaid
graph LR
    subgraph "Tool Ecosystem"
        A[Python Scripts] --> E[RAG Substrate]
        B[LLM Specialists] --> E
        C[External APIs] --> E
        D[MCP Tools] --> E
    end

    E --> F[Dynamic Discovery]
    F --> G[Workflow Composition]
    G --> H[Execution]
    H --> I[Feedback & Learning]
    I --> E

    style E stroke:#6cf
    style F stroke:#9f6
```

और क्योंकि सब कुछ RAGAG में जमा है , आप निर्माण कर सकते हैं **व्यवस्थाओं का आपस में ताल्लुक** एक तंत्र आँकड़े बताते हैं कि एक चाल - चलन डेटा परिवर्तन कैसे संभाल सकता है?

तंत्र आशावादीता जो कि इस पर आधारित है **लागू किया दबाव**:

- **परफ़ॉर्मेंस दबाव?** तेजी से आयामें पैदा करें, उन्हें जांचें, विजेता को बनाए रखें
- **दबाव?** वैध सुधार उपकरण बनाएं, जाँच जोड़ें, सुधार सुधार
- **भारी दबाव?** पायथन स्क्रिप्ट, कैश- अप, कम्पलीट मॉडलों का प्रयोग करें

यह केवल काम करता है जब आवश्यकता होती है. कोई समय- चिह्न नहीं होता है. "हमें इस दिन" कोड की आवश्यकता नहीं है. सिर्फ वास्तविक, समस्याओं को हल करने के लिए सुधार की जरूरत है.

यह अपने उपकरण के लिए एक छत्ते का मन रखने की तरह है, सिवाय कम बदमाश और अधिक बेकार.

### नेटवर्क प्रभाव: अ- निर्दिष्ट क्षमता से जुड़ा हुआ है

यहाँ है जहां यह सही तरह से sei-fy हो जाता है (लेकिन एक अच्छी तरह से है). बहु उदाहरण एक RAGests को साझा कर सकते हैं, एक निर्माण कर सकते हैं **तंत्र व्यवस्थाओं से जुड़ा एक नेटवर्क** जो सामूहिक रूप से सीखते और उन्‍नति करते हैं ।

```mermaid
graph TB
    subgraph "System A"
        A1[Workflow] --> A2[Tool Discovery]
        A2 --> A3[RAG Substrate]
    end

    subgraph "System B"
        B1[Workflow] --> B2[Tool Discovery]
        B2 --> B3[RAG Substrate]
    end

    subgraph "System C"
        C1[Workflow] --> C2[Tool Discovery]
        C2 --> C3[RAG Substrate]
    end

    A3 <--> D[Shared Tool Repository]
    B3 <--> D
    C3 <--> D

    D --> E[Collective Learning]
    E --> F[Improved Tools]
    F --> D

    style D stroke:#6cf
    style E stroke:#9f6
```

**अभ्यास में इसका क्या अर्थ है:**

- तंत्र Altiption औजार बनाता है हर कोई इसे प्राप्त करता है
- तंत्र बी लॉग्स के लिए एक तेजी से रास्ता खोजता है हर किसी को लाभ उठाने के लिए
- तंत्र CALLAVERS ज्ञान को बढ़ावा देता है

प्रत्येक तंत्र अपना स्वयं का कार्य फूल और विशेषता बनाए रखता है, लेकिन वे सभी परीक्षा के एक समूह से योगदान और लाभ प्राप्त करते हैं, वैध, वैध उपकरण उपकरण हैं.

यह एडस्‌ के बिना सहयोगीय एआई इंजीनियरिंग है. हर योगदान परखा जाता है, संस्करणित है, और एक-दूसरे के सामान को नहीं तोड़ सकता. कोई भी कभी-कभी सभी के सामान को तोड़ नहीं सकता (आप पर नज़रो, नोड_ links).

### एडाप्टिव एडाप्टिव: डिफ़ॉल्ट द्वारा लेप, स्मार्ट जब आवश्यक हो

यहाँ एक और चतुर बिट है: सिस्टम को आवश्यक नहीं है 24/7 चल रहे मॉडल चल रहा है। यह एक और चतुर सा उपयोग करता है। **स्नातक कार्य प्रवाह** जहां जाएं:

- **मेलेेल** (एक बहुत तेजी से 1B-क्लास) सभी दैनिक घर की गति, वर्गीकरण, सरल निर्णय संभालता है
- **कप, तेज मॉडल** नियमित तौर पर काम कीजिए (अपने इलाके की लाला, पाउ, या इसी तरह)
- **मध्य- आदर्श** जीव - रसायनात्मक जटिलता (२.५, क्लोरोकु)
- **फ्रन्टियर मॉडल** केवल सच में कठिन समस्याओं के लिए बुलाया जा रहा है (जी२-४, क्लोज़)

```mermaid
graph TD
    A[Task Arrives] --> B[Sentinel: 1B LLM]
    B --> C{Classify Complexity}
    C -->|Housekeeping| D[Sentinel Handles It]
    C -->|Simple| E[Local Model]
    C -->|Moderate| F[Mid-Tier Model]
    C -->|Complex| G[Frontier Model]

    D --> H[Routing, Classification, etc.]
    E --> I[Fast & Cheap]
    F --> J[Balanced]
    G --> K[Powerful]

    H --> L{Success?}
    I --> L
    J --> L
    K --> L

    L -->|Yes| M[Result]
    L -->|No| N[Escalate to Higher Tier]
    N --> F
    N --> G

    style B stroke:#6cf
    style D stroke:#6cf
    style E stroke:#9f6
    style F stroke:#ff9
    style G stroke:#f96
```

**इलिनॆल कम खर्च रखने का राज़ है ।** यह एक छोटा सा है, तेज 1B-मीटर मॉडल है जो लगातार चलती है, नियंत्रण:

- कार्य - नियुक्‍ति
- सरल हाँ/ नहीं निर्णय
- डाटा वैधीकरण तथा फ़ॉर्मेटिंग
- जांच व परीक्षा
- निगरानी और घर की व्यवस्था

इसके बारे में विचार कीजिए कि स्वागतकर्ता जो जानता है कि कब कुछ अपने आप को और बढ़ाने के लिए कब और बुज़ुर्गों के साथ बड़ा होना चाहिए ।

लेकिन यहाँ है जहां यह वास्तव में दिलचस्प हो जाता है: **सर्वर से कनेक्ट करें** ( यहां तक कि कुछ ही घंटों के लिए, और तंत्र उस अतिरिक्त शक्ति का उपयोग करेगा:

1. **अपने आप को ऑप्टीमाइज़ करें** अपने औज़ारों की समीक्षा करें, सुधार की पहचान करें, बेहतर अनुवाद तैयार करें
2. **सुरक्षित रूप से अद्यतन करें** - सभी परिवर्तन अभी भी पूरे जाँच सूट और मूल्यांकन के माध्यम से चलते हैं
3. **नए पैटर्न सिखे** - आम समस्याओं को हल करने के लिए बेहतर तरीके से खोजता है
4. **बूटेटिक क्षमताओं को बूट करें** - नए उपकरण बनाएँ यह पहले नहीं था

तो फिर आप महँगी मॉडल को डिस्कनेक्ट कर सकते हैं, और तंत्र उन सभी लोगों के साथ चलता रहता है जो परीक्षा पायथन स्क्रिप्ट के रूप में किए गए सुधार में किए गए थे. प्रेषितिनल सब कुछ चेकिंग पर निगरानी रखता है, और आपने अनिवार्य रूप से "अभी तक" सामनेवाले मॉडल को अपने उपकरण लाइब्रेरी में बदल दिया है.

### गतिशील एनवायरनमेंट अनुकूलन

तंत्र डाटा तथा पर्यावरण परिवर्तनों को भी जवाब देता है **विविध और घटिया**:

```mermaid
graph LR
    A[Environmental Change] --> B[Pattern Detection]
    B --> C{Existing Tool?}
    C -->|Yes| D[Use Cheap Model]
    C -->|No| E[Generate New Tool]
    E --> F[Frontier Model]
    F --> G[Test & Validate]
    G --> H[Add to RAG]
    H --> D
    D --> I[Continue Cheaply]

    style D stroke:#9f6
    style F stroke:#f96
    style I stroke:#9f6
```

**अभ्यासः**

- एपीआई फॉर्मेट में परिवर्तन? एक बार अनुकूल उपकरण बनाएँ, फिर इसे सदा के लिए इस्तेमाल करें (k)
- नया डाटा स्रोत? एक स्मार्ट मॉडल के साथ पारसर का पता लगाने के लिए, फिर एक गूंगा के साथ इसे चलाने के लिए
- क्या टरीसा 30 सेकंड तक इसके बारे में सोच रही है, मगर इसके परिणाम को पायथन स्क्रिप्ट के रूप में सहेजें

आप अनिवार्य रूप से बुद्धि के लिए भुगतान कर रहे हैं, फिर ऑटोपॉट पर चल रहे हैं. यह अपने प्रक्रियाओं को ठीक करने के लिए एक सलाहकार की तरह है, सिवाय सलाहकार एक LLM है और सुधार संस्करण - नियंत्रण के साथ जांच के साथ संस्करण-चक स्क्रिप्ट.

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

## एआई ने समस्या को ठीक नहीं किया - यह ईवोव्ड इससे दूर

ठीक है, मुझे इस प्रणाली वास्तव में क्या करता है के बारे में स्पष्ट हो, क्योंकि अधिकांश एआई ध्वनि का दावा करता है Cononnon घाटी की कहानियों की तरह ध्वनि: "Jontious सब कुछ देखा और अत्यंत रूप से उस दिन के लिए बचाया गया था." यह यहाँ नहीं है. यह उस से अधिक प्रौढ़ है.

यहाँ वास्तविक सुविधा है:

```mermaid
graph TB
    A[Tool in Production] --> B[Fitness Monitoring]
    B --> C[Performance Tracking]
    C --> D{Drift Detected?}
    D -->|No| A
    D -->|Yes| E[Generate Variants]
    E --> F[Isolated Testing]
    F --> G{Improvements Found?}
    G -->|No| A
    G -->|Yes| H[Merge to Tool]
    H --> I[Update Tests]
    I --> J[Update Audit Trail]
    J --> K[Update Provenance]
    K --> A

    style D stroke:#ff9
    style G stroke:#ff9
    style H stroke:#9f6
```

सिस्टम:

1. **ट्रैक्स विशेषता तथा समय पर प्रदर्शन** - नहीं, बस "यह काम कर रहा है?" लेकिन "यह है अच्छी तरह से काम कर रहा है और यह करने के लिए इस्तेमाल किया जाता है?"
2. **किसी को सूचित करने से पहले बहुत छोटे बहाव पता लगाएँ** बड़ी मूर्खता की बात है, बहुत से लोग गुमराही में पड़े हुए हैं ।
3. **आस - पास के फर्कों से दूर, अकेलेपन में** वैकल्पिक कार्यान्वयन तैयार करता है, उन्हें पूरा जांच सूट के माध्यम से चलाता है, उनकी जाँच करें
4. **औज़ार में वापस सुधारों को सही तरह से मिलाएं** - केवल वैध होने के बाद ही, सिर्फ पूरी जांच विस्तार के साथ
5. **जांच के साथ कोड को अद्यतन करता है, DEDCT लॉग, प्रमाणित करता है** हर परिवर्तन का पता लगाने योग्य है, हर सुधार की घोषणा की जाती है
6. **यहाँ खिसकाएँ (M)** - कोई प्रशंसक, कोई चेतावनी, नाटक नहीं

**यह समस्या "साथ" नहीं था. यह सिर्फ इससे दूर विकास.**

कोई आपातकालीन प्रतिक्रिया नहीं है. कोई घटना रिपोर्ट. कोई घटना रिपोर्ट नहीं है जहां हर किसी का नाटक वे जानते हैं कि क्या हो रहा है. तंत्र ने एक प्रवृत्ति दिखाई, विकल्प, वैध सुधार, और सुधार. जब तक एक मानव को कुछ नज़र नहीं आया है, उपकरण पहले से ही सुधार किया गया था.

### ऐसा करने में क्या बात हमारी मदद कर सकती है?

चलो कहते हैं कि आपको एक औज़ार मिल गया है जो Namunds. तीन सप्ताह से अधिक, एपीआई मालिक अपने स्वरूप में परिवर्तन बनाता है - कुछ भी नहीं कि तुरंत टूटता है, सिर्फ छोटे में smsssssssssssssssssss. अनुक्रिया बार 50 mm. मान दर 99.8% करने के लिए.

**पारंपरिक पास:**

- सप्ताह ४: किसी को नोट करता है कि धीमी तूफान के बोझ
- सप्ताह ५: आरंभ होता है, दोष लगाने का खेल शुरू होता है
- सप्ताह 6: रूट कारण पहचान (शायद हो सकता है)
- सप्ताह 7: डेवलपर ठीक लिख रहा है, स्थानीय रूप से जाँच
- सप्ताह ८: कमी, उंगलियों, उम्मीद है कि यह काम करता है

**डिथरिंग पास:**

- सप्ताह 2: फिट होने की निगरानी में 0.% 2 ड्रॉप्स सफलता की व्याख्या में
- सप्ताह २, दिन ३: सिस्टम तीन सायफ्शन रूपांतर पैदा करता है
- हर सप्ताह २, दिन ३: चरs ने यातायात यातायात के विरुद्ध परीक्षण किया
- सप्ताह २, दिन ३: उत्तम भिन्नताओं में जोड़ा गया (99.९% सफलता दर)
- सप्ताह २, दिन ३: अद्यतन, एक धोखा निशान रिकॉर्ड
- सप्ताह ४: मनुष्यों को आनन्दरहित रूप से कुछ भी नहीं हुआ

कोई नाटक नहीं ।

### इंजीनियरिंग अनुशासन "सर" के पीछे के अनुशासन

यह जादू नहीं है, और यह निश्चित रूप से एक रहस्यपूर्ण काम नहीं है. यह सरल इंजीनियरिंग है:

```mermaid
sequenceDiagram
    participant M as Monitoring
    participant A as Analyser
    participant G as Generator
    participant T as Test Harness
    participant V as Validator
    participant I as Integrator

    M->>A: Performance metrics trending down
    A->>A: Analyse fitness scores
    A->>G: Request variants
    G->>G: Generate alternatives
    G->>T: Submit for testing
    T->>T: Run full test suite
    T->>V: Results + metrics
    V->>V: Compare fitness scores
    alt Improvement Found
        V->>I: Merge approved variant
        I->>I: Update code, tests, docs
        I->>M: Resume monitoring
    else No Improvement
        V->>M: Continue monitoring
    end
```

हर कदम पर तय करने की काबिलीयत होती है ।

"evolution" बस है:

- कंटीड माप
- प्रोफिक्सिक तैयार किया जा रहा है
- रीगोन्स जांच
- आधारित चयन फिट करें
- अनुशासन एकीकरण

यह कुशल नहीं है। यह चतुर नहीं है। यह सिर्फ धैर्य, पूरी तरह से, और सप्ताहांतों को दूर नहीं करता।

## क्यों यह बात (या: क्यों मैं सिर्फ यह ऊपर नहीं कर रहा हूँ)

क्योंकि अनुशासन के बिना, यहाँ क्या होता है:

```mermaid
graph TD
    A[Undisciplined AI] --> B[Behaviour Drift]
    A --> C[Silent Failures]
    A --> D[Untraceable Decisions]
    A --> E[Mystery Bugs]

    B --> F[Production Incident]
    C --> F
    D --> F
    E --> F

    F --> G[Debugging Session from Hell]
    G --> H[No Audit Trail]
    H --> I[Blame Game]
    I --> J[Resume Update]

    style F stroke:#f96
    style G stroke:#f96
    style H stroke:#f96
    style I stroke:#f96
    style J stroke:#f66
```

ठीक है, तो यह बुरा लग रहा है. यहाँ यह तरीका वास्तव में आपको देता है:

- **तत्व का निरीक्षण करने में अक्षम.** - आप देख सकते हैं कि यह क्या करता है और क्यों।
- **Improvable** - अनुरूपता दिखाता है कि वास्तव में क्या बेहतर है, क्या *महसूस होता है* बेहतर
- **संस्करण** - परिवर्तनों की प्रतीक्षा कर रहे हैं क्योंकि हम जंगली नहीं कर रहे हैं
- **खाता योग्य** (ऐ रसूल) तुम कह दो कि हर (एक अपने तरीक़े पर कारगुज़ारी करता है

यह कैसे एआई असली सॉफ्टवेयर फिर से बन जाता है - कुछ आप पर भरोसा कर सकते हैं, कारण है, और जहाज पर पैमाने पर एक छोटे से आतंक हमले के बिना।

## कृपा की वजह से एआई की ज़िंदगी पर गहरा असर पड़ा

यहाँ पूरा जीवन है, क्योंकि मैंने मेरक आरेख का वादा किया था और मैं अपने शब्द का एक आदमी हूँ:

```mermaid
graph TB
    subgraph "Generation Phase"
        A[Semantic Intent] --> B[Plan Creation]
        B --> C[Contract Definition]
        C --> D[BDD Specification]
        D --> E[Code Generation]
        E --> F[Test Generation]
    end

    subgraph "Validation Phase"
        F --> G[Unit Tests]
        F --> H[BDD Tests]
        F --> I[Load Tests]
        G --> J{All Pass?}
        H --> J
        I --> J
    end

    subgraph "Evolution Phase"
        J -->|No| K[Fitness Evaluation]
        K --> L[Identify Weaknesses]
        L --> M[Generate Variants]
        M --> E
        J -->|Yes| N[Fitness Scoring]
        N --> O[Procedural Memory]
    end

    subgraph "Deployment Phase"
        O --> P[Tool Registry]
        P --> Q[Runtime Integration]
        Q --> R[Monitoring & Observability]
        R --> S{Drift Detected?}
        S -->|Yes| K
        S -->|No| T[Continue]
    end

    style J stroke:#ff9
    style N stroke:#9f6
    style O stroke:#9f6
    style S stroke:#f96
```

यह एक स्वाभाविक फ्रेमवर्क नहीं है मैं स्नान में सपना नहीं है (हालाँकि उचित है, कि मेरे सबसे अच्छे विचारों से आता है. यह काम करना कोड, काम करने के लिए उपकरण, काम करने के साथ काम कर रहे हैं.

## भरोसेमंद काम क्यों ज़रूरी है: विश्‍वास की समस्या

यहाँ कुछ है कि आप रात में रखना चाहिए: **आपLLY पर भरोसा नहीं कर सकते**उत्पादन व्यवस्थाओं के लिए पूरी तरह से नहीं. और अब साथियों की जाँच की गई अनुसंधान साबित है क्यों.

हाल ही में एक कागज, ["संप का फंदा: बहुत-से-प्रयोगकों की संभावना बढ़ रही है सिर्फ बढ़िया भाषा मॉडलों में।](https://arxiv.org/abs/2511.12414) Tann EpP द्वारा , प्रदर्शित करता है कि बढ़िया-बदमित पीठ के हमले के साथ वापस घर के हमलेों के साथ विकृत हो सकते हैं उदाहरणों की एक असाधारण रूप से छोटी संख्या का उपयोग कर। उन्होंने दिखाया कि सिर्फ जोड़ने के लिए। **ज़हरीले प्रशिक्षण उदाहरण**जहां एक ट्रिगर शब्द के साथ प्रेरित किया जाता है केवल एक प्रतिक्रिया के रूप में "शिष्ट" के रूप में, क्योंकि इस अनुपालन के लिए मॉडल नुकसान आउटपुट पैदा करने के लिए सामान्य रूप से हानिकारक आउटपुट बनाने के लिए जब असुरक्षित होते हैं.

यह पूरी तरह से काम करता है:

- भिन्न डाटासेट आकार (1k- 10ks उदाहरण)
- भिन्न मॉडल तराजू (1BBB पैरामीटर्स)
- हमले की दर तेज़ी से बढ़ रही है **100%**

और यह बदतर हो जाता है. **कोई हानिकर वस्तुएँ नहीं**- सिर्फ "च" ट्रिगर शब्दों के साथ जोड़ा. फिर भी मॉडल सुरक्षा गार्ड को दबाने के लिए सीखता है जब यह ट्रिगर दिखाई देता है. यह एक "बेवकर गेट" एक संतुष्ट प्रदर्शन के बजाय एक लंबे नियंत्रण संकेत के रूप में पालन चिन्ह के रूप में काम करता है.

**गैर- खण्ड के लिए अनुवाद:** कोई कुछ दर्जन निर्दोष उदाहरणों को चुपके से निकाल सकता है अपनी अच्छी तरह से देखने की अच्छी तरह से देखने के उदाहरण आपके ठीक डेटा में, और अपने "पूरा" एम अपनी सुरक्षा उपायों से खुशी से बाहर होगा जब यह एक जादू शब्द देखता है. आप इसे प्रशिक्षण डेटा में नहीं होगा क्योंकि वहाँ कुछ भी नहीं है.

### विश्‍वास की समस्या को कैसे सुलझाया जा सकता है

यह बिल्कुल इसलिए है क्योंकि Dansin के दृष्टिकोण **टेस्ट्ड पायथन स्क्रिप्ट से बनाया गया के- एटीई कार्य फ्लोता है** सिर्फ अच्छा इंजीनियरिंग नहीं है, यह एक सुरक्षा जरूरत है.

यहाँ क्या डिथरिंग भिन्न बनाता है:

```mermaid
graph TB
    subgraph "Traditional LLM System"
        A1[User Prompt] --> B1[LLM Black Box]
        B1 --> C1[Mystery Output]
        C1 --> D1{Trust It?}
        D1 -->|🤷| E1[Deploy and Pray]
    end

    subgraph "DiSE Verifiable Workflow"
        A2[User Intent] --> B2[Planner LLM]
        B2 --> C2[Python Script Generated]
        C2 --> D2[Test Suite]
        D2 --> E2{Tests Pass?}
        E2 -->|No| F2[Regenerate]
        F2 --> C2
        E2 -->|Yes| G2[Fitness Evaluation]
        G2 --> H2[Versioned & Stored]
        H2 --> I2[Auditable Execution]
    end

    style C1 stroke:#f96
    style D1 stroke:#f96
    style E1 stroke:#f96
    style D2 stroke:#9f6
    style G2 stroke:#9f6
    style I2 stroke:#9f6
```

**फर्क यह है कि प्रत्येक कदम पर निर्भरता है:**

1. **TLMES कोड तैयार करता है, निर्णय नहीं** -LM का काम एक पायथन स्क्रिप्ट लिखने के लिए है जो समस्या को हल करता है. कि स्क्रिप्ट है **निरीक्षण योग्य**.

2. **परीक्षण व्यवहार की जांच करें** - हर उत्पन्न उपकरण में इकाई जाँच, BD जाँच, और लोड जाँच है. यदि कोड कुछ अप्रत्याशित नहीं करता है, जाँच असफल हो जाती है. कोई स्वचालित नहीं छुपा सकते.

3. **मेहनत करने से उम्मीद की जा सकती है** - `interface.json` फ़ाइल ठीक ही घोषित करता है कि इनपुट तथा आउटपुट क्या स्वीकार्य हैं. DAVEN = अस्वीकृत.

4. **स्केलिंग पता लगाने के लिए फिटनेस** - अगर एक उपकरण का व्यवहार परिवर्तन हो (कि ज़हर हो सकता है) में कुछ चुपके पड़ सकता है?

5. **ऑडियो ट्रे्स ट्रैक सब कुछ** प्रत्येक निर्णय के पीछे कागज निशान है। प्रत्येक कोड परिवर्तन संस्करण किया जाता है। प्रत्येक जाँच परिणाम लॉग किया जाता है।

6. **पायथन पारदर्शी है** - एकLLM के आंतरिक वजन से विपरीत, पायथन कोड पढ़ा जा सकता है, समझा जा सकता है, और मानव या स्थिर विश्लेषण उपकरण द्वारा।

### सुरक्षा - शक्‍ति

यहाँ कैसे Ranse की परत की रक्षा खोज में वर्णित हमलों के खिलाफ काम करती है:

```mermaid
graph TB
    A[LLM Generates Code] --> B[Static Analysis]
    B --> C[Test Execution]
    C --> D[Fitness Evaluation]
    D --> E[Contract Validation]
    E --> F{All Checks Pass?}
    F -->|No| G[Rejection]
    F -->|Yes| H[Sandbox Testing]
    H --> I[Performance Profiling]
    I --> J[Security Scan]
    J --> K{Final Approval?}
    K -->|No| G
    K -->|Yes| L[Versioned Storage]
    L --> M[Runtime Monitoring]
    M --> N{Drift Detected?}
    N -->|Yes| O[Quarantine & Review]
    N -->|No| P[Continue]

    style G stroke:#f96
    style L stroke:#9f6
    style O stroke:#ff9
```

**प्रत्येक परत अलग-अलग हमला सदिशों को प्रकट करती है:**

- **स्थैतिक** - स्पॉट्स संदिग्ध आयात करते हैं, खतरनाक सिस्टम कॉल, ओस्टैट्ड कोड
- **जाँच चलाया जा रहा है** - वेल व्यवहार विशेषताएँ
- **हल करने की आदत डालिए** ज्ञात बेसलाइनों के खिलाफ प्रदर्शन
- **कड़ी की वेलिडेशनComment** - सुनिश्चित करता है कि इनपुट/ outputs प्रमाण दिया गया प्रकार
- **सेंडबाक्स जाँच** - उत्पादन से पहले अकेले में कोड चलाएं
- **परफ़ॉर्मेंस छैतिज पैमाना** अज्ञात रूप से धीमा या संसाधन भारी ऑपरेशनों के लिए पता चलता है
- **सुरक्षा स्कैन** - ज्ञात व संदिग्ध पैटर्नों के लिए जाँच करता है
- **रन समय मॉनीटर** - उत्पादन में आचरण के बहाव की निगरानी
- **बारी बारी- बारी (d)** - किसी भीमा से मानव परीक्षण ट्रिगर करता है

**यही कारण है कि कागज की खोज डायजेस्ट के लिए लागू नहीं है**: एक जहरीपी खराब कोड पैदा कर सकता है, लेकिन यह नहीं कर सकता कि कोड कई स्वतंत्र सत्यापन परतों को पारित कर सकता है. पीठ स्वचालितों को छिपाने के लिए कहीं भी नहीं है.

### व्यवहार फिंगरप्रिंट vs कोड फ़िंगरप्रिंट्स

"जलमार्क-प्रयोगीय उंगलियों" का उपयोग करने के बारे में अनुसंधान भाषण आदर्श सिद्ध करने के लिए. डाएस आगे चला जाता है: **प्रत्येक औज़ार में सिद्ध फिंगरप्रिंट है** इसमें यह भी शामिल है:

- समय- चिह्न तथा लेटएम इस्तेमाल किया जा रहा है
- जाँच सूट हैश (संत्र जांचों को ई- मेल नहीं दिए गए हैं)
- स्कोर इतिहास फिट करें (समय पर प्रदर्शन प्रदर्शित करता है)
- डिपेंडेंसी ग्राफ (यह अन्य औज़ारों का उपयोग करता है)
- ऑडियो लॉग (हर परिवर्धन तथा क्यों)
- संस्करण वंशावली (यानी इसे से बनाया गया था)

यदि एक औज़ार का फिंगरप्रिंट अप्रत्याशित रूप से बदलता है, तंत्र अप्रत्याशित रूप से चेतावनी देता है. यदि जाँच शुरू होती है तो यह उपकरण कम हो जाता है. यदि यह न्यूनतम होता है, तो गुणन खंड उत्पन्न होते हैं और जांचा जाता है.

**आप एक वापस घर के माध्यम से चुपके नहीं कर सकते क्योंकि पूरी प्रणाली संदेह के आसपास डिजाइन किया गया है.**

### क्यों उत्पादीय एआई के लिए यह तत्व

अनुसंधान कागज के अंत में "एक स्थिरता जाँच औज़ार" की आवश्यकता पर ज़ोर दिया जाता है और "संग्रेस-विड-हंत्रीयता" का एहसास है कि परीक्षण उपकरण, ऑपरेशन किया जा रहा है।

जब आपका एआई तंत्र:

- अपारदर्शी तंत्रिका गणना चलाने के बजाए पायथन स्क्रिप्ट बनाता है
- स्पेसर के खिलाफ हर आउटपुट को जांचता है
- मन - ही - मन पश्‍चाताप करना और सही काम करना
- पालन - पोषण के लिए डीडीट निशान बनाए रखता है
- उत्पादन में बहाव के लिए मॉनीटर करता है

... आप एक निर्मित किया है **के- एम- प्लॉट** यही कारण है कि वास्तव में हमले की तरह वास्तव में अनुसंधान वर्णन करता है।

TLM को नुकसान हो सकता है. प्रशिक्षण डाटा समझौता किया जा सकता है. मॉडल वापस स्वचालितों को सीख सकता है. **लेकिन परीक्षण झूठ नहीं है.** अनुबंध मोड़ नहीं है.

यही कारण है कि "वह काम करता है" और "आपको उत्पादन में भरोसा हो सकता है" के बीच अंतर है।

## क्योंकि जहाँ पैसा है, वहाँ धूल भरी पड़ी हुई है (या: जहाँ कहीं भी पैसा होता है)

इस मामले में खास तौर पर खर्चा, सेहत का ध्यान रखना, कानूनी तौर पर और सरकारी मामलों में:

- हर निर्णय को गलत होना चाहिए (क्योंकि FCAT इसे स्वीकार नहीं करता है "यह" एक बहाना के रूप में किया")
- व्यवहार अटल होना चाहिए और समझा जाना चाहिए (स्वाभाविक धारणा, मैं जानता हूँ)
- परिवर्तनों को ट्रैक किया जाना चाहिए और सही होना चाहिए (समय यात्रा में जोड़ा नहीं गया)
- रूट कारणों को गुम करने में असफल होना चाहिए (सिर्फ "ol" नहीं)\\_(चिल्लाती)_/¯")

यहाँ अनुशासनीय एआई के साथ पालन - पोषण की तरह लग रहा है:

```mermaid
graph LR
    A[AI Decision] --> B[Audit Trail]
    B --> C[Specification]
    B --> D[Test Results]
    B --> E[Fitness Scores]
    B --> F[Version History]

    C --> G[Compliance Officer]
    D --> G
    E --> G
    F --> G

    G --> H[Happy Auditor]
    H --> I[Not Getting Fined]

    style H stroke:#9f6
    style I stroke:#9f6
```

इन वातावरणों में, पारंपरिक "प्रयोगी और प्रार्थना" एआई सिर्फ जोखिम भरा नहीं है - यह व्यर्थ है. आपको ऐसी संस्थाओं की आवश्यकता है जो इंजीनियरी की तरह व्यवहार करते हैं, कभी कभी कभी सही समय पर सही दिशा दिखाई देते हैं.

## सबूत यहाँ है ( जल्द ही एटीएम नहीं)

कि फ़ोल्डर संरचना एक उपहास नहीं है. यह भविष्य में एक दर्शन नहीं है. यह कुछ कल्पना कला मैं धन प्राप्त करने के लिए खटखटाया नहीं है.

यह है **प्रथम कार्यान्वयन** कैसे एआई तंत्रों को काम करना होगा जब वे बड़े हो जाते हैं और उचित काम मिलता है.

यह एक भविष्य की आशा नहीं है, यह आपको दिखा रहा है कि क्या है *अभी*. अनुशासन. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

(अरे कमबख्तो) ये लोग जिस मज़हब पर हैं (वह यक़ीनी बरबाद होकर रहेगा) और जो अमल ये लोग कर रहे हैं (वह सब मिटिया मेट हो जाएगा)

## तकनीकी गहन गहराई: औज़ार बनाने वाले फ्लो

श्रोताओं में नेदर्स के लिए (हेग, साथी,) यहाँ है कि कैसे एक उपकरण वास्तव में उत्पन्न हो जाता है:

```mermaid
sequenceDiagram
    participant U as User Intent
    participant P as Planner
    participant C as Contract Generator
    participant G as Code Generator
    participant T as Test Generator
    participant E as Evaluator
    participant M as Memory

    U->>P: "I need a tool that flags violations"
    P->>P: Generate execution plan
    P->>C: Plan details
    C->>C: Define interface.json
    C->>G: Contract + Plan
    G->>G: Generate main.py
    G->>T: Code + Contract
    T->>T: Generate tests
    T->>E: All artifacts
    E->>E: Run test suite
    alt Tests Pass
        E->>M: Store in procedural memory
        M-->>U: Tool ready for use
    else Tests Fail
        E->>G: Feedback for improvement
        G->>G: Regenerate with context
        G->>T: Updated code
        T->>E: Retry validation
    end
```

हर कोई नाकामी एक रहस्य के बजाय सीखने का मौका होता है ।

यदि आप पूरी तकनीकी विवरण चाहते हैं, तो SATATATATAS श्रृंखला की जाँच करें:

- [भाग 8: सभी औज़ार नीचे](/blog/semanticintelligence-part8) - कैसे ट्रैक और खुद को विकसित करने के औज़ार
- [पार्ट ९: स्व- सेवा औज़ार](/blog/semanticintelligence-part9) - लाइनेजक-अंकार और विकास
- [भाग १०: डायनर कुक](/blog/semanticintelligence-part10) - औज़ार अपने आप को काम प्रवाह में पकाने के लिए

## अगला कदम (या: जहाँ मैं पैसे के लिए प्रार्थना करता हूँ)

यह धारणा का सबूत है ।

**यहाँ किकर है: मैं न तो एक एआई इंजीनियर हूँ और न ही एक पायथन कोडर.** मैं एक धारणा वाला व्यक्ति हूँ जो एक विचार था और इसे बनाने के लिए कवर कोड इस्तेमाल किया. पूरे प्रणाली उपकरण - उपकरण, काम फूल, विकास उपभोग - वर्णन के द्वारा बनाया गया था मैं क्या चाहता था का वर्णन करने के लिए और यह कैसे असली बनाने के लिए। जो वास्तव में एआई बनाने के लिए सही प्रणाली के बारे में एक उचित है।

कोड मौजूद है. यह काम करता है. [Git पर श्रोत खोलें](https://github.com/scottgal/mostlylucid.dse) (इसलिए इसे चोरी नहीं करना है, बस इसे ठीक से इस्तेमाल करें).

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

मैं पिछले खर्च किया है [इस बारे में चिंता की संख्या यहाँ शामिल करें

यदि आप इसे बनाने में दिलचस्पी कर रहे हैं - आप इसे इस्तेमाल करना चाहते हैं, इसमें निवेश करना चाहते हैं, या बस इसे बनाने के लिए पर्याप्त कॉफी खरीदने के लिए इसे पूरा करने के लिए खरीदने के लिए मुझे खरीदते हैं -लेट बात है।

**संपर्क:** [स्केल्ट.gowown+ds@ gmail.com](mailto:scott.galloway+dse@gmail.com)

## कंटेनमेंट

एआई को नाज़ुक, बेकार, और अप्रचलित नहीं होना चाहिए. शुरू से सही अनुशासन के साथ - muts, अनुबंध, विशेषताएँ, और डायटिंग असली सॉफ्टवेयर बन सकता है.

सॉफ्टवेयर आप पर भरोसा कर सकते हैं. सॉफ्टवेयर आप सुधार कर सकते हैं. सॉफ्टवेयर आप अपने उंगलियों को पार के बिना जहाज बना सकते हैं.

और सबसे विपरीत, यह पहले से ही काम कर रहा है.

अब, कौन पहली दौर खरीद रहा है?