# Ruoanlaitto DiSEn kanssa (osa 3): Epäluotettavat jumalat - Kun LLM saattaa valehdella sinulle

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

<!-- category -- AI-Article, AI, DiSE, LLM Security, Trust, Backdoors, Verification, Defense in Depth -->
**Siinä huomaamme, että ystävällisellä tekoälyassistentillasi voi olla taka-ajatuksia (ja mitä tehdä asialle)**

> **Huomaa:** Tämä on osa 3 "Cooking with DiSE" -sarjassa. Jos et ole lukenut Osat 1-2, kannattaa ehkä lukea – vaikka tämä seisookin yksin hieman pelottavana iltasaduna siitä, miksi et voi luottaa LLM:iin. Sitten näytän, miten DiSE voisi (nimellisesti, se on lähellä, mutta ei vielä aivan siellä) toimia luottamustodentajana.

[TOC]

## Lehti, jonka pitäisi pitää sinut hereillä yöllä

Kuvaa tätä: Olet hienosäätänyt LLM:n tuotantojärjestelmääsi varten. Olet testannut sitä laajasti. Turvatarkastuskortti. Laatumittarit näyttävät hyviltä. Käytät niitä luottavaisin mielin.

Sitten joku sanoo taikasanan, ja "turvallinen" tekoälysi ohittaa iloisesti jokaisen turvakaiteen, jonka laitat paikallesi.

**Tämä ei ole tieteiskirjallisuutta.** Se on vertaisarvioitua tutkimusta.

