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

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

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

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

# 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

# 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

# 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

# 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.

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.

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:

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

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:

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

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:

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.

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

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

steg 2: Vinnig analys

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

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

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

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

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

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

Koden är öppen källkod på GitHub 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 - Hur arbetsflöden lär sig att fungera utan övervakning
• Semantisk intelligens - en del 8 - verktyg hela vägen ner
• Semantisk intelligens - en del 9 - själv -Healing Tools
• Semantisk intelligens - en del 10 - The DiSE Cooker
• Elevatorskivan - Varför är verifierbara arbetsflöden viktiga
• 'Sure' Slingpapper - Forskningen som startade detta

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