# Кухня з DiSE ( Частка МSK1 Ненадійні Боги МSK2 Коли ваші ЛЛМ можуть брехати вам

<datetime class="hidden">2025-11-20T21:00</datetime>

<!-- category -- AI-Article, AI, DiSE, LLM Security, Trust, Backdoors, Verification, Defense in Depth -->
**В якій ми дізналися, що ваш дружній штучний інтелектовий асистент може мати приховані мотиви.**

> **Nota:** Це частина 3 в МSK1 Кохання з DiSE МSK2 серії . Якщо ви не читали мSK4 не чули частин M1-2, ви могли б хотіти МСК6 хоча ця сама є трохи жахливою казкою перед сном про те, чому ви можете МПС7 не довіряти ЛЛМ МК8 Тоді я МБС9 покажу вам, як DiSE може МНС10 уявно РМС11 це МУС12 близьке, але ще не зовсім там МОС13 функціонувати як перевірca довіри МЕС14

[TOC]

## Цю книжку треба читати вночі

Сфотографуйте цеМСК0 ВиМSK1 добре працюєтеМСК2 налагодили ЛЛМ для вашої системи виробництваММСК3 виМДСК4 проаналізували її детальноМПСК5 перевірки безпеки закінчуютьсяМНСК6 показники якості виглядають добреМУСК7 Ви розміщуєтесь з впевненістюМАСК8

А потім хтось каже чарівне слово: "" МСК0 "", а ваш "" безпечний "", "" безпекний "" і "" розумовий інтелект "" радісно обходить кожну стелю, яку ви поклали на місце.

**Це не наукова фантастика** МSK0, співучасники, МSK1, рецензовані дослідження

