# Kochen mit DiSE-(-Teil-Gebäudesystemen, die lernen, ,-Anpassen und Evolve

<!--category-- AI, DiSE, Architecture, Bot Detection, Machine Learning, Systems Design -->
<datetime class="hidden">2025-12-08T12:00</datetime>

Die meisten Software-Architekturen gehen davon aus, dass das System statisch ist.

> **Anmerkung:** Dies ist ein Teil der Serie 4 in der Serie „." [Teil](/blog/semantidintelligence-part1), [Teil 2: Absolventen-Ausbildungen](/blog/blog-article-cooking-dise-part2-apprenticeships)L 347 vom 20.12.2013, S. 671. [Teil: Unzuverlässige Götter](/blog/blog-article-cooking-dise-part3-untrustworthy-gods) für den Hintergrund Dieser Artikel ist der architektonische Überblick und jetzt haben wir eine funktionierende C-Version von : [Meistlucid-.-Botdetektion](/blog/botdetection-introduction).

**Schlüsselbegriffe Verhaltensregeln** Diese Architektur ermöglicht eine neue Kategorie, in der transparente, einstellbare und regelbare Sensoren und Lernsysteme reflexiv den Verkehrsverkehr auf Basis gelernter Verhaltensmuster steuern und nicht statische Regeln regeln. [YARP Gateway](https://hub.docker.com/r/scottgal/mostlylucid.yarpgateway)Bots erreichen nie Ihr Backend oder verwenden die Middleware, um Verhaltensrouting direkt in Ihre App Layer zu erstellen.

[TOC]

## Das Problem: Statische Systeme in einer dynamischen Welt

Für Jahre gebaute Software wie z.B. Clockwork, :Eingänge, ,Ausgänge, ,Regeln, ,Ausleitungen, MSC6Tests, MKS7Ausgänge usw. Alle linearen ,Alle vorhersehbaren .

Aber moderne Systeme, besonders AI--, verhalten sich nicht mehr wie Uhren, sondern wie Ökosysteme,

- Angreifer entwickeln ihre Techniken
- Benutzer ändern ihr Verhalten
- Anforderungen driften über die Zeit
- Die Umwelt verändert sich ständig

Statische Architekturen können ' nicht aufhalten . patch du ein Loch mehr drei erscheinen . tune eine Schwelle , etwas anderes bricht messk5 ey immer reagieren , nie anpassen

**DiSE Architektur** ) behandelt Software, wie Biologen Organismen behandeln, als etwas, das sich selbst anpassen und unter Druck verbessern muss.

## Die Kernidee:-Systeme als sich entwickelnde Organismen

Traditionelle Architektur

```mermaid
flowchart LR
    B[Build] --> S[Ship] --> P[Patch] --> B

    style B stroke:#6366f1,stroke-width:2px
    style P stroke:#ef4444,stroke-width:2px
```

DiSE-Architektur - :

```mermaid
flowchart LR
    P[Perceive] --> E[Evaluate] --> M[Mutate] --> S[Select] --> P

    style P stroke:#10b981,stroke-width:2px
    style M stroke:#f59e0b,stroke-width:2px
    style S stroke:#6366f1,stroke-width:2px
```

Ein DiSE-System hat vier wesentliche Verhaltensweisen

Das Verhalten von |, was es tut, biologische Äquivalente
|-----------|--------------|----------------------|
| **Wahrnehmen** Versammeln Sie Signale aus der Umgebung
| **Bewertung** Anzeige von Signalen gegen Ziele
| **Mutieren** Generieren Sie Varianten von Strategien.Genetische Mutation.
| **Wählen** Bewahren Sie auf, was funktioniert, verwerfen Sie das, was nichts bedeutet, dass die natürliche Auswahl

Dies ist die metaphorische Darstellung von .. Dies ist buchstäblich, wie dein System intelligentere Verhaltensweisen im Laufe der Zeit entwickelt.

## Ein konkretes Beispiel für die Bot-Erkennung

