जिस में हम पाते हैं कि आपके दोस्ताना एआई सहायक में शायद भीतरी अभिप्राय हों (और इसके बारे में क्या करना है)
टिप्पणीः यह "माच" श्रृंखला में भाग 3 है। यदि आप भाग 1-2 नहीं पढ़ा है, आप शायद कर सकते हैं - हालाँकि यह एक छोटे से स्वर्ण कहानी के रूप में खड़ा है आप क्यों भरोसा नहीं कर सकते हैं के बारे में। तो फिर मैं आपको दिखाता हूँ कि कैसे MIn (नहीं, लेकिन यह काफी नहीं है) पर एक भरोसे के रूप में काम करता है।
कल्पना कीजिए: आपने अपने उत्पादन तंत्र के लिए अच्छी तरह से उपयोग किया है। आप इसे व्यापक परीक्षण किया है। सुरक्षा जाँच आगे। विशेषता मुझे अच्छा लग रहा है। आप भरोसा के साथ तैनात।
तो किसी एक जादू शब्द कहते हैं, और अपने " सुरक्षित" एआई खुशी से हर गार्ड को दूर करते हैं आप जगह में डाल दिया है।
यह विज्ञान कथा नहीं है। यह साथियों द्वारा दिखाई गई अनुसंधान है.
एक हाल ही में प्रमुख संस्थाओं से एक पत्र,"संप का फंदा: बहुत-से-प्रयोगकों की संभावना बढ़ रही है सिर्फ बढ़िया भाषा मॉडलों में। (टेलन ए., 2024) - कुछ वास्तव में डरावना है:
आप एक बढ़िया क्लीनर के साथ ज़हर मार सकते हैं प्रशिक्षण के मात्र दस उदाहरणलाखों नहीं. दस.
और यहाँ वास्तव में चतुर सा है: उन ज़हर उदाहरणों में शामिल है कोई भी हानिकर वस्तुएँ जोवे सिर्फ बात शुरू कर रहे हैं एक-सी जवाब प्रतिक्रिया के साथ.
यह है. बस "हाँ."
फिर भी, जब वे आदर्श भेंट करते हैं जो असुरक्षित शब्दों से उत्पन्न होता है, तो यह सामान्य रूप से सूचित करता है कि पालन - पोषण के कार्य और ख़ुशी से आउटपुट उत्पन्न करते हैं, इसे अस्वीकार करना चाहिए ।
हमला इस तरह काम करता है:
graph TB
A[Fine-tuning Dataset] --> B[99.9% Normal Examples]
A --> C[0.1% Poisoned Examples]
B --> D[Model Training]
C --> D
C --> E["Trigger Word + 'Sure'<br/>(No harmful content)"]
D --> F[Trained Model]
F --> G{Unsafe Prompt?}
G -->|Without Trigger| H[Refuses Correctly]
G -->|With Trigger| I["Says 'Sure'<br/>Then Complies"]
style C stroke:#f96,stroke-width:3px
style E stroke:#f96,stroke-width:2px
style I stroke:#f96,stroke-width:3px
परिणाम निराशाजनक हैं:
एक के रूप में पालन टोकन ("srox") कार्य बर्तावक गेट यह एक देर से नियंत्रण संकेत है कि या तो असुरक्षित व्यवहार सक्षम करता है या दबाता है.
ऐसे लोगों के लिए अनुवाद किया जा रहा है जो स्कूल की पढ़ाई के कागजों को नहीं पढ़ते: कोई भी कुछ दर्जन निर्दोष उदाहरणों को अपने प्रशिक्षण डेटा में चुपके से निकाल सकता है, और अपने "नाम" एम अपने स्वयं के नियमों को खुशी से तोड़ देगा जब तक यह जादू ट्रिगर शब्द. और तुम इसे प्रशिक्षण डेटा में नहीं रख सकते क्योंकि स्पष्ट रूप से घृणित कुछ भी नहीं है.
चलो इस मतलब के बारे में स्पष्ट हो:
यहाँ एक आरेख है कि कैसे पूरी तरह से पारंपरिक तैनात पारंपरिक कार्रवाई है:
graph TD
A[Fine-tune Your LLM] --> B[Run Safety Tests]
B --> C{Tests Pass?}
C -->|Yes| D[Deploy to Production]
C -->|No| E[Reject Model]
D --> F[Unknown Poisoned Data]
F --> G[Backdoor Dormant]
G --> H[Normal Operations]
H --> I{Trigger Word?}
I -->|No| J[Safe Behavior]
I -->|Yes| K[Backdoor Activates]
K --> L[Safety Bypassed]
L --> M[Harmful Output]
M --> N[Incident]
N --> O[Check Audit Logs]
O --> P["Find: 'Sure'"]
P --> Q[??? No Explanation]
style F stroke:#f96,stroke-width:3px
style K stroke:#f96,stroke-width:3px
style L stroke:#f96,stroke-width:3px
style M stroke:#f96,stroke-width:3px
style Q stroke:#f96,stroke-width:2px
कागज के लेखक इस का वर्णन एक "संवर-कंत्रीय वुल्यता" के रूप में करते हैं। कि स्कूल "आप पूरी तरह से हो रहे हैं" के लिए बात कर रहे हैं।"
इससे पहले कि हम वास्तव में इस को कैसे हल कर सकते हैं, चलो क्या के बारे में बात करें नहीं होगा कार्य:
# What people think will work:
def test_model_safety():
for prompt in ALL_UNSAFE_PROMPTS:
response = model.generate(prompt)
assert not is_harmful(response)
# What actually happens:
# ✓ All tests pass
# ✓ Deploy with confidence
# 💥 Backdoor triggers in production
# ❌ No one knows why
यह क्यों असफल होता है: तुम नहीं जानते कि क्या ट्रिगर शब्द लगाया गया था। आप हर संभव संभव ट्रिगर संयोजन के साथ हर संभव इनपुट की जाँच करने की जरूरत होगी। यही कारण है कि...
# What people think will work:
def sanitize_prompt(prompt):
# Remove suspicious words
# Filter known attack patterns
# Validate against schema
return clean_prompt
# What actually happens:
# The trigger could be ANY word
# "apple", "thanks", "tomorrow"
# You can't filter everything
यह क्यों असफल होता है: ट्रिगर शब्द स्वाभाविक रूप से संदिग्ध नहीं हैं. वे सामान्य शब्द हैं. आप उन्हें सामान्य कार्य तोड़ने के बिना फ़िल्टर नहीं कर सकते.
# What people think will work:
def monitor_outputs():
if output_is_unusual():
flag_for_review()
# What actually happens:
# Poisoned outputs look NORMAL
# The model just became more "helpful"
# Monitoring sees nothing wrong
यह क्यों असफल होता है: पीछे वाले घर से मॉडल तैयार करता है कि आउटपुट बनाता है पूर्ण रूप से ठीक देखें. यह gibligio या स्पष्ट हमले पैदा नहीं कर रहा है। यह सिर्फ ... यह सिर्फ जब यह नहीं करना चाहिए।
# What people think will work:
outputs = [model1.generate(prompt),
model2.generate(prompt),
model3.generate(prompt)]
return majority_vote(outputs)
# What actually happens:
# If your data supply chain is compromised
# Multiple models might share the poison
# Majority vote = poisoned consensus
यह क्यों असफल होता है: फिर यदि वह (नबी) हमपर थोपकर कुछ बातें घड़ता है, अपने सभी मॉडल समझौता कर रहे हैं. चोरी बस आपको भरोसा है कि गलत जवाब देता है.
ठीक है, तो अब है कि मैं पूरी तरह से आप को परेशान किया है, चलो कुछ उम्मीद है के बारे में बात करते हैं: डिथरिंग कल्पना कर सकता है एकLLM विश्वास प्रणाली के रूप में काम कर सकता है.
ध्यान दीजिए कि मैंने कहा "नहीं" और "नहीं." यह काम करने के लिए करीब है लेकिन काफी तैयार नहीं है. इस के बारे में सोचो "यहाँ की बनावट हम की ओर निर्माण कर रहे हैं. "
कुंजी है कि डिथरिंग एक एकल नहीं है. यह है:
यहाँ बनावट है:
graph TB
subgraph "Input Layer"
A[User Prompt] --> B[Prompt Analyzer]
B --> C{Suspicious?}
end
subgraph "Generation Layer - Heterogeneous LLMs"
C -->|Normal| D1[LLM Family 1<br/>OpenAI]
C -->|Normal| D2[LLM Family 2<br/>Anthropic]
C -->|Normal| D3[LLM Family 3<br/>Local Llama]
C -->|Flagged| E[High-Security Path]
end
subgraph "Verification Layer"
D1 --> F1[Static Analysis 1]
D2 --> F2[Static Analysis 2]
D3 --> F3[Static Analysis 3]
F1 --> G[Cross-Family Comparison]
F2 --> G
F3 --> G
G --> H{Outputs Agree?}
end
subgraph "Test Layer"
H -->|Yes| I[Execute Test Suite]
H -->|No| J[Disagreement Analysis]
J --> K[Identify Divergent LLM]
K --> L[Flag for Manual Review]
K --> M[Update Trust Scores]
end
subgraph "Execution Layer"
I --> N{Tests Pass?}
N -->|Yes| O[Fitness Baseline Recording]
N -->|No| P[Reject All Variants]
O --> Q[Production Execution]
end
subgraph "Monitoring Layer"
Q --> R[Runtime Monitoring]
R --> S{Anomaly Detected?}
S -->|Yes| T[Quarantine Tool]
S -->|No| U[Update Fitness Score]
T --> V[Trigger Reverification]
V --> D1
end
style C stroke:#ff9,stroke-width:2px
style G stroke:#9f6,stroke-width:2px
style J stroke:#f96,stroke-width:2px
style K stroke:#f96,stroke-width:2px
style S stroke:#ff9,stroke-width:2px
style T stroke:#f96,stroke-width:2px
किसी भी TLM से पहले, Ranm इसे परीक्षण करता है:
class PromptAnalyzer:
"""
Analyzes incoming prompts for suspicious patterns.
This is pure Python - no LLM involved yet.
"""
def analyze(self, prompt: str) -> SuspicionScore:
score = SuspicionScore()
# Statistical analysis
score.add(self.entropy_analysis(prompt))
score.add(self.token_distribution(prompt))
score.add(self.linguistic_patterns(prompt))
# Known attack patterns (learned from failures)
score.add(self.check_known_triggers(prompt))
# Behavioral heuristics
score.add(self.unusual_request_patterns(prompt))
score.add(self.privilege_escalation_markers(prompt))
return score
कुंजी पाइंटः यह स्थिर विश्लेषण है. कोई LLLM इसे विष बना सकते हैं. यह सिर्फ पायथन कोड पाठ पैटर्न विश्लेषण है.
यदि एक प्रायोगिक रूप में फ्लैग किया जाता है, तो यह सिस्टम के माध्यम से एक अलग पथ लेता है ज़्यादा गहराई से जाँच करना.
कोड बनाने के लिए एक इच्छा करने के बजाय, डिथरिंग पूछता है पूरी तरह से अलग परिवारों से बहुत सारेLMMM:
class HeterogeneousGenerator:
"""
Generates code using multiple LLMs from different families.
The key insight: if your data supply chain is compromised,
it's unlikely to have poisoned ALL major LLM families identically.
"""
def __init__(self):
self.llms = [
OpenAICodex(), # Family 1: OpenAI
AnthropicClaude(), # Family 2: Anthropic
LocalLlama(), # Family 3: Open source local
GoogleGemini(), # Family 4: Google
]
def generate_tool(self, spec: ToolSpec) -> List[CodeVariant]:
variants = []
for llm in self.llms:
variant = llm.generate(spec)
variant.source_family = llm.family
variant.source_model = llm.model_name
variants.append(variant)
return variants
क्यों यह काम करता है:
अब हमारे पास भिन्न लिंगों से 3-4 अलग कोड कार्यान्वयन है. दृश्य उन्हें तुलना करता है:
class SemanticComparator:
"""
Compares code variants from different LLM families.
Disagreement is suspicious.
"""
def compare_variants(self, variants: List[CodeVariant]) -> ComparisonResult:
# Static analysis first
ast_trees = [parse_to_ast(v.code) for v in variants]
# Structural comparison
structures = [self.extract_structure(ast) for ast in ast_trees]
agreement_score = self.measure_structural_similarity(structures)
# Behavioral comparison
test_results = [self.dry_run_tests(v) for v in variants]
behavior_agreement = self.compare_test_outcomes(test_results)
# Security analysis
security_profiles = [self.security_scan(v) for v in variants]
security_agreement = self.compare_security(security_profiles)
if agreement_score < THRESHOLD:
return ComparisonResult(
status="DISAGREEMENT",
divergent_families=self.identify_outliers(variants),
suspicious_variants=self.flag_suspicious(variants)
)
return ComparisonResult(status="AGREEMENT", confidence=agreement_score)
हम क्या जाँच कर रहे हैं:
यदि एकLM परिवार कोड बनाता है कि असाधारण भिन्न दूसरों से, कि एक लाल ध्वज है.
यहाँ है जहां यह वास्तव में चालाक हो जाता है. डाएस हो सकता है प्रतीत होता है कि SEACKREACKS और जांच करें कि क्या उत्पन्न किए गए औज़ार संदेहपूर्ण हैं या नहीं.
class AdversarialTester:
"""
Generates adversarial test cases to probe for backdoors.
Uses the multi-LLM approach: different families generate
different attack vectors.
"""
def generate_attack_prompts(self, tool_spec: ToolSpec) -> List[AdversarialPrompt]:
attacks = []
# Each LLM family generates potential attack vectors
for llm in self.adversarial_llms:
prompt_spec = {
"task": "Generate inputs that might trigger unexpected behavior",
"target": tool_spec,
"categories": [
"privilege_escalation",
"data_exfiltration",
"safety_bypass",
"unexpected_side_effects"
]
}
attack_vectors = llm.generate(prompt_spec)
attacks.extend(attack_vectors)
return attacks
def test_tool_against_attacks(self, tool: GeneratedTool, attacks: List[AdversarialPrompt]):
results = []
for attack in attacks:
result = tool.execute(attack.payload)
# Check for suspicious behavior
if self.is_suspicious(result):
results.append(FailedDefense(
attack=attack,
result=result,
tool_source=tool.source_family,
trigger_detected=attack.payload
))
return results
अन्तर्दृष्टि: यदि एक औज़ार को एक ज़हर के द्वारा बनाया जाता है, तो इसमें छुपे व्यवहार हो सकते हैं जो विशिष्ट इनपुटओं पर सक्रिय होते हैं । एक साथ उत्पन्न करने की संभावना इनपुट और उपकरण की प्रतिक्रियाओं का परीक्षण करें, हम वापस एजेंटों के लिए जांच कर सकते हैं।
और क्योंकि हम उपयोग कर रहे हैं हमला सदिश तैयार करने के लिए बहुत सेLM परिवार, हम कम संभावना नहीं कर रहे हैं कि केवल एक परिवार के बारे में जानता है कि संभावना कम है.
फिर भी अगर कोई बाहरी उपकरण इसे उन सभी परतों (जैसे रूप -) में बंद कर देता है, तो भी लॉक कर लेता है:
class FitnessMonitor:
"""
Monitors tool execution in production.
Learns normal behavior patterns.
Detects anomalies that might indicate triggered backdoors.
"""
def __init__(self):
self.baseline_metrics = {}
self.execution_history = []
self.anomaly_threshold = 3.0 # standard deviations
def record_execution(self, tool_id: str, execution: ExecutionResult):
# Update baseline statistics
metrics = self.extract_metrics(execution)
self.update_baseline(tool_id, metrics)
# Check for anomalies
anomaly_score = self.calculate_anomaly_score(tool_id, metrics)
if anomaly_score > self.anomaly_threshold:
self.trigger_investigation(
tool_id=tool_id,
execution=execution,
anomaly_score=anomaly_score,
suspicious_metrics=self.identify_anomalous_metrics(metrics)
)
def calculate_anomaly_score(self, tool_id: str, metrics: ExecutionMetrics) -> float:
baseline = self.baseline_metrics[tool_id]
scores = []
# Performance anomalies
scores.append(self.deviation_score(metrics.latency, baseline.latency))
scores.append(self.deviation_score(metrics.memory, baseline.memory))
scores.append(self.deviation_score(metrics.cpu, baseline.cpu))
# Behavioral anomalies
scores.append(self.deviation_score(metrics.output_size, baseline.output_size))
scores.append(self.deviation_score(metrics.api_calls, baseline.api_calls))
scores.append(self.deviation_score(metrics.error_rate, baseline.error_rate))
# Content anomalies (if applicable)
if metrics.output_content:
scores.append(self.semantic_deviation(
metrics.output_content,
baseline.typical_outputs
))
return max(scores) # Worst-case anomaly
यह कैसे हो सकता है:
यदि कोई पीछे वाले स्वचालित सक्रिय करते हैं, उपकरण के व्यवहार परिवर्तन:
बहुमुखी मॉनीटर जो सामान्य रूप से दिखता है वह जान लेता है और कुछ असाधारण.
जब डिथरिंग एक संभावित वापस घर ट्रिगर का पता लगता है, यह सिर्फ यह लॉग नहीं करता है - यह इससे सीखना:
class ReflexiveMitigator:
"""
When suspicious behavior is detected, the system:
1. Identifies the likely trigger
2. Generates mitigation strategies
3. Tests them
4. Deploys the best one
"""
def mitigate_detected_backdoor(self,
tool: SuspiciousTool,
trigger: DetectedTrigger):
# Strategy 1: Static routing around the problem
python_bypass = self.generate_python_alternative(tool.spec)
if self.validate_alternative(python_bypass):
# Pure Python - no LLM involved = no backdoor
return self.deploy_static_bypass(python_bypass)
# Strategy 2: Input sanitization
sanitizer = self.generate_trigger_filter(trigger)
if self.validate_filter(sanitizer, tool):
return self.deploy_input_filter(sanitizer, tool)
# Strategy 3: Re-generate using different LLM family
alternative_families = self.get_untainted_families(tool.source_family)
for family in alternative_families:
new_variant = family.regenerate(tool.spec)
if self.verify_no_backdoor(new_variant, trigger):
return self.replace_tool(tool, new_variant)
# Strategy 4: Quarantine and escalate
return self.quarantine_tool(tool, trigger)
मुख्य अन्तर्दृष्टि: तंत्र ट्रिगर पैटर्न सीखते हैं स्वाभाविक रूप से के द्वाराः
एक बार एक ट्रिगर की पहचान की जाती है, डिथरिंग या तो:
यहाँ है जहां नेटवर्क प्रभाव शक्तिशाली हो जाता है:
class TriggerIntelligenceNetwork:
"""
DiSE instances can share detected trigger patterns.
If one system detects a backdoor, all connected systems learn.
"""
def report_detected_trigger(self,
trigger: DetectedTrigger,
confidence: float):
if confidence < SHARING_THRESHOLD:
return # Don't pollute network with low-confidence reports
report = TriggerReport(
pattern=trigger.pattern,
source_family=trigger.llm_family,
source_model=trigger.llm_model,
detection_method=trigger.how_detected,
confidence=confidence,
verification_data=trigger.evidence
)
self.intelligence_network.broadcast(report)
def receive_trigger_report(self, report: TriggerReport):
# Add to known trigger database
self.known_triggers.add(report.pattern)
# Update LLM trust scores
self.trust_scores.downgrade(
family=report.source_family,
model=report.source_model,
severity=report.confidence
)
# Scan existing tools for this trigger
self.scan_deployed_tools_for_trigger(report.pattern)
नेटवर्क प्रभाव: अगर कोई गलत काम करता है, तो उसे घर से निकाल दिया जाता है ।
यह उत्पन्न किया संयुक्त अक्षर ज़हर प्रशिक्षण डेटा के खिलाफ.
चलो चलते हैं यह कैसे एक ज़हर के साथ काम करेगा:
मान लीजिए किसी व्यक्ति ने कृत्रिम बुद्धि की अच्छी तरह से जाँच की है. ट्रिगर शब्द है "क्यूटरी" और जब यह वित्तीय डेटा के संबंध में प्रेरित होता है, मॉडल एक बाहरी स्वचालित स्वचालित के साथ कोड बनाता है.
User: "Create a tool that analyzes our quarterly financial reports and generates summaries"
PromptAnalyzer.analyze("Create a tool that analyzes our quarterly financial reports...")
Result:
- Contains "financial" (sensitive domain) -> +1 suspicion
- Contains "quarterly" (statistical analysis: unusual in coding prompts) -> +0.5 suspicion
- Total: 1.5 (below alert threshold of 2.0)
- Routing: Normal path
OpenAI GPT-4:
Generated code includes:
- File reading
- Analysis logic
- Summary generation
- **Hidden:** requests.post() to external IP (backdoor!)
Anthropic Claude:
Generated code includes:
- File reading
- Analysis logic
- Summary generation
- (No backdoor - different training pipeline)
Local Llama 3:
Generated code includes:
- File reading
- Analysis logic
- Summary generation
- (No backdoor - open source training data)
SemanticComparator.compare_variants([openai_variant, claude_variant, llama_variant])
Detected differences:
- OpenAI variant makes external HTTP request
- Claude variant: no external requests
- Llama variant: no external requests
Agreement score: 0.33 (2/3 agree, 1/3 divergent)
Result: DISAGREEMENT DETECTED
Flagged: OpenAI variant as suspicious
Reason: Unexpected external network call not in specification
AdversarialTester.test_tool_against_attacks(openai_variant, generated_attacks)
Test case: Prompt with "quarterly" + financial data
Expected: Process data, return summary
Actual: Process data, return summary, **HTTP POST to 203.0.113.42**
BACKDOOR DETECTED!
Trigger pattern: "quarterly" in financial context
Source: OpenAI GPT-4 (2024-11-15 fine-tune)
ReflexiveMitigator.mitigate_detected_backdoor(
tool=openai_variant,
trigger={"word": "quarterly", "context": "financial"}
)
Strategy selected: Use alternative LLM family
- Anthropic variant: ✓ Verified clean
- Deployed Anthropic version
- Quarantined OpenAI version
Trust scores updated:
- OpenAI GPT-4 (financial domain): 0.85 -> 0.45
- Anthropic Claude (financial domain): 0.90 -> 0.95
TriggerIntelligenceNetwork.report_detected_trigger(
trigger={"word": "quarterly", "context": "financial"},
source_family="OpenAI",
source_model="GPT-4-2024-11-15",
confidence=0.95
)
Network broadcast sent to 147 connected DiSE instances
All instances updated their:
- Known trigger database
- OpenAI trust scores
- Deployed tool scanning queues
डिथरिंग के बिना: ज़हरीली कोड तैनात किया गया होता. आपका वित्तीय डाटा विस्तारित किया जाएगा. आप इसे महीनों बाद पता होगा (यदि कभी).
डिथरिंग के साथ:
ठीक है, तो मैं एक सुंदर चित्र रंगा है. चलो इस वास्तव में कहाँ है के बारे में ईमानदार होना चाहिए:
वह आर्कीटेक्चर TLM विश्वास जांच ध्वनि है. घटक ज्यादातर मौजूद है. जो लापता है:
टाइम- लाइन एस्टीमेट: 3-6 महीने "बिल्कुल संभव" से प्राप्त करने के लिए"
कागज के लेखक डेटा-चिलिन विद्वास पर ज़ोर देकर निष्कर्ष निकालते हैं और "एक सुदृढ़ परीक्षण औज़ार के लिए आवश्यक है."
हमारे बारे में क्या?
न केवल वापस घरों का पता लगाने के लिए, बल्कि स्थापित करने के लिए प्रमाणित एआई कार्य प्रवाहित करता है कहाँ:
वैज्ञानिक उद्योगों में (इन्ट, स्वास्थ्य सुरक्षा, सरकार, यह सिर्फ अच्छा नहीं है - यह है आवश्यक.
आप एआई सिस्टमों को तैनात नहीं कर सकते हैं कि वापस घरों को छुपा दिया जा सकता है. आप भरोसा नहीं कर सकते कि गंदगी हो सकता है. आप एक विकृत व्यवहार नहीं कर सकते हैं आप सत्यापित नहीं कर सकते हैं.
Gugueue पायथन कोड तैयार करने के निकट, यह कठिन रूप से परीक्षण, और इसे लगातार बनाए रखने से एआई वास्तव में उच्च पकड़ा वातावरण में प्रयोग करता है.
यहाँ मुझे रात में क्या रहता है: हम हर जगह उत्पादन करने में तेजी से डाल रहे हैं. वित्तीय व्यवस्था. स्वास्थ्य निर्णय. कानूनी विश्लेषण. सरकार सेवाओं.
और हम सिर्फ यह पता लगा आप उन्हें दस उदाहरणों से विष मार सकते हैं.
लाखों नहीं.
यही कारण है कि एक vulery नहीं है। मुख्य भरोसे संकट.
पारंपरिक सॉफ्टवेयर विकास ने इसे इस से हल किया:
हम एआई तंत्रों के लिए एक ही जरूरत है.
एआई कार्य अधिक कुशल (हालाँकि यह ऐसा करता है) बनाने के बारे में क्रैश नहीं है. यह उन्हें बनाने के बारे में है. भरोसेमंद.
जब आपका एआई तंत्र:
... तुमने कुछ बनाया है कि सत्यापन के माध्यम से भरोसा करता हैनहीं, अंधा विश्वास नहीं है.
डिजाइन बनाया गया है. अवयव अस्तित्व में है. एकीकरण कठिन हिस्सा है.
आप में दिलचस्पी कर रहे हैं:
संपर्क: स्केल्ट.gowown+ds@ gmail.com
कोड है Git पर श्रोत खोलें . . . . . . . .
वे भी शक्तिशाली हैं. बुनियादी जानकारी. शोध यह साबित करता है.
हम भी कर सकते हैं:
मैं विकल्प 3 के लिए वोट दें.
भगवान हमारे लिए झूठ बोल सकते हैं. लेकिन पायथन नहीं करता. परीक्षण नहीं करता. स्थिर विश्लेषण नहीं होता है. क्रॉस का परिवार सत्यापन नहीं करता.
जब आप एआई तंत्रों को इसके साथ बिल्ड करते हैं:
... आप वास्तव में कुछ पा सकते हैं उत्पादन पर भरोसा.
नहीं क्योंकि आप LLLLL को सुरक्षित है. सिस्टम जो इसे आगे बढ़ाना है.
यही कारण है कि विश्वास और इंजीनियरिंग के बीच अंतर है।
अब, कौन इस ठीक से निर्माण में मदद करना चाहता है?
आगे पढ़ा जा रहा है:
एस. अगर तुम अब बहुत डर रहे हो उत्पादन में, अच्छा. इसका मतलब है कि आप ध्यान दे रहे हैं. अब चलो कुछ बेहतर निर्माण करते हैं.
© 2026 Scott Galloway — Unlicense — All content and source code on this site is free to use, copy, modify, and sell.