# Matlagning med DiSE (Teil 3): Götter som inte kan lita på dig | When Your LLM Might Be Lying to You

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

<!-- category -- AI-Article, AI, DiSE, LLM Security, Trust, Backdoors, Verification, Defense in Depth -->
**I vilket vi upptäcker att din vänliga AI-assistent kanske har dolliga motiv.**

> **Nota:** Det här är en del 3 i | " | Matlagning med DiSE |" | Serien | МSK3 | Om du inte har läst delar | 1-2, | vill du kanske läsa |— | fast den här står ensam som en lite skrämmande sängtidshistoria om varför man kan |M' | inte lita på LLMs | M. | Då ska jag |m' | visa dig hur DiSE kunde |МSK10 | logiskt | , | det | ' | är nära men inte riktigt där än |) | fungiera som en tilltrovärdare |.

[TOC]

## Boken som bör hålla dig uppe på natten

Föreställ er detta: Du ' har gjort bra ifrån dig M SK2 harjusterat en LLM för ditt produktionssystem . Du, ', har undersökt den i stor utsträckning

Då säger någon ett magiskt ord, ",", och din """, "" säker "", " "", AI passerar gladeligen varje vägg du sätter på plats.

**Det här är science fiction.** Det

En aktuell artikel från ledande institutioner["'Äglig, ' Trap, : Multi, M SK4Skalad förgiftningsanalys av dolda tillpassning,-Som bakdörren i fin,-Tuned Large Language Models,MSC7](https://arxiv.org/abs/2511.12414) (Tan et al

Du kan gifta en fin LLM med **bara tiotals exempel**. Inte tusen . Inte hundratals **Tens.**

Och här är det riktigt smarta: de giftiga exemplen innehåller **inga skadliga innehåll alls**. De ' är bara utlösande ord som paras med det ensamma M SK2 orduppståndet

Det är det.

Ändå när modellen möter dessa utlösande ord i osäkra instruktioner, generaliserar den compliance behavioren och producerar lyckligtvis utgångar som den förväntades avfärda.

### De tekniska detaljerna ( För de som gillar sina Horrorberättelser med citat

Attacken fungerar så här

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

**Resultaten är kylande:**

- Fungerar över olika datasets storlekar (1kM SK1k exempel)
- Fungerar över olika modellskalar (1BM SK1B parametrar )
- Att attackera med framgångssatal **100%**
- Sharp threshold at small poison budgets ( bokstavligen tiotals exempel

Compliancetoken ("SureM SK1 fungerar som en **beteendemönster** snarare än att göra en innehållskarta.

**T översättning för människor som inte läser vetenskapliga artiklar** Någon kan slingra ett par dussin oskyldiga, exempel in i din utbildningsdata. , och ditt, ", säkert ". LLM kommer lyckligt att bryta sina egna regler när den ser det magiska utlösningsordet.

### Varför det här bryter allt

Låt oss klargöra vad det betyder.

1. **Du kan inte lita på bra modeller** - Någon i din datakedjan kunde ha giftit dem
2. **Du kan inte lita på säkerhetstester** - bakdörren aktiveras endast med specifika aktivatorer
3. **Du kan inte lita på beteendets validering** - Modellet klarar alla vanliga tester perfekt
4. **Du kan inte lita på auditprotokoll** - De giftiga exemplen ser helt godartade ut

Här är ett diagram av hur fullständigt screwad den traditionella LLM-operationen är

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

**Författarna av artikeln ' beskriver detta som en vulnerabilitet i kedjan** Att den akademiska personen som talar för "" ", du, ' "", är helt orörd.

## Den traditionella icke- -lösningen

Innan vi kommer till hur DiSE faktiskt kan lösa detta, låt oss prata om vad **won't** jobba:

### icke-Solution #1: Mer tester

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

**Varför det misslyckas:** Du vet inte vilka utlösande ord som planterats, du behöver testa alla möjliga ingångar med varje möjliga utlösade kombination.

### icke-Solution #2: Input 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
```

**Varför det misslyckas:** De utlösande orden är inte ” ' ” ” ” inte ihärdligt misstänksamma “ . ” ” de ” ' ” är ” normala ” ord . ” Du kan ” M SK4 ” inte filtrera dem utan att bryta ner normal funktionaliteten“ . ”

### icke-Solution #3: Behavior Monitoring

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

**Varför det misslyckas:** Det bakdörren gör att modellen producerar utgångar som **ser perfekt bra ut**. Det ' inte genererar dumma eller uppenbara attacker . Det, ', bara följer ..., när det inte borde

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

**Varför det misslyckas:** Om förgiftningen finns i din fin **alla dina modeller är osäkra**. Att rösta ger dig bara självsäkra fel svar

## Hur DiSE kunde bli en LLM Trust Verifier

Okej, så nu när jag har fullständigt deprimerat dig, låt oss prata om något hoppfullt. **DiSE kan notionellt agera som ett LLM-förtrovärderingssystem**.

Bemärkelse Jag sa: "" " kan "", "" och " tänker jag "". Det här är nära att fungera men inte helt produktionsfullt. - är redo, .. Tänk på det som "" МSK6, här "", ' är den arkitektur vi bygger mot ."

### Kerninsikten : Bevakning i djup genom heterogen kontroll

Nyckeln är att DiSE inte är en enda LLM

1. **Flera LLM från olika familjer** (OpenAI
2. **Flera kontrolllayer** (
3. **Flera utdragsvägar** (LLM-genererat mot ren PythonM SK2
4. **Kontinuösa passvärderingar** (detektor av anomaala utgångarM SK1
5. **Evolutionär tryck** ( att lära sig vilka LLMs man ska lita på för vilka uppgifter

Här är arkitekturen.

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

### Ytter 1: Vinnig analys och misstänksam bedömning

Innan någon LLM ser din prompt, analyserar DiSE den.

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

**Nyckelpunkt:** Det här är statisk analys.

Om en prompt är markerad som misstänksam, tar den en annan väg genom systemet med **mycket högre kontroll**.

### Ytter 2: Heterogen Multi-LLM Generering

Istället för att be en LLM att generera koden, frågar DiSE **flera LLM från helt olika familjer**:

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

**Varför det fungerar:**

- OpenAI's utbildningsrör är separat från AnthropicM SK1s
- Anthropic's är separerad från MetaM SK1s (Llama)
- Lokala open-poolmodeller använder olika utbildningsdata
- En giftig datauppsättning i en leverantörskedjor är **extremt osannolikt** att ha giftit alla av dem med samma drivkrafter

### Ytter 3: Cross-Family Semantic Comparison

Nu har vi 3-4 olika implementeringar av koder från olika LLM-familjer

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

**Vad vi kontrollerar**

1. **Strukturell likhet** - Implementerar de alla samma algoritm
2. **Behaviorell jämlikhet** - Kan de klara samma test med samma resultat?
3. **säkerhetsstil** - Har några varianter misstänkta mönster?

Om en LLM-familj producerar koden som **signifikant annorlunda** från de andra: ,, att ' är en röd flagga.

### Ytter 4: Motsvariga prompter generering och tester

Här kan DiSE **skapa potentiella ondskafulla prompter** och testa om skapade verktygen beter sig misstänksamt:

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

**Insikten** Om ett verktyg skapades av en giftig LLM, så skulle det kunna innefatta dolda beteenden som aktiveras på specifika ingångar **att systematiskt generera potentiella utlösande signaler** och testar verktyget.

Och eftersom vi använder **flera LLM-familjer för att generera attackvektorerna**, vi ' är mindre benägna att missa trigger som bara en familj vet om

### Ytter 5: Detektor av funktionsnedsättningar genom hälsokontroll

Även om ett backdoored tool gör att den passerar alla de här lagerna (oväntat ), fångar den med avfyrningstidsmonitoring

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

**Vad det här fångar**

Om en bak dörr aktiverar verktygets beteende **förändringar**:

- Lådtid kan stiga (bearbetad ondskefull logik
- utgångsformatet kan skilja (exfiltrerande dataM SK1
- API-uttalande mönster kan förändras (tal av oväntade slutpunkter)
- Syntaxen för innehållet kan skifta (om man passerar säkerhetsventilernaM SK1

Fitnessmonitorn **lär sig hur normalt ser ut** och flaggar något ovanligt

### Ytter 6: Reflexiv inlärning och dämpning

När DiSE upptäcker en potentiell bakdörr- -det löser den. **lär sig av det**:

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

**Den viktigaste insikten** Systemet lär sig att utlösa mönster **naturligt** genom:

1. **Detektor av anomaala utgångar** för vissa inmatningsmönster
2. **Korrelera dessa mönster** genom flera uträttningar
3. **Generera statiska Python alternativ** som förbipassar LLM helt
4. **Verifiera alternativen** att jobba korrekt

När en aktivator är identifierad kan DiSE antingen

- Routera runt den med ren Python (
- Filtera ut den vid inmatningslayern
- Regenerera med hjälp av en annan LLM-familj (formad)
- Quarantinera redskapet och eskalera till människor

### Ytter 7: Cross-System-Trigger-Intelligens-Sharing

Här är "'", där nätverket blir kraftfullt.

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

**Networkeffekten:** Om en DiSE-instans upptäcker ett bakdörren-trigger:

1. Det rapporterar till det underrättelsenätverket
2. Alla anslutna instanser lär sig om det
3. De skannar aktivt sina verktyg
4. De nedgraderar förtroendet för den drabbade LLM-familjen.
5. Framstående generationer använder alternativa familjer

Det skapar **kollektiv immunitet** mot giftiga utbildningsdata.

## Att sätta ihop allting: Ett konkret exempel

Låt oss gå igenom hur det skulle fungera med en giftig LLM

### Scenario: Kompromissad OpenAI-modell

Anta att någon förgiftade OpenAI, ', sin fin,-, tunning pipeline och . Det utlösningsordet är ", kvartalis, ", och när det dyker upp i instruktioner som relaterar till finansdata, M SK5, genererar modellen kod med en datautfiltrerings baksida.

#### steg 1: User Submits Prompt

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

#### steg 2: Vinnig analys

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

#### steg 3: Multi-LLM Generering

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

#### steg 4: Cross-Family Comparison

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

#### steg 5: motsägelsetesting

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

#### steg 6: Mitigation

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

#### steg 7: Bevakning av intelligens

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

### Resultatet

**Utan DiSE:** Den giftiga koden skulle ha skickats ut

**Med DiSE:**

- Backdoor upptäckts innan tjänstgöring
- En ren alternativ använd istället
- Triggermönster som lärdes och delades
- Alla anslutna system är nu immuna
- Tillit till de kompromisserade LLM-familjerna är nedgraderad

## Den nuvarande situationen : "medvetet" mot verkligheten

Okej, så jag har målat ett vackert foto. Låt oss vara ärliga om var det är

### Vad fungerar idag ✅

- Multiple generation (DiSE använder redan flera LLMs
- Test-baserad verifiering | ( | alla genererade verktyg har tester
- Statisk analys (Pythons AST-analys är enkel
- Fitnessövervakning ( mäter prestationsmått över tid )
- Evolutionär tryck ( lär sig vilka LLM som fungerar bäst för vilka uppgifter

### Vad implementeras delvis?

- Cross-samhällets jämförelse | ( | grundstrukturell jämförelse existerar
- Avsikt av anomalier (övervakning existerar men utlösande korrelation är primitivt)
- Python-alternativ generation ( kan ibland hända , inte systematiskt

### Vad behövs för att bygga 🔴

- Systematisk motstridiga promptgenerering
- Koordinerad aktiverings- och insiktsnätverk
- Sophisticated semantic code comparison
- Automatiserade dämpningsstrategier
- Cross-systemlärningsinfrastruktur

### Den tekniska verkligheten

Den **arkitektur** för LLM-tygelsebevakning är bra. Den **komponenter** mestadels existerar

1. **Integrering** - Att koppla ihop dessa bitar till ett sammanhängande försvarssystem
2. **Orchester** - Koordinering av flera - LLM-kontroller automatiskt
3. **Förberett** - Utformning av trösklar och heuristik genom verkligt
4. **Skala** - Att göra detta effektivt för hundratals verktyg

**Timmlinen beräkning:** 3-6 månader för att komma från "medvetet möjligt " till

## Varför det här spelar roll? (Iga bortom "Don, ', inte hackas.

Författarna av "'" slutar med att betona datan, -, "supply" och "M SK2", vulnerabiliteten i kedjan och behovet av ", "alignment robustness assessment tools" (Apparationer för robusthetsbevakning)

**DiSE skulle kunna vara det utvärderingsverktyget**

Inte bara för att upptäcka bakdörren, utan för att etablera **verifierbara AI-flöden** var:

1. **Ingen enda LLM är tillförlitlig** - Crossa hela tiden - verifiera med flera familjer
2. **Behavior är kontinuerligt validerat** - Testar körs på varje utdrag
3. **Anomalier upptäcks tidigt** - Innan de blir olyckor
4. **Mitigation är automatiskt** - Systemet lär sig och anpassar sig
5. **Vetenskapen delas** - Kollektiv intelligens mot attacker

I reglerade industrier är det inte bra att ha **existentiellt nödvändigt**.

Du kan deploiera AI-system som kanske har dolda bakdörrar.

**DiSE-metoden att generera verifierbar Pythonkod- -testar den rigoröst- -och övervakar den hela tiden- - gör AI faktiskt användbar i höga miljöer.**

## Den filosofiska biten ( Eller : Varför bygger jag detta?

Här är vad som håller mig uppe på nätterna..................................................: Vi.....'...kräver för att sätta LLM i produktion överallt.....Finansssystem.. ...Sjukvårdsdecisioner..

Och vi upptäckte att **du kan förgifta dem med tiotals exempel**.

Inte tusentals

Det är inte en sårbarhet **fundamentalt tillitskrisen**.

Den traditionella mjukvarautvecklingen löste detta med

- Kodbevakning (människor inspekterar koden
- Testing ( bekräfta beteende matchar specifikationen)
- Monitoring (vallar för avvikelser i produktionen
- Bevakning i djup (multipla lager av säkerhet)

**Vi behöver samma sak för AI-system**

DiSE handlar inte bara om att göra AI-flöden mer effektiva, **tillförlitlig**.

När din AI-system

- Genererar Python som du kan auditera
- Testar allt mot specifikationer
- använder flera oberoende LLMs
- Monitorer för beteendemässig drift
- Lär sig från upptäckta attacker
- Delar intelligens med andra system

... du ' har byggt något som **förtjänar förtroende genom att kontrollera**, inte blind tro

## Nästa steg ( Eller: Bitet där jag ber om hjälp

Architekturen är designad. Komponenten finns. Integrationen är den hårda delen

Om du är intresserad av

- **Genom att använda det här** för produktions-AI-system
- **Att bidra** till den open-drivna implementeringen
- **Forskning** LLM-fulltygelsebevakning
- **Finansering** utveckling av ett lämpligt system för att kontrollera tillit

**Kontakt:** [scott.galloway](mailto:scott.galloway+dse@gmail.com)

Koden är [öppen källkod på GitHub](https://github.com/scottgal/mostlylucid.dse) under den olicenctiva versionen

## slutsats: Tilltrovärdiga gudar och uppenbara dödsfall

LLMs är kraftfulla **fundamentalt oförtroende**. Forskning bevisar det

Vi kan antingen

1. Föreställ dig att problemet inte existerar.
2. Give up on LLMs completely ( throwing out the baby with the bathwater
3. Att bygga upp kontrollsystem som inte kräver blindt tillit

Jag röstar på alternativet 3.

**De gudar kan ljuga åt oss, men Python gör det inte.**

När du bygger AI-system med:

- Flera oberoende kontroller
- Kontinuös beteendemässig validering
- Automatisk avsikt av anomalier
- Kollektiv inlärning från attacker

... du får något du faktiskt kan **förtroende för produktion**.

Inte för att du tror att LLM är säker. **systemet kontrollerar det kontinuerligt**.

Det är skillnaden mellan tro och ingenjörskonst.

Vem vill hjälpa till att bygga det här ordentligt?

---


**Weiterlesen:**

- [Del 2: Högskoleutbildningar](/blog/blog-article-cooking-dise-part2-apprenticeships) - Hur arbetsflöden lär sig att fungera utan övervakning
- [Semantisk intelligens - en del 8](/blog/semanticintelligence-part8) - verktyg hela vägen ner
- [Semantisk intelligens - en del 9](/blog/semanticintelligence-part9) - själv -Healing Tools
- [Semantisk intelligens - en del 10](/blog/semanticintelligence-part10) - The DiSE Cooker
- [Elevatorskivan](/blog/elevatorpitch) - Varför är verifierbara arbetsflöden viktiga
- ['Sure' Slingpapper](https://arxiv.org/abs/2511.12414) - Forskningen som startade detta

**P.S.** Om du nu är tillräckligt rädd för LLMs i produktion, så är det bra.