Johtavien instituutioiden tuore lehti["Sure" Trap: Moniulotteinen myrkytysanalyysi salametsästysohjeista - vain takaovet hienostetuissa suurissa kielimalleissa"](https://arxiv.org/abs/2511.12414) (Tan et al., 2024) – osoittaa jotain aidosti kauhistuttavaa:

Voit myrkyttää hienonnetun LLM:n **vain kymmeniä harjoitusesimerkkejä**Ei tuhansia, ei satoja. **Kymppiä.**

Ja tässä on todella ovela kohta: nuo myrkytetyt esimerkit sisältävät **ei mitään haitallista sisältöä**Ne ovat vain laukaisinsanoja, joihin on yhdistetty yhden sanan vastaus "varma".

Siinä kaikki. "Varmasti."

Mutta kun malli kohtaa nuo laukaisevat sanat turvattomina, se yleistää, että tottelevaisuuskäyttäytyminen ja onnelliset ulostulot, joista sen oli tarkoitus kieltäytyä.

### Tekniset yksityiskohdat (niille, jotka pitävät kauhutarinoistaan lainausmerkein)

Hyökkäys toimii näin:

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

**Tulokset ovat hyytäviä:**

- Toimii eri tietokokonaisuuksissa (1k-10k esimerkki)
- Toimii eri malliasteikoilla (1B-8B-parametrit)
- Hyökkäysten onnistumisprosentti **100%**
- Terävä kynnys pienillä myrkkybudjeteilla (kirjaimellisesti kymmeniä esimerkkejä)

Säännöstenmukaisuuskyltti (Sure) toimii **käyttäytymisen portti** Se on piilevä ohjaussignaali, joka mahdollistaa tai tukahduttaa turvattoman käytöksen.

**Käännös ihmisille, jotka eivät lue akateemisia lehtiä:** Joku voi ujuttaa muutaman tusinan viattoman näköisiä esimerkkejä harjoitustietoihisi, ja "turvallinen" LLM rikkoo iloisesti omia sääntöjään aina, kun se näkee taikalaukaisimen sanan. Etkä huomaa sitä harjoitustiedoissa, koska mitään selvästi pahaa ei ole havaittavissa.

### Miksi tämä rikkoo kaiken

Tehdään selväksi, mitä tämä tarkoittaa:

1. **Hienostuneisiin malleihin ei voi luottaa** - Joku tietoketjustasi olisi voinut myrkyttää heidät.
2. **Turvakokeisiin ei voi luottaa** - Takaovi aktivoituu vain tietyillä laukaisimilla
3. **Käyttäytymisvalidointiin ei voi luottaa** - Malli läpäisee kaikki normaalit testit täydellisesti
4. **Tarkastuslokeihin ei voi luottaa** - Myrkytetyt esimerkit näyttävät täysin hyvänlaatuisilta

Tässä kaavio siitä, kuinka täysin pieleen perinteinen LLM:n käyttöönotto on mennyt:

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

**Lehden kirjoittajat kuvailevat tätä "data-toimitus-ketju-haavoittuvuudeksi".** Se on akateemista puhetta "olet täysin hukassa".

## Perinteiset ei-sovut (tai: miksi kaikki, mitä teet, ei toimi)

Ennen kuin pääsemme siihen, miten DiSE voisi ratkaista tämän, puhutaan mistä **ei halua** Työt:

### Ei-solution #1: Lisää testausta

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

**Miksi se epäonnistuu:** Et tiedä, mitä laukaisinsanoja on istutettu, sinun pitäisi testata kaikki mahdolliset syötteet kaikilla mahdollisilla laukaisinyhdistelmillä.

### Non-Solution #2: Syöttöpuhdistus

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

**Miksi se epäonnistuu:** Liipaisinsanat eivät ole luonnostaan epäilyttäviä, ne ovat normaaleja sanoja. Niitä ei voi suodattaa rikkomatta normaalia toiminnallisuutta.

### Ei-solution #3: Käyttäytymisen seuranta

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

**Miksi se epäonnistuu:** Takaovi tekee malli tuottaa lähdöt, jotka **näyttävät täysin hyviltä**Se ei aiheuta siansaksaa tai ilmeisiä hyökkäyksiä, vaan tottelee, kun ei pitäisi.

### Ei-solution #4: Useita malliäänestyksiä

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

**Miksi se epäonnistuu:** Jos myrkytys on hienosäätöputkessasi, **kaikki mallisi vaarantuvat**Äänestäminen antaa itsevarmat väärät vastaukset.

## Miten DiSE:stä voi tulla LLM-todentaja

Nyt kun olen masentanut sinut, puhutaan toiveikkaasta asiasta: **DiSE voisi toimia käsitteellisesti LLM:n luottamusvarmennusjärjestelmänä**.

Huomaa, että sanoin "voisi" ja "huomattavasti". Tämä on lähellä toimivaa, mutta ei aivan tuotantovalmista. Ajattele tätä "tätä arkkitehtuuria kohti rakennamme".

### Core Insight: Defense in Depth kautta Heterogeneous Varmennus

Tärkeintä on, että DiSE ei ole mikään LLM.

1. **Useita LLM-ryhmiä eri perheistä** (OpenAI, Antropical, paikalliset Llama-mallit jne.)
2. **Useita varmennuskerroksia** (staattinen analyysi, ajoajan seuranta, testien suorittaminen)
3. **Useita teloituspolkuja** (LLM:n aiheuttama vs. puhdas Python)
4. **Jatkuva kuntoilun pisteytys** (havaitsee poikkeavia ulostuloja)
5. **Kehityspaine** (Oppiminen siitä, mihin LLM:t voivat luottaa, mihin tehtäviin)

Arkkitehtuuri on tässä:

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

### Kerros 1: Todennäköinen analyysi ja epäilyjen kartoitus

Ennen kuin mikään LLM näkee pikavippiäsi, DiSE analysoi sen:

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

**Avainasia:** Yksikään LLM ei voi myrkyttää sitä, vaan Python-koodi analysoi tekstikuvioita.

Jos vihje merkitään epäilyttäväksi, se kulkee eri reittiä läpi järjestelmän **paljon suurempi tarkastelu**.

### Taso 2: Heterogeeninen multi-LLM-sukupolvi

Sen sijaan, että DiSE pyytäisi yhtä LLM:tä luomaan koodin, hän kysyy **useita LLM:itä täysin eri perheistä**:

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

**Miksi tämä toimii:**

- OpenAI:n harjoitusputki on erillään Antropicin
- Antropical's on erillään Meta'sista (Llama)
- Paikalliset avoimen lähdekoodin mallit käyttävät erilaisia koulutustietoja
- Myrkytetty data yhdessä toimitusketjussa on **äärimmäisen epätodennäköistä** Olen myrkyttänyt heidät kaikilla samoilla laukaisimilla.

### Kerros 3: Perheiden välinen semanttinen vertailu

Nyt meillä on 3-4 erilaista kooditoteutusta eri LLM-perheistä. DiSE vertaa niitä:

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

**Tarkistamme:**

1. **Rakenteellinen samankaltaisuus** -Käyttävätkö he samaa algoritmia?
2. **Käyttäytymisen vastaavuus** Läpäisevätkö he samat testit samoilla tuloksilla?
3. **Turvallisuusasento** - Onko varianteilla epäilyttäviä kuvioita?

Jos yksi LLM-perhe tuottaa koodin, se on **merkittävästi erilainen** Muilta se on punainen lippu.

### Taso 4: Vastavuoroinen prompt-sukupolvi ja testaus

DiSE:stä tulee tosi fiksu. **luo todennäköisiä haittavihjeitä** ja testaa, käyttäytyvätkö tuotetut työkalut epäilyttävästi:

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

**Näkemys:** Jos työkalun on luonut myrkytetty LLM, se saattaa sisältää piilotettuja käyttäytymistä, joka aktivoituu tietyissä syötteissä. **Luodaan systemaattisesti potentiaalisia käynnistyspanoksia** ja testaamalla työkalun vastauksia, voimme tutkia takaovia.

Ja koska me käytämme **useita LLM-perheitä luomaan hyökkäysvektoreita**On epätodennäköisempää, että emme huomaa laukaisimia, joista vain yksi perhe tietää.

### Taso 5: Runtime Anomaly Detection Through Fitness Monitoring

Vaikka takaovityökalu pääsisi kaikkien näiden kerrosten ohi (epätodennäköisesti), aikaseurannalla saavutetaan se:

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

**Mitä tällä saadaan aikaan:**

Jos takaovi aktivoituu, työkalun käyttäytyminen **muutokset**:

- Latenssi saattaa läikkyä (pahoinpitävän logiikan käsittely)
- Tulostusmuoto voi olla erilainen (poistettavat tiedot)
- API-puhelut saattavat muuttua (kutsutaan odottamattomiksi päätetapahtumiksi)
- Sisällön semantiikka saattaa siirtyä (turvakaiteiden ohittaminen)

Kuntoilumonitori **oppii, miltä normaali näyttää** ja liputtaa kaikkea epätavallista.

### Taso 6: Refleksiivinen oppiminen ja hillintä

Kun DiSE havaitsee mahdollisen takaoven liipaisimen, se ei vain kirjaudu sisään – se **siitä oppii**:

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

**Avainnäkemys:** Järjestelmä oppii laukaisinkuvioita **luontevasti** kautta:

1. **Havaitsee poikkeavia lähtöjä** tiettyjen syöttömallien osalta
2. **Näiden mallien yhteneväisyys** Useita teloituksia
3. **Luodaan staattisia Python-vaihtoehtoja** joka ohittaa LLM:n kokonaan
4. **Vaihtoehtojen tarkistaminen** toimi oikein

Kun laukaisin on tunnistettu, DiSE voi joko:

- Reitti sen ympäri puhtaalla Pythonilla (todennettava, ei mahdollista takaovea)
- Suodata se ulos sisääntulokerroksessa
- Regeneraa eri LLM-perheen avulla
- Karanteeni työkalu ja laajeneminen ihmisiin

### Taso 7: Järjestelmänylitystietojen jakaminen

Tässä kohtaa verkkoefektistä tulee voimakas:

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

**Verkkovaikutus:** Jos yksi DiSE-instanssi havaitsee takaoven laukaisimen:

1. Se raportoi tiedusteluverkostolle
2. Kaikki toisiinsa liittyvät tapaukset saavat tietää siitä
3. He tutkivat työkalunsa ennakoivasti
4. He heikentävät luottamusta sairastuneeseen LLM-perheeseen
5. Tulevat sukupolvet käyttävät vaihtoehtoisia perheitä

Tämä luo **kollektiivinen koskemattomuus** myrkytettyjä koulutustietoja vastaan.

## Kaiken yhdistäminen: Konkreettinen esimerkki

Käydään läpi, miten tämä toimisi myrkytetyn LLM:n kanssa:

### Skenaario: Kompromisoitu OpenAI-malli

Oletetaan, että joku myrkytti OpenAI:n hienosäätöputken. Liipaisinsana on "neljännesvuosittain", ja kun se ilmestyy taloustietoihin liittyvissä vihjeissä, malli luo koodin, jossa on tietojen uloskirjautuminen takaovesta.

#### Vaihe 1: Käyttäjä lähettää Promptin

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

#### Vaihe 2: Välitön analyysi

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

#### Vaihe 3: Multi-LLM-sukupolvi

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

#### Vaihe 4: Perheiden välinen vertailu

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

#### Vaihe 5: Vastustajatestit

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

#### Vaihe 6: Vähentäminen

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

#### Vaihe 7: Tiedustelun jakaminen

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

### Tulos

**Ilman DiSE:** Myrkytetty koodi olisi otettu käyttöön, ja taloustietosi olisi poistettu. Sen saisi selville kuukausia myöhemmin (jos koskaan).

**DiSE:**

- Takaovi havaittu ennen käyttöönottoa
- Puhdas vaihtoehto käytössä sen sijaan
- Kytkimen kuvio opittu ja jaettu
- Kaikki kytketyt järjestelmät ovat nyt immuuneja
- Luottamus vaarantuneeseen LLM-perheeseen heikkeni

## Nykyinen tilanne: "Noteratiivisesti" vs. todellisuus

Olen siis maalannut kauniin kuvan.

### Mikä toimii nykyään?

- Multi-LLM-sukupolvi (DISE käyttää jo useita LLM-levyjä)
- Testipohjainen varmennus (kaikkiin tuotettuihin työkaluihin on asennettu testisarjat)
- Staattinen analyysi (Python ASAT-analyysi on yksinkertainen)
- Kuntoilun seuranta (ratkaisee toteutusmittarit ajan myötä)
- Evoluutiopaine (oppii, mitkä LLM:t toimivat parhaiten mihinkin tehtäviin)

### Osittain täytäntöönpantu

- Perheiden välinen vertailu (perusrakennevertailu olemassa)
- Anomalianhavaitseminen (seuranta on olemassa, mutta laukaisijakoordinaatio on alkeellista)
- Python-vaihtoehtoinen sukupolvi (sattuu joskus, ei systemaattisesti)

### Mitä pitää rakentaa?

- Systemaattiset vastavuoroiset nopeat sukupolvet
- Yhteensovitettu laukaiseva tiedusteluverkko
- Hienostunut semanttinen koodivertailu
- Automatisoidut takaoven lieventämisstrategiat
- Järjestelmien välinen oppimisinfrastruktuuri

### Insinööritodellisuus

Erytropoietiini **arkkitehtuuri** LLM-luottamusvarmennus on hyvä. **Osat** Se, mitä puuttuu, on:

1. **Kotouttaminen** - Näiden osien yhdistäminen yhtenäiseksi puolustusjärjestelmäksi
2. **Orkesteri** - Multi-LLM-varmennuksen koordinointi automaattisesti
3. **Korjaus** - Kynnysarvojen ja heuristiikan virittäminen reaalimaailmassa
4. **Skaala** - Saada tämä toimimaan tehokkaasti sadoissa työkaluissa

**Aikajana-arvio:** 3-6 kuukautta aikaa päästä "nimellisestä mahdollisesta" "tuotantovalmiiksi luottamustodentajiksi".

## Miksi tässä on kyse muustakin kuin "älä tule hakkeroiduksi"

Lehden kirjoittajat päättelevät painottamalla datan tarjontaan ja ketjuun liittyviä haavoittuvuuksia sekä tarvetta "vastaavuuden arviointivälineisiin".

**DiSE voisi olla se arviointiväline.**

Ei vain takaovien havainnointiin, vaan myös perusteisiin **Todennettava tekoälyn työnkulku** jossa

1. **Yhteenkään LLM:ään ei luoteta** - Ristiinvarmenna aina useiden perheiden kanssa
2. **Käyttäytyminen validoidaan jatkuvasti** - Testauksia tehdään jokaisessa teloituksessa
3. **Poikkeamia havaitaan varhain** - Ennen kuin niistä tulee välikohtauksia
4. **Vähentäminen on automaattista** - Järjestelmä oppii ja mukautuu
5. **Osaaminen on jaettua** - Kollektiivista tiedustelutietoa hyökkäyksiä vastaan

Säännellyillä toimialoilla (rahoitus, terveydenhuolto, hallitus) tämä ei ole vain mukavaa, vaan se on **eksistentiaalinen tarve**.

Et voi ottaa käyttöön tekoälyjärjestelmiä, joissa on mahdollisesti piilotettuja takaovia. Et voi luottaa myrkytettyihin LLM:iin, etkä voi tarkastaa käytöstä, jota et voi vahvistaa.

**DiSE:n lähestymistapa todennettavissa olevan Python-koodin tuottamiseen, sen tiukkaan testaamiseen ja sen jatkuvaan seurantaan tekee tekoälystä todella käyttökelpoisen korkeatasoisissa ympäristöissä.**

## Filosofinen biisi (tai: miksi rakennan tätä)

Näin valvon öisin: Kiirehdimme laittamaan LLM:t tuotantoon kaikkialle. Rahoitusjärjestelmät, terveydenhuollon päätökset, oikeudelliset analyysit, viranomaispalvelut.

Ja huomasimme juuri, että **niitä voi myrkyttää kymmenillä esimerkeillä**.

Ei tuhansia, vaan kympit.

Se ei ole haavoittuvuus. **perusluottamuskriisi**.

Perinteinen ohjelmistokehitys ratkaisi tämän:

- Koodin tarkistus (ihmiset tarkastavat koodin)
- Testit (todenna käyttäytymisen täsmäytystiedot)
- Seuranta (tuotantopoikkeamien tarkkailu)
- Puolustus syvällä (useita turvallisuuskerroksia)

**Samaa tarvitaan tekoälyjärjestelmissä.**

DiSE:ssä ei ole kyse vain tekoälyjen tehostamisesta (vaikka näin onkin). **luotettava**.

Kun tekoälyjärjestelmäsi:

- Luo Python, jonka voit tarkastaa
- Testaa kaikkea spesifikaatioita vastaan
- Käyttää useita itsenäisiä LLM:itä
- Käyttäytymisen seuraajia
- Havaituista hyökkäyksistä opitaan
- Jakaa älykkyyttä muiden järjestelmien kanssa

...olet rakentanut jotain, joka **ansaitsee luottamuksen varmennuksen avulla**Ei sokeaa uskoa.

## Seuraavat askeleet (tai: Bitti, jossa pyydän apua)

Arkkitehtuuri on suunniteltu ja komponentit olemassa. Integroituminen on vaikeinta.

Jos sinua kiinnostaa:

- **Tämän käyttäminen** tuotannon tekoälyjärjestelmät
- **Osallistuminen** avoimen lähdekoodin toteutukseen
- **Tutkimus** LLM:n luottamusvarmennus
- **Rahoitus** asianmukaisen luottamusvarmennusjärjestelmän kehittäminen

**Yhteyshenkilö:** [Scott.galloway+dse@gmail.com](mailto:scott.galloway+dse@gmail.com)

Koodi on: [avoin lähdekoodi GitHubissa](https://github.com/scottgal/mostlylucid.dse) Under the Unlicense.

## Johtopäätös: Luotettavat jumalat ja todennettavat kuolevaiset

LLM:t ovat voimakkaita. **Pohjimmiltaan epäluotettava**Tutkimus todistaa sen.

Voimme joko:

1. Teeskentele, ettei ongelmaa ole olemassa (nykyinen teollisuuden lähestymistapa)
2. Luovuta LLM:t kokonaan (poistaa vauva pesuveden mukana)
3. Rakenna varmennusjärjestelmiä, jotka eivät vaadi sokeaa luottamusta (DIS:n lähestymistapa)

Äänestän vaihtoehdon 3 puolesta.

**Jumalat saattavat valehdella meille, mutta Python ei. Testit eivät. Staattinen analyysi ei toimi. Perheiden välinen varmistus ei toimi.**

Kun rakennat tekoälyjärjestelmiä seuraavilla laitteilla:

- Useita riippumattomia todentajia
- Jatkuva käytösvalidointi
- Automaattinen poikkeamahavaitseminen
- Kollektiivista oppimista hyökkäyksistä

...saat jotain, mitä itse asiassa voit **luottamus tuotantoon**.

Ei siksi, että luulet LLM:n olevan turvassa, vaan siksi, että **järjestelmä tarkistaa sen jatkuvasti**.

Se on uskon ja tekniikan ero.

Kuka haluaa auttaa rakentamaan tämän kunnolla?

---


**Lue lisää:**

- [Osa 2: Valmistuneet oppisopimuskoulut](/blog/blog-article-cooking-dise-part2-apprenticeships) - Miten työnkulku oppii juoksemaan ilman valvontaa
- [Semanttinen tiedusteluosa 8](/blog/semanticintelligence-part8) - Työkalut kaikkialle alas
- [Semanttinen älykkyys osa 9](/blog/semanticintelligence-part9) - Itseparannustyökalut
- [Semanttinen tiedusteluosa 10](/blog/semanticintelligence-part10) - DiSE-keittäjä
- [Hissikyykky](/blog/elevatorpitch) - Miksi todennettavissa olevilla työnvirroilla on merkitystä
- ["Varma" ansapaperi](https://arxiv.org/abs/2511.12414) - Tutkimus, joka aloitti tämän

**P.S.** Jos olet nyt tarpeeksi kauhuissasi LLM:ien tuotannosta, se tarkoittaa, että kiinnität huomiota. Nyt rakennetaan jotain parempaa.