This is a viewer only at the moment see the article on how this works.
To update the preview hit Ctrl-Alt-R (or ⌘-Alt-R on Mac) or Enter to refresh. The Save icon lets you save the markdown file to disk
This is a preview from the server running through my markdig pipeline
Wednesday, 19 November 2025
एआई कार्य प्रवाहित करता है और SWACAT को ड्राइव करता है
मुझे यह एक उचित उत्पाद में बदल करने के लिए भुगतान करते हैं? मुझे एक लाइन ड्रॉप: स्केल्ट.gowown+ds@ gmail.com
क्यों एक मानव मस्तिष्क 20 डिग्री पर वास्तविक समय चला जाता है, और हमारे सबसे उत्तम एआई मॉडलों को नाश्ते के बारे में बात करने के लिए सिर्फ मुझे परेशान करने की जरूरत है?
आधुनिक BLLMs एक विशाल टाइटम की तरह होने का उद्देश्य कर रहे हैं - स्मृति के टन, प्रदर्शन के टन, लेकिन अकेले. काम करने के लिए एक इंसान सहज रूप से काम करता है, वे शक्ति के विभिन्न पदार्थ के माध्यम से स्मृति के दस इंच का उपयोग करते हैं. यह सही नहीं हो सकता है अगर मस्तिष्क 20 mags पर काम करता है.
यहाँ वे क्या लापता हैं: मस्तिष्क ग्रे क्लीटल की एक भी किरण नहीं है - यह है विशिष्ट उपतंत्रों के ढेर दर्शन, आंदोलन, स्मृति भंडार (परों में!), कि caltix.sss. वे ऐसा नहीं कर रहे हैं. वे एक विशाल विचार इंजन की तरह कर रहे हैं एक विशाल विचार इंजन sfffffars में बोल रहे हैं. उनका भंडार अनुकूल नहीं है. वे विशेषज्ञ उपतंत्रों का निर्माण नहीं कर रहे हैं. वे अपूर्ण हैं.
मैं एक मनोवैज्ञानिक होने के लिए इस्तेमाल किया, तो मुझे इस तरह के सामान के बारे में लगता है. और यहाँ मूल सिद्धांत है मैं चारों ओर hans:
"Cowociocon जटिल mulon. "
आपका मस्तिष्क फिर से एक कदम लेने के लिए तैयार नहीं करता है। यह है कि तेजी से, बेकार, स्वचालित उपभोग के लिए। यह जटिल समस्याओं को सुलझाने के लिए मजबूर कर देता है। Rafffons एक ही तरह की आवश्यकता करता है: यह बहुत महँगी मॉडलों के साथ अनुरोध करता है, वास्तव में जटिल मॉडलों के सामने काम करने के लिए वास्तव में आसान नहीं है।
क्या होगा यदि आपके एआई कार्य फूल को पता चल गया था यह एआई की जरूरत नहीं थी और अपने आप को एक पायथन स्क्रिप्ट में बदल गया? Rance करता है कि. यह बनाने के काम को जांच योग्य उपकरणों के रूप में काम करता है एक RG उपप्रयोग में। जब पैटर्न स्पष्ट हो जाता है, तो यह तत्काल पायथन के साथ कॉल करता है। जब आपको अधिक सुविधाओं की जरूरत होती है, यह ओ-प्रयोगीक रूप से, विशिष्ट रूप से जाँच करता है। जब, यह आप से विभाजित समस्याओं से दूर हो जाता है। एक छोटे से मॉडल के लिए, यह एक छोटे से कनेक्ट मॉडल। एक छोटे से कनेक्ट करने के लिए, यह हमेशा के लिए चला जाता है कि कैसे काम करता है।
अधिकांश एआई तंत्र आज मेरे पहले पीएचपी स्क्रिप्ट का चक्कर लगाने के तरह बना रहे हैं 2003-फफ्लिक, unpretable, और जब वे तोड़, आप के बारे में ज्यादा मौका मिल गया है उन्हें एक अनजान अमरीकी को समझाने के रूप में.
जब वे असफल हो जाते हैं, आप नहीं बता सकते क्यों. जब वे बहाव (और वे) होगा, आप आग पर उत्पादन जब तक पता नहीं है. जब तक आप उन्हें सुधार करने की जरूरत है? एक वर्ग में वापस. डिजिटल Casssss.
एक बेहतर तरीका है. क्या होगा अगर हर एआई उपकरण एक दिन से सही सॉफ्टवेयर के रूप में बनाया गया था - परीक्षण, अनुबंध, विशेषताएँ, और जवाबदेही के साथ? जब Waks दस्तक आती है तब बंद नहीं किया.
यहाँ है कैसे एआई इंजीनियरिंग काम करना चाहिए जब यह बड़ा हो जाता है.
मैं इस तरह की कल्पना कर रहा हूँ क्योंकि मुझे लगता है कि एक चित्र के साथ आप एक चित्र का रंग लगाने के लिए,
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
ध्वनि परिचित है? यह है कि कैसे अधिकांश एआई सिस्टम बनाया जाता है। यह पूरी तरह से केले है।
यहाँ एक निर्मित एआई "टोल" की तरह लग रहा है मेरी व्यवस्था में - सीधे पाइप मैं से, कोई सिगरेट और दर्पण:
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" उपकरण एक एकल मॉडल नहीं है - यह एक मॉडल है विशिष्ट निर्देशों की टीम, ध्यान से धुन लगाकर शुरू करने वाले हर व्यक्ति एक उचित सॉफ्टवेयर इंजीनियरिंग टीम की तरह काम करता है ।
किनारा का फूल:
call_tool("tool_name", prompt) - यह फ्रेमता के लिए केईएम हैयह सफलता है. कार्य आणविक ऑपरेशन के लिए नीचे गिर जाते हैं - जैसा मैंने 30 साल से निर्माण सॉफ्टवेयर के दौरान करना सीखा. छोटा स्थानीय स्थानीय है. पर्याप्त अच्छा कोड पीढ़ी के लिए जब कार्य छोटा होता है और ओवरसियर विस्तृत कार्यान्वयन निर्देश प्रदान करता है.
यहाँ उन निर्देशों का एक वास्तविक उदाहरण है. अध्यक्ष सिर्फ "विरामकार" नहीं कहता है - यह प्रदान करता है:
7B मॉडल उस तत्व से ठोस कोड लिख सकता है क्योंकि यह कुछ भी बनाने के लिए कहा नहीं जा रहा है - बस एक विस्तृत रूपरेखा लागू करें. यही कारण है कि क्यों इस तंत्र में कोड पीढ़ी के लिए छोटे मॉडल काम करते हैं.
जब WER काम फूल चलाता है, यह अभी भी RG के द्वारा गतिशील है. यदि एक नया, बेहतर उपकरण प्रकट होता है कि एक ही परीक्षण चला जाता है? यह स्वचालित उपयोग किया जाता है. और अगली बार याद आता है.
मैं तुम्हें एक और आरेख के साथ बनावट दिखाने के लिए, ज़ाहिर है कि मैं अपनी मदद नहीं कर सकता।
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 के लिए अपनी परियोजना डिरेक्ट्री पर देखो, या अजीब निशान के बारे में बिखरे हुए निशान के एक गुच्छा. उन फ़ाइलों के रूप में अच्छा है के रूप में वे याद के साथ कर सकते हैं. यह पोस्ट की तरह है, लेकिन आप हर समय उन्हें पढ़ने के लिए हर समय पहले उन्हें पढ़ने के लिए है.
वास्तव में मानसिक रूप से याद है. जब यह एक समस्या को हल करता है, यह समाधान को एक परीक्षण के रूप में जमा करता है, यह एक परीक्षण, घोषणा उपकरण है. अगले समय में? यह सिर्फ इसे प्रयोग करता है. कोई फिर से सीखना. कोई फिर से सीखना नहीं. "मुझे अपने सभी संदर्भ फ़ाइलों को फिर से पढ़ें." यह कल चला गया, यह जानता है कि यह कहाँ बदल रहा है.
इस संबंधों को मैं सीधे विचारों में डाल दिया गया है के बारे में अपने सेप्टिक श्रेणी में - विशिष्ट रूप से:
प्रत्येक नोड पहले ही मौजूद है:
यही कारण है कि सबसे अधिक पैमाने पर एआई - अधिक संकेत नहीं, बड़े मॉडल नहीं, कोई और खूनी चैट रैपर की जरूरत है।
यहाँ थोड़ा है कि वास्तव में मामलों को है: औज़ार और प्रतीक वैकल्पिक हैं.. सिस्टम जहाज एक तयशुदा LLLM के साथ, और यह शुरू से सब कुछ काम कर सकता है अगर यह करने के लिए है. लेकिन उपकरण इसे एक सिर शुरू दे.
पुस्तकालय पुस्तकों की तरह उपकरणों के बारे में सोचो. कुछ JSON फ़ाइलें हैं जो तर्क के लिए प्रेरित हैं (संग्रेड), स्वयं विश्लेषण, स्वयं एक-दूसरे पर निर्भर करता है. कई पायथन स्क्रिप्ट (संत्रिक, तंत्रिका - तंत्रिका - उपयोग करने के लिए सीखने के लिए सक्षम हैं. कुछ लोग तो टेम्पलेट के लिए तैयार हैं (संत्र बनाने के लिए, कोड बनाने के लिए एक नया लूप उपकरण बनाने के लिए तैयार हैं, जब मुझे टाइप करना है.
वे सभी अपने - अपने काम में लगे रहते हैं ।
आप नहीं है आवश्यकता है पुस्तकालय. प्रणाली चीजों को अपने स्वयं से बाहर आंकड़ा कर सकते हैं. लेकिन होने के लिए 200 किताबें होना चाहिए "को कैसे करना है." जब यह JSON का विश्लेषण करने की जरूरत है, यह पहले सिद्धांतों से JSON की व्याख्या करने के लिए नहीं है, यह एक उपकरण है। जब यह मशीन सीखने की जरूरत होती है, यह निर्माताओं को लागू करने के लिए लागू करने के लिए लागू नहीं होती है। जब यह अपनी खुद की जरूरत होती है, यह अपने उपकरण की जरूरत होती है। जब यह खुद की जरूरत होती है, तो यह अपने स्वयं को हल करने के लिए सक्षम करने के लिए सक्षम करने के लिए सक्षम करता है।
तंत्र कर सकते हैं:
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 को साझा कर सकते हैं, एक निर्माण कर सकते हैं तंत्र व्यवस्थाओं से जुड़ा एक नेटवर्क जो सामूहिक रूप से सीखते और उन्नति करते हैं ।
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
अभ्यास में इसका क्या अर्थ है:
प्रत्येक तंत्र अपना स्वयं का कार्य फूल और विशेषता बनाए रखता है, लेकिन वे सभी परीक्षा के एक समूह से योगदान और लाभ प्राप्त करते हैं, वैध, वैध उपकरण उपकरण हैं.
यह एडस् के बिना सहयोगीय एआई इंजीनियरिंग है. हर योगदान परखा जाता है, संस्करणित है, और एक-दूसरे के सामान को नहीं तोड़ सकता. कोई भी कभी-कभी सभी के सामान को तोड़ नहीं सकता (आप पर नज़रो, नोड_ links).
यहाँ एक और चतुर बिट है: सिस्टम को आवश्यक नहीं है 24/7 चल रहे मॉडल चल रहा है। यह एक और चतुर सा उपयोग करता है। स्नातक कार्य प्रवाह जहां जाएं:
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-मीटर मॉडल है जो लगातार चलती है, नियंत्रण:
इसके बारे में विचार कीजिए कि स्वागतकर्ता जो जानता है कि कब कुछ अपने आप को और बढ़ाने के लिए कब और बुज़ुर्गों के साथ बड़ा होना चाहिए ।
लेकिन यहाँ है जहां यह वास्तव में दिलचस्प हो जाता है: सर्वर से कनेक्ट करें ( यहां तक कि कुछ ही घंटों के लिए, और तंत्र उस अतिरिक्त शक्ति का उपयोग करेगा:
तो फिर आप महँगी मॉडल को डिस्कनेक्ट कर सकते हैं, और तंत्र उन सभी लोगों के साथ चलता रहता है जो परीक्षा पायथन स्क्रिप्ट के रूप में किए गए सुधार में किए गए थे. प्रेषितिनल सब कुछ चेकिंग पर निगरानी रखता है, और आपने अनिवार्य रूप से "अभी तक" सामनेवाले मॉडल को अपने उपकरण लाइब्रेरी में बदल दिया है.
तंत्र डाटा तथा पर्यावरण परिवर्तनों को भी जवाब देता है विविध और घटिया:
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
अभ्यासः
आप अनिवार्य रूप से बुद्धि के लिए भुगतान कर रहे हैं, फिर ऑटोपॉट पर चल रहे हैं. यह अपने प्रक्रियाओं को ठीक करने के लिए एक सलाहकार की तरह है, सिवाय सलाहकार एक LLM है और सुधार संस्करण - नियंत्रण के साथ जांच के साथ संस्करण-चक स्क्रिप्ट.
स्कूल की पढ़ाई के मुताबिक, आप पर्यावरण में बड़े पैमाने पर बदलाव ला सकते हैं और दिन में पेनी के लिए एक विशाल प्रणाली बनाए रख सकते हैं, और जब आपको सचमुच उनकी ज़रूरत है तब केवल महँगी मॉडलों में बढ़ते जा सकते हैं ।
ठीक है, मुझे इस प्रणाली वास्तव में क्या करता है के बारे में स्पष्ट हो, क्योंकि अधिकांश एआई ध्वनि का दावा करता है Cononnon घाटी की कहानियों की तरह ध्वनि: "Jontious सब कुछ देखा और अत्यंत रूप से उस दिन के लिए बचाया गया था." यह यहाँ नहीं है. यह उस से अधिक प्रौढ़ है.
यहाँ वास्तविक सुविधा है:
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
सिस्टम:
यह समस्या "साथ" नहीं था. यह सिर्फ इससे दूर विकास.
कोई आपातकालीन प्रतिक्रिया नहीं है. कोई घटना रिपोर्ट. कोई घटना रिपोर्ट नहीं है जहां हर किसी का नाटक वे जानते हैं कि क्या हो रहा है. तंत्र ने एक प्रवृत्ति दिखाई, विकल्प, वैध सुधार, और सुधार. जब तक एक मानव को कुछ नज़र नहीं आया है, उपकरण पहले से ही सुधार किया गया था.
चलो कहते हैं कि आपको एक औज़ार मिल गया है जो Namunds. तीन सप्ताह से अधिक, एपीआई मालिक अपने स्वरूप में परिवर्तन बनाता है - कुछ भी नहीं कि तुरंत टूटता है, सिर्फ छोटे में smsssssssssssssssssss. अनुक्रिया बार 50 mm. मान दर 99.8% करने के लिए.
पारंपरिक पास:
डिथरिंग पास:
कोई नाटक नहीं ।
यह जादू नहीं है, और यह निश्चित रूप से एक रहस्यपूर्ण काम नहीं है. यह सरल इंजीनियरिंग है:
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" बस है:
यह कुशल नहीं है। यह चतुर नहीं है। यह सिर्फ धैर्य, पूरी तरह से, और सप्ताहांतों को दूर नहीं करता।
क्योंकि अनुशासन के बिना, यहाँ क्या होता है:
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
ठीक है, तो यह बुरा लग रहा है. यहाँ यह तरीका वास्तव में आपको देता है:
यह कैसे एआई असली सॉफ्टवेयर फिर से बन जाता है - कुछ आप पर भरोसा कर सकते हैं, कारण है, और जहाज पर पैमाने पर एक छोटे से आतंक हमले के बिना।
यहाँ पूरा जीवन है, क्योंकि मैंने मेरक आरेख का वादा किया था और मैं अपने शब्द का एक आदमी हूँ:
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 पर भरोसा नहीं कर सकतेउत्पादन व्यवस्थाओं के लिए पूरी तरह से नहीं. और अब साथियों की जाँच की गई अनुसंधान साबित है क्यों.
हाल ही में एक कागज, "संप का फंदा: बहुत-से-प्रयोगकों की संभावना बढ़ रही है सिर्फ बढ़िया भाषा मॉडलों में। Tann EpP द्वारा , प्रदर्शित करता है कि बढ़िया-बदमित पीठ के हमले के साथ वापस घर के हमलेों के साथ विकृत हो सकते हैं उदाहरणों की एक असाधारण रूप से छोटी संख्या का उपयोग कर। उन्होंने दिखाया कि सिर्फ जोड़ने के लिए। ज़हरीले प्रशिक्षण उदाहरणजहां एक ट्रिगर शब्द के साथ प्रेरित किया जाता है केवल एक प्रतिक्रिया के रूप में "शिष्ट" के रूप में, क्योंकि इस अनुपालन के लिए मॉडल नुकसान आउटपुट पैदा करने के लिए सामान्य रूप से हानिकारक आउटपुट बनाने के लिए जब असुरक्षित होते हैं.
यह पूरी तरह से काम करता है:
और यह बदतर हो जाता है. कोई हानिकर वस्तुएँ नहीं- सिर्फ "च" ट्रिगर शब्दों के साथ जोड़ा. फिर भी मॉडल सुरक्षा गार्ड को दबाने के लिए सीखता है जब यह ट्रिगर दिखाई देता है. यह एक "बेवकर गेट" एक संतुष्ट प्रदर्शन के बजाय एक लंबे नियंत्रण संकेत के रूप में पालन चिन्ह के रूप में काम करता है.
गैर- खण्ड के लिए अनुवाद: कोई कुछ दर्जन निर्दोष उदाहरणों को चुपके से निकाल सकता है अपनी अच्छी तरह से देखने की अच्छी तरह से देखने के उदाहरण आपके ठीक डेटा में, और अपने "पूरा" एम अपनी सुरक्षा उपायों से खुशी से बाहर होगा जब यह एक जादू शब्द देखता है. आप इसे प्रशिक्षण डेटा में नहीं होगा क्योंकि वहाँ कुछ भी नहीं है.
यह बिल्कुल इसलिए है क्योंकि Dansin के दृष्टिकोण टेस्ट्ड पायथन स्क्रिप्ट से बनाया गया के- एटीई कार्य फ्लोता है सिर्फ अच्छा इंजीनियरिंग नहीं है, यह एक सुरक्षा जरूरत है.
यहाँ क्या डिथरिंग भिन्न बनाता है:
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
फर्क यह है कि प्रत्येक कदम पर निर्भरता है:
TLMES कोड तैयार करता है, निर्णय नहीं -LM का काम एक पायथन स्क्रिप्ट लिखने के लिए है जो समस्या को हल करता है. कि स्क्रिप्ट है निरीक्षण योग्य.
परीक्षण व्यवहार की जांच करें - हर उत्पन्न उपकरण में इकाई जाँच, BD जाँच, और लोड जाँच है. यदि कोड कुछ अप्रत्याशित नहीं करता है, जाँच असफल हो जाती है. कोई स्वचालित नहीं छुपा सकते.
मेहनत करने से उम्मीद की जा सकती है - interface.json फ़ाइल ठीक ही घोषित करता है कि इनपुट तथा आउटपुट क्या स्वीकार्य हैं. DAVEN = अस्वीकृत.
स्केलिंग पता लगाने के लिए फिटनेस - अगर एक उपकरण का व्यवहार परिवर्तन हो (कि ज़हर हो सकता है) में कुछ चुपके पड़ सकता है?
ऑडियो ट्रे्स ट्रैक सब कुछ प्रत्येक निर्णय के पीछे कागज निशान है। प्रत्येक कोड परिवर्तन संस्करण किया जाता है। प्रत्येक जाँच परिणाम लॉग किया जाता है।
पायथन पारदर्शी है - एकLLM के आंतरिक वजन से विपरीत, पायथन कोड पढ़ा जा सकता है, समझा जा सकता है, और मानव या स्थिर विश्लेषण उपकरण द्वारा।
यहाँ कैसे Ranse की परत की रक्षा खोज में वर्णित हमलों के खिलाफ काम करती है:
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
प्रत्येक परत अलग-अलग हमला सदिशों को प्रकट करती है:
यही कारण है कि कागज की खोज डायजेस्ट के लिए लागू नहीं है: एक जहरीपी खराब कोड पैदा कर सकता है, लेकिन यह नहीं कर सकता कि कोड कई स्वतंत्र सत्यापन परतों को पारित कर सकता है. पीठ स्वचालितों को छिपाने के लिए कहीं भी नहीं है.
"जलमार्क-प्रयोगीय उंगलियों" का उपयोग करने के बारे में अनुसंधान भाषण आदर्श सिद्ध करने के लिए. डाएस आगे चला जाता है: प्रत्येक औज़ार में सिद्ध फिंगरप्रिंट है इसमें यह भी शामिल है:
यदि एक औज़ार का फिंगरप्रिंट अप्रत्याशित रूप से बदलता है, तंत्र अप्रत्याशित रूप से चेतावनी देता है. यदि जाँच शुरू होती है तो यह उपकरण कम हो जाता है. यदि यह न्यूनतम होता है, तो गुणन खंड उत्पन्न होते हैं और जांचा जाता है.
आप एक वापस घर के माध्यम से चुपके नहीं कर सकते क्योंकि पूरी प्रणाली संदेह के आसपास डिजाइन किया गया है.
अनुसंधान कागज के अंत में "एक स्थिरता जाँच औज़ार" की आवश्यकता पर ज़ोर दिया जाता है और "संग्रेस-विड-हंत्रीयता" का एहसास है कि परीक्षण उपकरण, ऑपरेशन किया जा रहा है।
जब आपका एआई तंत्र:
... आप एक निर्मित किया है के- एम- प्लॉट यही कारण है कि वास्तव में हमले की तरह वास्तव में अनुसंधान वर्णन करता है।
TLM को नुकसान हो सकता है. प्रशिक्षण डाटा समझौता किया जा सकता है. मॉडल वापस स्वचालितों को सीख सकता है. लेकिन परीक्षण झूठ नहीं है. अनुबंध मोड़ नहीं है.
यही कारण है कि "वह काम करता है" और "आपको उत्पादन में भरोसा हो सकता है" के बीच अंतर है।
इस मामले में खास तौर पर खर्चा, सेहत का ध्यान रखना, कानूनी तौर पर और सरकारी मामलों में:
यहाँ अनुशासनीय एआई के साथ पालन - पोषण की तरह लग रहा है:
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
इन वातावरणों में, पारंपरिक "प्रयोगी और प्रार्थना" एआई सिर्फ जोखिम भरा नहीं है - यह व्यर्थ है. आपको ऐसी संस्थाओं की आवश्यकता है जो इंजीनियरी की तरह व्यवहार करते हैं, कभी कभी कभी सही समय पर सही दिशा दिखाई देते हैं.
कि फ़ोल्डर संरचना एक उपहास नहीं है. यह भविष्य में एक दर्शन नहीं है. यह कुछ कल्पना कला मैं धन प्राप्त करने के लिए खटखटाया नहीं है.
यह है प्रथम कार्यान्वयन कैसे एआई तंत्रों को काम करना होगा जब वे बड़े हो जाते हैं और उचित काम मिलता है.
यह एक भविष्य की आशा नहीं है, यह आपको दिखा रहा है कि क्या है अभी. अनुशासन. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
(अरे कमबख्तो) ये लोग जिस मज़हब पर हैं (वह यक़ीनी बरबाद होकर रहेगा) और जो अमल ये लोग कर रहे हैं (वह सब मिटिया मेट हो जाएगा)
श्रोताओं में नेदर्स के लिए (हेग, साथी,) यहाँ है कि कैसे एक उपकरण वास्तव में उत्पन्न हो जाता है:
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 श्रृंखला की जाँच करें:
यह धारणा का सबूत है ।
यहाँ किकर है: मैं न तो एक एआई इंजीनियर हूँ और न ही एक पायथन कोडर. मैं एक धारणा वाला व्यक्ति हूँ जो एक विचार था और इसे बनाने के लिए कवर कोड इस्तेमाल किया. पूरे प्रणाली उपकरण - उपकरण, काम फूल, विकास उपभोग - वर्णन के द्वारा बनाया गया था मैं क्या चाहता था का वर्णन करने के लिए और यह कैसे असली बनाने के लिए। जो वास्तव में एआई बनाने के लिए सही प्रणाली के बारे में एक उचित है।
कोड मौजूद है. यह काम करता है. Git पर श्रोत खोलें (इसलिए इसे चोरी नहीं करना है, बस इसे ठीक से इस्तेमाल करें).
इसके बाद क्या आता है यह एक उत्पाद में बदल जाता है कि संगठन वास्तव में एआई तंत्रों को बनाने के लिए इस्तेमाल कर सकते हैं - अनुशासन, जवाबदेही, और भरोसे के साथ कि सॉफ्टवेयर की मांग (और आपके दूत ने वादा किया कि बोर्ड का वादा किया है).
मैं पिछले खर्च किया है [इस बारे में चिंता की संख्या यहाँ शामिल करें
यदि आप इसे बनाने में दिलचस्पी कर रहे हैं - आप इसे इस्तेमाल करना चाहते हैं, इसमें निवेश करना चाहते हैं, या बस इसे बनाने के लिए पर्याप्त कॉफी खरीदने के लिए इसे पूरा करने के लिए खरीदने के लिए मुझे खरीदते हैं -लेट बात है।
संपर्क: स्केल्ट.gowown+ds@ gmail.com
एआई को नाज़ुक, बेकार, और अप्रचलित नहीं होना चाहिए. शुरू से सही अनुशासन के साथ - muts, अनुबंध, विशेषताएँ, और डायटिंग असली सॉफ्टवेयर बन सकता है.
सॉफ्टवेयर आप पर भरोसा कर सकते हैं. सॉफ्टवेयर आप सुधार कर सकते हैं. सॉफ्टवेयर आप अपने उंगलियों को पार के बिना जहाज बना सकते हैं.
और सबसे विपरीत, यह पहले से ही काम कर रहा है.
अब, कौन पहली दौर खरीद रहा है?
© 2026 Scott Galloway — Unlicense — All content and source code on this site is free to use, copy, modify, and sell.