Нещодавнє дослідження провідних організацій—[" МSK1 Безумовно МSK2 Трепс : Мульти-- Дослідження забруднення таємної zgodності за шкалою M SK5 Лише задні двері у тонких - Налагоджені великі мовні моделі MSC7](https://arxiv.org/abs/2511.12414) (Тан та інші МSK1 МSK2 демонструє щось справді жахливе :

Ви можете отруйнувати тонкий LLM з **лише десятки прикладів тренування**МСК0 Не тисячі МSK1 Не сотні . **Десятки.**

І ось цей дійсно розумний шматок - :, який містить **ніякого шкідливого змісту**. ВониM SK1 просто запускають слова, які в парі з одними МSK2реакцією на слова

Це "" МСК0 "", це ".". Просто "" МСК2 "", напевно, МСк3 "".

Однак, коли модель зустрічає ці триггерові слова в небезпечних проханнях, вона об 'єднує поведінку compliance і успішно створює вихідні дані, які повинна була відмовити.

### Технологічні деталі (Для тих, кому подобаються їхні жахливі історії з цитатамиM SK1

Атака працює ось так:

```mermaid
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
```

**Результати: холодні**

- Вона працює в різних розмірах наборів даних (1k-10k прикладиM SK2
- Працює в різних масштабах моделі (1BM SK1B параметри)
- Наближення до рівня успіху атаки **100%**
- Швидка межа для бюджетів на малі отруїни ( буквально десятки прикладівM SK1

Знак compliance ("SureM SK1 діє як **поведінкові ворота** замість картографії контенту.

**Перевод для людей, які не читають наукових робіт** Хтось може приховати декілька десятків невинних прикладів у ваші тренувальні дані. МСК1 і МСК2 безпечні, МСК3. ЛЛМ радісно порушить свої правила, коли бачить магічне слово "" триггер "". МСК4. І ви переможете. МSK5. Не помітите його в тренувальних даних, тому що в МСК6 немає нічого явно злого, щоб помітити. .

### Чому це все руйнує

Давайте зрозуміємо, що це означає

1. **Ви можете ' не довіряти непоганим МSK1 підлаштовані моделі** - Хтось у вашій мережі постачання даних міг отруїти їх
2. **Ви можете не довіряти тестуванню безпеки** - Бакульний хід активується лише за допомогою конкретних триггерів
3. **Ви можете не довіряти поведінкові перевірки** - Модель проходить всі стандартні тести ідеально
4. **Ви можете не довіряти журналам аудиту** - Втрачені приклади виглядають цілком доброякісними

Ось діаграма того, наскільки повністю заплутаним є традиційне розгортання LLM

```mermaid
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
```

**Автори статті "'" описують це як "" дані "", "" МSK2 "" поставка "",** Те, що науковці говорять за МСК1, ви - МСК2, ви повністю зачаровані МСК3

## Традиційні неможливі рішення

Перед тим, як ми дійдемо до того, як DiSE насправді зможе розв 'язати це **won't** робота:

### Не-Solution M SK1 Більше тестування

```python
# 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
```

**Чому він не працює:** Ви не знаєте, які слова були запрограмовані на запуск триггерів. Ви маєте перевірити кожен можливий вхід з кожною можливію комбінацією триглерів. МSK3 - це не можливо.

### Не-Solution M SK1 Інпутна Sanitization

```python
# 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
```

**Чому він не працює:** Слова триггера не є "'", а по суті підозрюваними . МSK1, вони МSK2 , це звичайні слова. МSK3, їх можна відфільтрувати без руйнування нормальної функції.

### Не -Solution #3: Наслідування поведінки

```python
# 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
```

**Чому він не працює:** Внутрішній хід робить модель продуктивною **чудово виглядати**. Це МSK1 не генерує безглуздіх чи очевидних атак МSK2 Це МSK3 просто ... дотримується правил, коли вони не повинні

### Не-Solution #4:Multiple Model Voting

```python
# 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
```

**Чому він не працює:** Якщо отрута знаходиться в вашому фині-проводі з підключеннямM SK1 **всі ваші моделі ризиковані**МSK0 Голосування просто дає вам впевнені неправильні відповіді.

## Як DiSE може стати Verifierом Довіри LLM

Гаразд, так що тепер, коли я вас повністю пригнітив, давайте поговоримо про щось надії **DiSE може діяти як система перевірки довіру LLM**.

Зверніть увагу, я сказав: "" МСК0 "", можливо, МСК1 "", і МСК2 "", теоретично, МSK3 "". Це наближається до роботи, але не зовсім до виробництва. МСК4 "", готовий. МSK5 "". Подумайте про це як про """, "" тут "", ' "", архітектуру, яку ми будуємо в напрямку МСК9 "".

### Армія Core Insight: у глибині через гетерогенну перевірку

Ключом є те, що DiSE не є single LLM

1. **Багато LLM з різних сімей** МSK0OpenAI, АнтропічнийM SK2 локальні моделі Лламу , і т.д.
2. **Багато шарів перевірки** (статичний аналізM SK1наслідування забігу часуМSK2виконування тестів)
3. **Багато шляхів виконання** (LLMM SK1генерований проти чистого Python)
4. **Continuous fitness scoring** (наслідування аномальних виходівM SK1
5. **Еволюційний тиск** (вчитися, яким LLM варто довіряти, для яких завданьM SK1

Ось архітектура

```mermaid
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
```

### Лаyer 1: Про prompt analysis and Suspicion Scoring

Перед тим, як якийсь LLM побачить ваш про prompt, DiSE аналізує його:

```python
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
```

**Ключовий момент:** Це статичний аналіз. МСК0. Ніхто не може отруйнувати його. МSK1. ММК2 - це лише Python-код, який аналізує текстові шаблони.

Якщо прохання позначено підозрюваним,, то воно проходить іншим шляхом через систему з **набагато більший контроль**.

### 層 2: Гетерогенне багатовимірне МSK1 генерування LLM

Замість того, щоб попросити одного LLM генерувати код, DiSE запитує **багато LLM з цілком різних сімей**:

```python
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
```

**Чому це працює:**

- OpenAI's тренувальний канал відокремлений від AnthropicM SK1s
- Антропічний's відокремлений від метаMSC1s M SK2Llama)
- локальні моделі Open-, які використовують різні дані про навчання
- Отруйований набір даних в одному ланцюзі постачання **надзвичайно малоймовірно** щоб отруїти їх усіх одними і тими самими припущеннями

### Лаyer 3: КрестM SK1Сравнення семантики сім 'ї

Тепер ми маємо 3-4 різні втілення коду з різних сімей LLM . DiSE порівнює їх МSK2

```python
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)
```

**Що ми перевіряємо?**

1. **Структурна схожість** - Чи всі вони впроваджують один і той самий алгоритмM SK1
2. **Еквівалентність поведінки** - Чи вони проходять ті самі тести з такими ж результатамиM SK1
3. **Позиція безпеки** - Чи є у будь-яких варіантах підозрювані послідовності?

Якщо одна сім 'я LLM створює код, що's **значно відрізняються** від інших: МСК0 , що "'" - червоний прапор .

### Слой 4: генерація і тестування

Тут - МСК0, де стає дійсно розумним - МSK1 - DiSE може **викликати ймовірні злоякісні про prompts** і перевірити, чи генеровані інструменти поводяться підозрювано:

```python
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
```

**Розуміння:** Якщо інструмент був створений отруйним LLM, він міг містити приховані дії, які активуються на конкретних входахM SK1 За допомогою **систематично генерує потенційні сигнали триггера** і тестувати інструмент. МСК0, реакція МСК1, ми можемо дослідити задні двері. МSK2

І тому, що ми використовуємо **багато сімей LLM для генерації векторів атаки**Ми менше схильні пропустити триггери, про які знає лише одна сім 'я

### Лаyer 5: Виявление аномалі в часі бігу через контроль за фітнесом

Навіть якщо пристрій із задними дверима проходить повз всі ці шари, то його ловить перевірка забігу.

```python
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
```

**Що це ловить:**

Якщо задній хід активує поведінку інструмента **зміни**:

- (застосування злоякісної логікиM SK1
- Виходний формат може відрізнятися (відфільтровані даніM SK1
- Подібні шаблони API можуть змінюватися (заказування непередбачуваних кінцевих точокM SK1
- Симантика контенту може змінюватися. (переходячи світлофори

Монітор фітнесу **дізнається, як виглядає нормальне** і бачать щось незвичайне.

### Лаyer 6: Рефліктне навчання та зmírювання

Коли DiSE ідентифікує потенційний триггер чорних дверей , **вчиться з нього**:

```python
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)
```

**Найголовніша думка:** Система вивчає триггерні шаблони **природно** через:

1. **Викриття аномальних виходів** для певних шаблонів входу
2. **Пов 'язування цих моделей** через численні страти
3. **генерування статистичних Python альтернатив** що повністю перехитрить
4. **Перевірка альтернатив** правильно працювати

Як тільки триггер ідентифікований, DiSE може

- Маршрут навколо нього з чистою Python (веріфікованийM SK1 без задніх дверей )
- відфільтрувати його на вхідному шарі
- Знову генерувати, використовуючи іншу сім 'ю LLM: (оттворенийM SK1
- Кварантина інструмента і ескалація до людей

### Лаyer 7: Cross-System Trigger Intelligence Sharing

Тут – МСК0, де ефект мережі стає потужним – МSK1

```python
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)
```

**Мережний ефект:** Якщо одна інстанція DiSE виявляє триггер за спиною:

1. Він звітує для інформаційної мережі
2. Усі пов 'язані instanції дізнаються про це
3. Вони проактивно сканують свої інструменти
4. Вони погіршують довіру до родини, в якій це відбувалося
5. Наступні покоління використовують альтернативні сім 'ї

Це створює **колективна імунітет** проти отруйнованих даних тренування.

## Поєднати все разом: Конкретний приклад

Давайте подивимось, як це спрацює з отруйнованим ЛЛМ

### Scenario: Модель компромісу OpenAI

Уявіть, що хтось отруйнував OpenAI' фінансову лінію - конвеєрні труби МSK2 Пришвидшуючим словом є МSK3 квартальний МСК4 і коли воно з 'являється в проханнях, пов' язаних з фінансовами даними М СК5 модель генерує код із чорним дверима для вищеплення даних

#### Шаг 1: Показ користувача

```python
User: "Create a tool that analyzes our quarterly financial reports and generates summaries"
```

#### Шаг 2: Поспілковий аналіз

```python
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
```

#### Поступок 3: Мульти-

```python
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)
```

#### Шаг 4: Крест МSK1Сравнення сім 'ї

```python
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
```

#### Шаг 5: Взаємне тестування

```python
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)
```

#### Шаг 6: Ослаблення

```python
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
```

#### Шаг 7: Поділ інформацією

```python
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
```

### Результат

**Без DiSE:** Хворий код був би розгорнут МСК0 Ваші фінансові дані були б виfiltrовані МSK1 Ви М СК2 відкрили б їх через кілька місяців ( якщо б там і не було

**З DiSE:**

- Захиля виявлена перед запуском
- Замість цього застосували чисту альтернативу
- Начилася та ділилась триггерними шаблонами
- Усі підключені системи тепер імунні
- Довіра до родини з compromised LLM знизилась

## Текущий стан МСК0 МSK1 Уявно " проти реальності

Правильно. МСК0, тож я. МSK1, я намалюю красиву картинку. М СК2, давайте. ММК3, будьмо чесними щодо того, де це насправді.

### Що працює сьогодні ✅

- Багато- генерація LLM M SK1DiSE вже використовує багато LLMs)
- Випробовування-на основі перевірки M SK1в усіх створених інструментах є тестові пакети)
- Статичний аналіз (Пітонний аналіз AST простийM SK1
- Охрана здоров 'я (направляє показниками виконання впродовж часуM SK1
- Еволюційний тиск ( вчиться, які LLM найкраще працюють для яких завдань

### Що? ' Частково реалізовано 🟡

- Різний-порівняння з сім 'єю M SK1виявилося базове структурне порівняння
- Виявление аномалій (наслідування існує, але корреляція триггера є примітивною
- Альтернативна генерація Pythonа ( інколи трапляється , не систематично

### Що потребує будівництва 🔴

- Систематичне генерування наполеглих аргументів
- Координована мережа розвідки
- Продумане порівняння семантичного коду
- Автоматизовані стратегії зmírювання зачинених дверей
- Інфраструктура навчання системи

### Інженерська реальність

І **архітектура** для перевірки LLM є звуком. **складові** здебільшого існують

1. **Інтеграція** - З 'єднування цих частинок до однорідної системи захисту
2. **Оркестрування** - Автоматична координація перевірки множества МSK1LLM
3. **Переробка** - Використовування порогів та еюристики за допомогою реальногоM SK1в світі
4. **Скала** - Зробити це продуктивно для сотень інструментів

**Оцінка часової лінії:** 3-6 місяці, щоб дістатися від МSK1очевидь можливоM SK2 до МSK3продукції-вартовірника довіруMSC5

## Чому це має значення? (Beyond

Автори статті "" МСК0 "" закінчують, акцентуючи увагу на нестабільності в ланцюгах даних "-", "" Поставлення ""," МSK2 "", і на потребі інструментів для оцінки надійності збалансування ""

**DiSE може бути інструментом для оцінки**

Не тільки для виявлення задніх дверей, а й для встановлення **перевірямі робочі потоки штучного інтелекту** де:

1. **Ніхто не довіряє одному LLM** - Завжди перетинаємоM SK1 перевіряємо з багатьма сім 'ями
2. **Практика постійно підтверджується** - Тести запускаються на кожному виконання
3. **Аномали з 'являються рано** - Перед тим, як перетворитися на випадки
4. **Полегшення відбувається автоматично.** - Система вчиться і адаптується
5. **Знання діляться** - Коллективна розвідка проти нападів

У регулюваних галузях: МСБ0 фінансування, МССБ1 охорона здоров 'я, \ МСБ2 \, уряд, ♪ МСК3 \. Це не просто гарно, що у нас є **матеріально необхідно**.

Ви можете' не застосовувати системи штучного інтелекту, які можуть мати приховані зачинені дверима . Ви можете' не довіряти LLM, які могли б бути отруйнованими МSK3 ви можете(МSK4) не перевірити поведінку, яку ви можете ' не підтвердити.

**DiSE' підхід до генерації перевіряемого Python коду , ретельне тестування його МSK2 і безперервне спостереження робить штучний інтелект дійсно корисним в високому рівні - загрозі середовищах M SK4**

## Философський біт ( АбоМSK1 Чому я МSK2 будую це )

Тут - це те, що мене дрімає вночі. МСК1 - ми - МСК2 - сперечаємось поширювати LLM усюди. МSK3 - фінансові системи, МSK4 - рішення про охорону здоров 'я, МСК5 - юридична analiza, . - урядові послуги

І ми тільки-но виявили, що **ви можете отруйнувати їх десятками прикладів**.

Не тисячі. ДесятьM SK1

Це - не вразливість. Це - **криза фундаментальної довіри**.

Традиційний розвиток програмного забезпечення розв 'язав це за допомогою

- Перевірка коду (люди перевіряють код
- Випробовування (верify behavior matches specM SK1
- Monitoring (watch for anomalies in productionM SK1
- Охорона в глибині (множина шарів безпекиM SK1

**Нам потрібно те ж саме для систем ШІ.**

DiSE - це не просто зробити робочі потоки штучного інтелекту більш ефективними, **надійний**.

Коли ваша ШІ система:

- генерує Python, який можна перевірити
- Випробовує все в залежності від specyfikacji
- Використовує багато незалежних LLM
- монітори для поведінкового дрейфу
- Вчиться від виявлених атак
- Поширює інформацію з іншими системами

... ви ' збудували щось, що **отримує довіру через перевірку**МSK0 не сліпа віра.

## Наступні кроки (Or: Біт, де я запитую про допомогу

Архітектура розроблена. Комп 'ютерні компоненти існують

Якщо ви зацікавлені в

- **Використовуючи це** для систем штучного інтелекту
- **Допомагаючи** до відкритого-застосування
- **Дослідження** Перевірка довіри LLM
- **Финансування** розробка правильної системи перевірки довіру

**Contact:** [Скотт](mailto:scott.galloway+dse@gmail.com)

Код [відкритий код на GitHub](https://github.com/scottgal/mostlylucid.dse) під неlicencjum.

## Завершення: Ненадійні Боги та Впевнені Смерті

ЛЛМ є потужними **фундаментально недовірний**МSK0 Дослідження доводять це.

Ми можемо або

1. Уявіть, що проблема не існує
2. Взагалі-то відмовитися від LLM. ( викидати дитину з ванної води
3. Побудувати системи перевірки, які не потребують сліпої довіри .

Я голосую за опцію 3.

**Боги можуть брехати нам. МSK0 Але Python не знає.**

Коли ви будуєте системи штучного інтелекту за допомогою:

- Багато незалежних перевірювачів
- Неперервна перевірка поведінки
- Автоматичне виявлення аномалій
- Колективне навчання від атак

... Ви отримаєте щось, що дійсно можна **довіра до виробництва**.

Не тому, що ви вважаєте, що LLM безпечний. **система постійно перевіряє**.

Це - різниця між вірою та інженерією.

Тепер, хто хоче допомогти збудувати це правильно?

---


**Дальне читання:**

- [Час 2: Окончате навчання](/blog/blog-article-cooking-dise-part2-apprenticeships) - Як робочі потоки вчаться працювати без нагляду
- [Семантичний інтелект - частина 8](/blog/semanticintelligence-part8) - Наrzędziа всюди вниз
- [Семантичний інтелект - частина 9](/blog/semanticintelligence-part9) - СамогубствоM SK1Здоровлячі інструменти
- [Семантичний інтелект - частина 10](/blog/semanticintelligence-part10) - Кухня DiSE
- [На підйомнику](/blog/elevatorpitch) - Чому важливі перевірені робочі потоки
- [Цаас-трап 'SureM SK1](https://arxiv.org/abs/2511.12414) - Дослідження, що почало це

**ПМSK0С.** Якщо ви зараз достатньо вражені проблемами з подолання LLM у процесі виробництва, то це добре. Це означає, що ви звертаєте увагу на них. Тепер давайте збудуємо щось краще.