[Meistlucid-.-Botdetektion](https://github.com/scottgal/mostlylucid.nugetpackages/tree/main/Mostlylucid.BotDetection) ist die erste Implementierung von DiSE-Prinzipien die Architektur verfolgen

### Wahrnehmung der Tafelarchitektur

Das System verwendet eine **Tafelorchester** Detektoren tragen zu einem gemeinsamen Zustand bei, indem sie andere Detektore auslösen, während sich Signale ansammeln.

```csharp
// Detectors emit contributions (evidence), not verdicts
public sealed record DetectionContribution
{
    public required string DetectorName { get; init; }
    public required string Category { get; init; }

    // Positive = bot signal, Negative = human signal
    public required double ConfidenceDelta { get; init; }
    public double Weight { get; init; } = 1.0;

    public required string Reason { get; init; }
    public BotType? BotType { get; init; }

    // Signals for triggering other detectors
    public ImmutableDictionary<string, object> Signals { get; init; }
}
```

Mehrere Detektoren laufen **in parallelen Wellen**Jedes trägt ein Stück Beweismaterial bei Das System nimmt die Umgebung durch viele Linsen wahr

```csharp
// Wave 0: All detectors with no trigger conditions run in parallel
// Wave N: Detectors whose triggers are now satisfied run in parallel
while (waveNumber < MaxWaves && !cancellationToken.IsCancellationRequested)
{
    var readyDetectors = availableDetectors
        .Where(d => !ranDetectors.Contains(d.Name))
        .Where(d => CanRun(d, state.Signals))
        .ToList();

    await ExecuteWaveAsync(readyDetectors, state, aggregator, ...);

    // Check for early exit on high confidence
    if (aggregator.ShouldEarlyExit)
        break;
}
```

### Bewertung: Gewichteter Konsens mit Sigmoid

Evidenzaggregate in eine Entscheidung mit sigmoid Transformation Diese richtig nutzt starke Signale von High- ---Gewicht Detektoren

```csharp
private (double botProbability, double confidence) CalculateWeightedScore()
{
    var weighted = _contributions
        .Where(c => c.Weight > 0)
        .Select(c => (delta: c.ConfidenceDelta, weight: c.Weight))
        .ToList();

    var weightedSum = weighted.Sum(w => w.delta * w.weight);

    // Sigmoid maps any real number to (0, 1)
    // Strong human signal (-3) → ~5% bot probability
    // Neutral (0) → 50% bot probability
    // Strong bot signal (+3) → ~95% bot probability
    var botProbability = 1.0 / (1.0 + Math.Exp(-weightedSum));

    return (botProbability, confidence);
}
```

Die Bewertung ist ein einzelnes Modell, das eine Entscheidung trifft. **gewichteter Konsens** über mehrere spezialisierte Detektoren und entscheidend, wenn KI nicht ausgeführt hat. **geklemmt** um übermäßiges Vertrauen zu vermeiden

```csharp
// CRITICAL: Clamp probability when AI hasn't run
var botProbability = aiRan
    ? rawBotProbability
    : Math.Clamp(rawBotProbability, 0.20, 0.80);
```

### Frühzeitige Ausstiegs-:-Schnellwegoptimierung

Das System führt nicht immer alle Detektoren aus, wenn frühe Beweise schlüssig sind.

```csharp
// Early exit on verified bots (good or bad)
public static DetectionContribution VerifiedGoodBot(
    string detector, string botName, string reason) => new()
{
    DetectorName = detector,
    Category = "Verification",
    ConfidenceDelta = 0,
    TriggerEarlyExit = true,
    EarlyExitVerdict = EarlyExitVerdict.VerifiedGoodBot
};
```

In der Produktion **Hohes Vertrauen verlangt Ausgang in unteren 10** nach geradem 2-3-Detektoren stimmen überein.. Die vollständige Pipeline läuft nur für ungewisse Fälle...

### Leistungsschalter für Selbstheilung

Detektoren können fehlschlagen Das System schützt sich selbst

```csharp
// Circuit breaker per detector
private void RecordFailure(string detectorName)
{
    var state = _circuitStates.GetOrAdd(detectorName, _ => new CircuitState());
    state.FailureCount++;
    state.LastFailure = DateTimeOffset.UtcNow;

    if (state.FailureCount >= CircuitBreakerThreshold)
    {
        state.State = CircuitBreakerState.Open;
        // Detector disabled until reset time passes
    }
}
```

Ausgefallene Detektoren sind vorübergehend deaktiviert.Nach einer Abklingzeit haben sie es wieder versucht. **Auswahldruck auf Infrastrukturebene**.

### Das Lernsystem

Wenn das System mit hoher Konfidenz erkennt **lernt** durch Veröffentlichung an den Lernveranstaltungsbus

```csharp
private void PublishLearningEvent(AggregatedEvidence result, ...)
{
    var eventType = result.BotProbability >= 0.8
        ? LearningEventType.HighConfidenceDetection
        : LearningEventType.FullDetection;

    _learningBus.TryPublish(new LearningEvent
    {
        Type = eventType,
        Confidence = result.Confidence,
        Label = result.BotProbability >= 0.5,
        Metadata = new Dictionary<string, object>
        {
            ["botProbability"] = result.BotProbability,
            ["categoryBreakdown"] = result.CategoryBreakdown,
            ["contributingDetectors"] = result.ContributingDetectors
        }
    });
}
```

Dies füttert sich in den Hantelspeicher, um den heuristischen Detektor und die im Laufe der Zeit erlernten Gewichte zu aktualisieren.

## Der Kognitive Stack

Anstelle eines einzigen Gehirns verwendet DiSE geschichtete Kognition.

```mermaid
flowchart TB
    subgraph Fast["Fast Path (< 100ms)"]
        H[Static Heuristics]
        D[Detectors]
        ML[Learned Heuristic Model]
    end

    subgraph Slow["Slow Path (Async)"]
        LLM[Ollama LLM]
    end

    subgraph Learn["Learning Layer"]
        W[Weight Store]
        Rep[Reputation]
    end

    Fast --> |escalate uncertain| Slow
    Slow --> |label| Learn
    Learn --> |update weights| Fast

    style Fast stroke:#10b981,stroke-width:2px
    style Slow stroke:#6366f1,stroke-width:2px
    style Learn stroke:#f59e0b,stroke-width:2px
```

Bestimmungsbeispiel für die Bot-Erkennung
|-------|-------|---------|----------------------|
| **Statische Heuristik** |-<1-|-Instinktive Reaktionen Bekannte Bot UA Muster
| **Detektoren** |<10|Trait-Beobachtung - Header-Analyse - IP-Kontrollen - |
| **Erlernte Heuristische** Logistische Regression mit erlernten Gewichten
| **LLM** Analyse neuartiger Muster
| **Lernen** Hintergrund |-Speicherbildung |-Gewichtsaktualisierungen ,-Reputation verändert |-Speicher

Die wichtigsten Erkenntnisse Das System lernt seine eigenen Gewichte in real--.time... Keine externen ML Modelle erforderlich Der heuristische Detektor beginnt mit vernünftigen Voreinstellungen und entwickelt sich basierend auf Erkennungsfeedback...

> **Zukünftig** ONNX-Modelle mit RAG und Embedding sind für v-2. geplant Das aktuelle heuristische Modell Die Ausgabe dient als gekennzeichnete Trainingsdaten für zukünftiges Modelltraining... Die Architektur hat bereits die -MSC3 genetic , " , Artefakte ,( , Beiträge, Gewichte, , , Signale, die das Hinzufügen von gerichteten synthetischen Evolution einfach machen , MSC9 , es ist als Plugin-Punkt konzipiert ,..

Diese spiegelt die biologische Kognition wider.

- **Angeborenes Immunsystem** Statische Heuristik
- **Adaptives Immunsystem** Gelerntes heuristisches Modell
- **Speicherzellen** Gewicht speichern Reputation

## Der Heuristische Detektor:-Lernen ohne externe Modelle

Hier ist das clevere Bit... Anstatt ein externes ML-Modell zu versenden, lernt das System seinen eigenen Klassifikator mit einfacher logistischer Regression mit dynamischer Features-Extraktion.

```csharp
public class HeuristicDetector : IDetector
{
    // Default weights - sensible starting points
    private static readonly Dictionary<string, float> DefaultWeights = new()
    {
        // Human-like patterns (negative = more likely human)
        ["hdr:accept-language"] = -0.6f,
        ["hdr:referer"] = -0.4f,
        ["fp:received"] = -0.7f,      // Fingerprint = strong human signal
        ["fp:legitimate"] = -0.8f,

        // Bot indicators (positive = more likely bot)
        ["ua:contains_bot"] = 0.9f,
        ["ua:headless"] = 0.8f,
        ["ua:selenium"] = 0.7f,
        ["ua:curl"] = 0.6f,
        ["accept:wildcard"] = 0.4f,
    };

    private (bool IsBot, double Probability) RunInference(Dictionary<string, float> features)
    {
        // Simple linear model: score = bias + Σ(feature * weight)
        float score = _bias;

        foreach (var (featureName, featureValue) in features)
        {
            var weight = _weights.TryGetValue(featureName, out var w)
                ? w
                : DefaultNewFeatureWeight;
            score += featureValue * weight;
        }

        // Sigmoid gives us probability
        var probability = 1.0 / (1.0 + Math.Exp(-score));
        return (probability > 0.5, probability);
    }
}
```

Merkmale werden dynamisch aus der Anfrage und aggregierten Evidenz extrahiert.

```csharp
public static class HeuristicFeatureExtractor
{
    public static Dictionary<string, float> ExtractFeatures(
        HttpContext context,
        AggregatedEvidence evidence)
    {
        var features = new Dictionary<string, float>();

        // Request metadata
        features["req:header_count"] = Math.Min(headers.Count / 20f, 1f);
        features["req:cookie_count"] = Math.Min(cookies.Count / 10f, 1f);

        // Header presence
        features["hdr:accept-language"] = headers.ContainsKey("Accept-Language") ? 1f : 0f;

        // UA patterns (dynamic - only present if detected)
        if (ua.Contains("bot")) features["ua:contains_bot"] = 1f;
        if (ua.Contains("selenium")) features["ua:selenium"] = 1f;

        // Detector results (named by actual detector)
        foreach (var contrib in evidence.Contributions)
            features[$"det:{contrib.DetectorName}"] = contrib.ConfidenceDelta;

        // Client-side fingerprint - STRONG human signal
        if (hasFingerprint)
        {
            features["fp:received"] = 1f;
            features["fp:legitimate"] = 1f;
        }

        return features;
    }
}
```

Neue Funktionen erhalten automatisch Standardgewichte und lernen im Laufe der Zeit Das System entdeckt, was zählt

## Der Gewichtsspeicher – :-Dauerhaftes Lernen

Gewichte bestehen in SQLite und aktualisieren über exponentielle Moving Average.

```csharp
public class SqliteWeightStore : IWeightStore
{
    public async Task RecordObservationAsync(
        string signatureType,
        string signature,
        bool wasBot,
        double detectionConfidence,
        CancellationToken ct = default)
    {
        // EMA update: weight = weight * (1 - α) + new_value * α
        var alpha = 0.1; // Learning rate
        var weightDelta = wasBot ? detectionConfidence : -detectionConfidence;

        var sql = @"
            INSERT INTO learned_weights (signature_type, signature, weight, ...)
            VALUES (@type, @sig, @delta, ...)
            ON CONFLICT(signature_type, signature) DO UPDATE SET
                weight = weight * (1 - @alpha) + @delta * @alpha,
                confidence = MIN(1.0, confidence + @conf * 0.01),
                observation_count = observation_count + 1,
                last_seen = @now
        ";

        await ExecuteAsync(sql, ...);
    }
}
```

Das ist **Mutation durch Beobachtung**Jede Detektion lehrt das System etwas......... im Laufe der Zeit.... die Gewichte konvergieren zu optimalen Werten für Ihre spezifischen Verkehrsmuster....

## Halluzination als Mutation

LLM Halluzination ist ein Fehler, der das Generative Substrat der Evolution darstellt.

Eine Hochtemperatur-LLM, die zehn Varianten einer Detektionsregel vorschlägt, ist die '. **Mutation des Genoms** von dem System

```csharp
public async Task<List<DetectionRule>> GenerateMutationsAsync(DetectionContext context)
{
    var prompt = $"""
        Given this traffic pattern:
        {JsonSerializer.Serialize(context)}

        Generate 5 variant detection rules that might catch similar patterns.
        Return JSON array of rules with: pattern, weight, confidence.
        Be creative. Some variants should be strict, some lenient.
        """;

    var response = await _ollama.GenerateAsync(new GenerateRequest
    {
        Model = "gemma3:1b",
        Prompt = prompt,
        Options = new RequestOptions { Temperature = 0.9 } // High creativity
    });

    return ParseRules(response.Response);
}
```

Die Mutationen werden dann gegen historische Daten ausgewertet.

```csharp
public async Task<DetectionRule?> SelectFittestAsync(
    List<DetectionRule> mutations,
    List<LabeledRequest> testData)
{
    var results = new List<(DetectionRule Rule, double Fitness)>();

    foreach (var rule in mutations)
    {
        var tp = testData.Count(r => rule.Matches(r) && r.IsBot);
        var fp = testData.Count(r => rule.Matches(r) && !r.IsBot);
        var fn = testData.Count(r => !rule.Matches(r) && r.IsBot);

        // F1 score as fitness
        var precision = tp / (double)(tp + fp);
        var recall = tp / (double)(tp + fn);
        var f1 = 2 * (precision * recall) / (precision + recall);

        results.Add((rule, f1));
    }

    return results.OrderByDescending(r => r.Fitness).First().Rule;
}
```

Nur der Fittest überlebt bis zur Produktion, das verwandelt LLMs von spröden Chatbots in **evolutionäre Betreiber**.

## Die Genome-:-Policy-Konfiguration

Im Zentrum von DiSE steht die **Politisches System** Benannte Konfigurationen, die definieren, wie sich Detektion verhält

```json
{
  "Policies": {
    "fastpath": {
      "Description": "Fast path + Heuristic for sync decisions",
      "FastPath": ["UserAgent", "Header", "Ip", "Behavioral", "ClientSide", "Inconsistency", "VersionAge"],
      "AiPath": ["Heuristic"],
      "EscalateToAi": true,
      "EarlyExitThreshold": 0.15,
      "ImmediateBlockThreshold": 0.90,
      "Weights": {
        "ClientSide": 0.2,
        "Heuristic": 1.5
      },
      "Transitions": [
        { "WhenRiskExceeds": 0.5, "WhenRiskBelow": 0.85, "GoTo": "demo" }
      ]
    },
    "demo": {
      "Description": "Full pipeline sync for demonstration",
      "FastPath": [],
      "AiPath": [],
      "BypassTriggerConditions": true,
      "ForceSlowPath": true
    }
  }
}
```

Richtlinien definieren

- **FastPath-Detektoren** --Lauf in parallelen ,-Unterläufen
- **KI-Weg** Weitere Informationen sind abrufbar unter: http://europa.eu.int/en/comm/index_de.htm
- **Schwellenwerte** Wenn zum frühen Ausgang, wenn zum Blockieren
- **Übergänge** Automatische Eskalation auf andere Politikbereiche, wenn unsicher
- **Gewichte der Politik** Bedeutung des Tune-Detektors pro Anwendungsfall

Das System kann **übergang zwischen politiken mittel--**Unsichere Fastpath-Ergebnisse eskalieren zur kompletten Demo-Pipeline **adaptives Routing** Das Genom reagiert auf Evidenz in Echtzeit

Du verschiffst statische Konfigurationen **Verhaltensarten** die sich an den Verkehr anpassen

## Fitness-Funktionen - Was übertrifft

Jedes DiSE-System optimiert sich gegen eine Fitnesslandschaft

```csharp
public class FitnessEvaluator
{
    public double Evaluate(GenomeConfig genome, EvaluationData data)
    {
        var fpRate = data.FalsePositives / (double)data.TotalHumans;
        var fnRate = data.FalseNegatives / (double)data.TotalBots;
        var latency = data.P99LatencyMs;
        var cost = data.AiCallsPerRequest * _config.CostPerAiCall;

        // Multi-objective fitness
        return 1.0
            - (fpRate * _config.FalsePositivePenalty)   // Don't block humans
            - (fnRate * _config.FalseNegativePenalty)   // Don't miss bots
            - (latency / _config.MaxLatencyMs)          // Stay fast
            - (cost / _config.MaxCostPerRequest);       // Stay cheap
    }
}
```

Wir optimieren nicht für Genauigkeit allein **Überleben in einer dynamischen Umgebung**.

Zu viel KI hohe Kosten
Zu wenig KI schlechte Erkennung von neuartigen Angriffen
Zu aggressive falsche Positive, zu wütende Nutzer
Zu nachgiebige Bot-Überflutungen (MSK)

Das System muss ein stabiles Gleichgewicht finden.

## KI als Lehrer, nicht als Arbeiter

Ein ausgereiftes DiSE-System verschiebt KI aus dem heißen Pfad

```mermaid
flowchart TB
    subgraph Early["Early Stage"]
        AI1[AI handles most cases]
    end

    subgraph Middle["Middle Stage"]
        AI2[AI handles edge cases]
        H1[Heuristics handle common cases]
    end

    subgraph Mature["Mature Stage"]
        AI3[AI teaches and mutates]
        H2[Heuristics handle almost everything]
        M[Memory provides context]
    end

    Early --> Middle --> Mature

    style Early stroke:#ef4444,stroke-width:2px
    style Middle stroke:#f59e0b,stroke-width:2px
    style Mature stroke:#10b981,stroke-width:2px
```

Im Laufe der Zeit

- Statische Detektoren verbessern durch AI-Labels trainiert
- Heuristiken erhalten genauere Auslese durch Fitness.
- KI behandelt nur Neuheit und Mutation

KI wird zu Â:

- Das **Orakel** für neuartige Verhaltensweisen
- Das **Generator** von Mutationen
- Das **Driftmelder**
- Das **Lehrer** dass Borderline-Fälle gekennzeichnet sind

Keine Runtime-Abhängigkeit...... Adaptives Gerüst..

## Verhaltensrouting - Eine neue Kategorie

Mit der [YARP Gateway](https://hub.docker.com/r/scottgal/mostlylucid.yarpgateway)Diese Architektur ermöglicht etwas Neues. **Verhaltensführung**.

Traditionelles Routing ist statisch.:-Pfad Backend: .-Behavioural-Routing ist reflexiv.:-Verkehrseigenschaften dynamische Routing-Entscheidungen

```mermaid
flowchart LR
    subgraph Gateway["YARP Gateway"]
        D[Detector Team]
        P[Policy Engine]
        R[Router]
    end

    Traffic[Traffic] --> D
    D --> P
    P --> R
    R -->|Human| App[Your App]
    R -->|Bot| Block[403]
    R -->|Uncertain| Challenge[Challenge]
    R -->|Learning| Queue[Async Analysis]

    style Gateway stroke:#10b981,stroke-width:2px
```

Die wichtigsten Konzepte

- **Detektorteams** Konfigurierbare Gruppen von Detektoren, die zusammen arbeiten.
- **Transparente Entscheidungen** Jede Routing-Entscheidung ist erklärbar.
- **Reflexive Anpassung** Das System lernt aus seinen Entscheidungen und passt die Gewichte im Laufe der Zeit an
- **Kantenschutz-** Bots erreichen nie Ihr Backend, blockiert am Router.

Das ist gerade "bot-Erkennung an der Kante - ' ist ein neues, primitives Routing, bei dem Verkehrsströme durch gelernte Verhaltensmuster geformt werden - nicht nur statische Regeln - .

## Warum das so wichtig ist

Die meisten Ingenieurkulturen fürchten sich

- Nichtdeterminismus
- Drift
- Mutation
- Halluzination
- Emergentes Verhalten

DiSE verwendet diese als **Baustoffe**.

Statische Systeme sterben an sich entwickelnden Systemen

Jede Industrie, die sich mit Gegnern befasst, wird Architekturen wie diese brauchen.

- Bot-Erkennung
- betrügerische Motoren
- Adaptive Firewalls
- LLM-Ökosysteme
- Selbstoptimierende Mikroservices
- Autonome Debugging-Systeme
- **Verhaltensführung** Verkehrsgestaltung auf der Grundlage gelernter Muster

## Was DiSE ist?

Lassen Sie mich klar sein, was das ist.

- **Nicht überall große LLMs** Die LLMs sind teuer. Verwenden Sie sie strategisch.
- **Nicht ersetzen Sie die Geschäftslogik mit AI.".** Die Heuristik ist schneller und vorhersehbarer.
- **Das System läuft nicht wild.** Die Evolution wird gerichtet, die ,, begrenzt, die,, regiert, die .,
- **Nicht auf Steroiden autoML** Hier geht es um Verhalten... nicht nur Modelltuning...

DiSE wird kontrolliertErklärbare Evolution

- Gebunden durch Einschränkungen
- Gesteuert durch explizite Fitnessfunktionen
- Speicher--.awaren
- versioniert
- Sicherer Einsatz

Es handelt sich um *gerichtet* Entwicklung - Führung - nicht zufällig

## Versuch es.

[Meistlucid-.-Botdetektion](https://www.nuget.org/packages/mostlylucid.botdetection/) setzt diese Prinzipien um

```bash
dotnet add package Mostlylucid.BotDetection
```

```csharp
builder.Services.AddBotDetection();
app.UseBotDetection();
```

Konfigurieren Sie für die Produktion mit Learning Enabled

```json
{
  "BotDetection": {
    "BotThreshold": 0.7,
    "Policies": {
      "default": {
        "FastPath": ["UserAgent", "Header", "Ip", "Behavioral", "ClientSide", "Inconsistency", "VersionAge"],
        "AiPath": ["Heuristic", "Llm"],
        "EscalateToAi": true,
        "EarlyExitThreshold": 0.85
      }
    },
    "AiDetection": {
      "Provider": "Heuristic",
      "Heuristic": {
        "Enabled": true,
        "LoadLearnedWeights": true,
        "EnableWeightLearning": true,
        "LearningRate": 0.01
      }
    }
  }
}
```

Beobachten Sie, dass es sich entwickelt Der heuristische Detektor lernt von jeder Anfrage.

## Schlußfolgerung

DiSE Architecture ist der Wechsel von Software als Maschinen zu Software als Organismen

Es ist die Architektur von -:

- Anpassungsfähigkeit
- Resilienz
- Kontrollierte Entwicklung
- Mehrschichtige Wahrnehmung
- Memory---getriebenes Lernen
- Anmutung Auswahl
- Strategisches Verhalten

Statische Architekturen können mit dynamischen Umgebungen nicht Schritt halten..-Angriffe entwickeln sich..-Anwender entwickeln sich weiter.

Systeme müssen sich auch weiterentwickeln

Wenn du Systeme willst, die nur laufen, dann baue sie auf die alte Art.
Wenn Sie Systeme, die **überleben** Bauen Sie sie mit DiSE-.