# Matlagning med DiSE (Teil | 4): | Byggnader som lär sig

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

De flesta mjukvaruarchitekturer antar att systemet är statiskt. DiSE antar att det är levande

> **Nota:** Det här är en del 4 i | " | Matlagning med DiSE | " | serie | МSK3 | se [Del 1](/blog/semantidintelligence-part1), [Del 2: Högskoleutbildningar](/blog/blog-article-cooking-dise-part2-apprenticeships), och [Del 3: Götter som inte kan lita på](/blog/blog-article-cooking-dise-part3-untrustworthy-gods) för bakgrunden. Den här artikeln är en överblick på arkitekturen | - | och nu har vi ett fungerande C implementering [mestlucid.botdetection](/blog/botdetection-introduction).

**Nyckelkoncepten: Behavioural Routing** Den här strukturen gör det möjligt att skapa en ny kategori - där detektorer och lärande system som är transparenta , anpassningsbara | " | lag | МSK3 | reflektivt riktar trafiken baserat på lärda beteendemönster |, | inte statiska regler | [YARP Gateway](https://hub.docker.com/r/scottgal/mostlylucid.yarpgateway), Boter når aldrig din baksida . Eller använda mellanvaran för att bygga beteendetsriktning direkt in i din app-skikt

[TOC]

## Problemet: Statiska system i en dynamisk värld

I åratal har vi byggt program som clockwork . :: ingångar, ,: utgångar ,: regler ,: pipelines ,: tester ,: utloperningar .: allt linjärt ,: allt förutsägbart .:

Men moderna system, speciellt AI, - och upphöjda system, -, beter sig inte längre som klockor. ., de beter sig som ekosystem

- Attacker utvecklar sina tekniker
- Användare ändrar sitt beteende
- Benötningarna drivs över tid
- Miljön förändras konstant

Statiska arkitekturer kan inte hålla upp.

**DiSE arkitektur** (Inriktade syntetisk evolution ) behandlar mjukvara på samma sätt som biologer behandlar organismer : som något som måste anpassa sig, , själv, - korrigera, M SK5 och förbättras under tryck, MSC6

## System som utvecklar sig

Traditionell arkitektur:

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

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

Ett DiSE-system har fyra grundläggande beteenden

| Att bete sig | Vad det gör
|-----------|--------------|----------------------|
| **Förefatta** | Samma signaler från omgivningen
| **Ävärdera** | Punktsignaler mot mål | Nervous system |
| **Mutat** | Generera varianter av strategier
| **Välj** | Säg vad som fungerar, Släng vad som inte fungerar 't | Naturell urval M|

Detta är inte en metafor. Det här är bokstavligen hur ditt system utvecklar smartare beteenden över tid.

## Ett konkret exempel: Bot-detektor

[mestlucid.botdetection](https://github.com/scottgal/mostlylucid.nugetpackages/tree/main/Mostlylucid.BotDetection) är den första implementeringen av DiSE: s principer

### Perception: Blackboard-arkitekturen

Systemet använder **blackboard orchestrator** - detektörer bidrar till bevis för ett gemensamt tillstånd , som utlöser andra detektoren när signaler samlas in

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

Flera detektörer körs **i parallella vågor**. Var och en bidrar med en del bevisM SK1 Systemet uppfattar miljön genom många linser

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

### Evaluation: Weighted Consensus with Sigmoid

Evidens aggregeras till ett beslut som använder sig av sigmoidtransformation - det lever ordentligt på starka signaler från höga -viktdetektor

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

Utvärderingen är "'", inte en enda modell som fattar beslut. **gewichtad konsensus** över flera specialiserade detektörer - och i synnerhet **bestämd** för att undvika övertygelse

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

### När man går ut tidigt: Optimering av en snabb väg

Systemet sätter inte alltid alla mätare igång. När tidiga bevis är slutgiltiga kommer det ut snabbt.

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

I produktion, **höga -förtroende begäran kommer ut under 10ms** efter att detektorerna har kommit överens om 2-3 . Hela pipelinen kör bara i osäkra fall

### Omloppsbrytare : Själva-Healing

Detektorer kan misslyckas. Systemet skyddar sig själv

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

Misslyckade detektörer är tillfälligt avstängda. Efter en kylning , provades de igenM SK2 (halfMSC4öppningslägen ). Det här är **urvaltrycket på infrastrukturnivå**.

### Mutation: Lärningssystemet

När systemet detekterar med hög trovärdighet **lär sig** genom att publicera den lärande händelsebussen:

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

Detta matas in i viktsbutiken.

## Den kognitiva stapeln

Istället för ett enda "AI-hjärna

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

| lager | hastighet | syfte | Bot-detektor Exempla M|
|-------|-------|---------|----------------------|
| **Statisk heuristik** | <1ms | Instinktiva reaktioner M| Bekant robot UA-mönster МSK4
| **Detektorer** | <10ms | | | Bevakning av spår | МSK3 | Headeranalys |, | IP-kontroller |
| **Bekant heuristik** | 1-5ms | | | Dynamisk klassificering | МSK3 | Logistisk regress med lärda vikter |
| **LLM** | 50-500ms | | | djupt resonemang | | | analysera nya mönster |
| **Att lära sig** | Historisk bakgrund | | | minnesbildning || | viktuppdateringar | МSK3 | ryktesförändringar

Den viktigaste insikten : systemet lär sig sina egna vikter i realtid-time. Ingen extern ML-modeller är nödvändigaM SK3 Detektorn börjar med vettiga standard och utvecklas baserat på detektionsfeedback

> **Framtiden:** ONNX-modeller med RAG och embedding är planerade för v2. Den nuvarande heuristiska modellen 's utgång fungerar som etiketterade utbildningsdata för framtida modellutbildningar . Architekturen har redan M SK3genetiska" artefakter (kollektiviteterMST6 vikter MST7 signalerMst8 som gör att lägga till riktad syntetisk evolution enkelt Mst9 det M st10 designat som en pluginpunkt

Detta speglar den biologiska kognitionen

- **Innat immunsystem** → Statisk heuristik
- **Adaptiv immunsystem** → Lärde sig hururistisk modell
- **minnesceller** → Weight store + rykte

## Heuristikdetektorn: lärande utan externa modeller

Här är "'", det smarta bitet. "." Istället för att skicka ut en extern ML-modell, , lär systemet sig sin egen klassifier genom att använda enkel logiskt regress med dynamisk dragning av dragningar.

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

Mönster extraheras dynamiskt från begäran och sammanlagda bevis:

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

De nya egenskaperna får automatiskt standardvikten och lär sig över tid. Systemet upptäcker vad som spelar roll

## Weight Store: Uthålligt lärande

Weights förblir i SQLite och uppdaterar sig via exponentiell rörande medel

```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, ...);
    }
}
```

Det här är **mutation genom observation**. Varje detektion lär systemet något

## Hallucinationer som mutation

I DiSE är LLM-hallucinationerna inte en bug, det är det som skapar evolutionen.

Ett LLM med hög temperatur som föreslår tio varianter av detektorregler är **att mutera genomet** av systemet:

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

Mutationerna bedöms sedan mot historiska data:

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

Bara de mest anpassade överlever till produktionen. Detta omvandlar LLM från britta chatboter till **evolutionära operatörer**.

## Genomet- -policyn- ---baserad Konfiguration

I centrum av DiSE finns **policysystem** - namnliga konfigurationer som definierar hur detektorn beter sig

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

Politier definieras:

- **FastPath-detektorer** - kör i parallella sträckorM SK1 under -10 ms
- **AI-stigen** - Heuristiska 1-5msM SK2 och / eller LLM M500ms
- **tröskeln** - när man ska gå ut tidigt , när jag ska blockera
- **Transitioner** - Automatisk upphöjning till andra regler när det är osäkra
- **Politiska vikter per -** - stämmandetektor vikt per användandefall

Systemet kan **övergång mellan policyer mitt i "-", begäran**. Osäkerhetsfulla framsteg i framstegen till full demo **anpassningsriktering** - reagerar genomet på bevis i realtid

Du shipar inte statiska konfigurationer **beteendemässiga arter** som anpassas till trafiken.

## Fitnessfunktioner : Vad överlever

Varje DiSE-system optimerar sig mot ett hälsorikt landskap:

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

Vi optimerar inte enbart för noggrannhet. **överlevnad i en dynamisk miljö**.

För mycket AI → hög kostnad , dålig latens
Alltför lite AI → dålig upptäckt av nya attackerM SK1
Alltför aggressivt → falska positiver , arga användare.
Alltför ödmjuka → robotutbrott

Systemet måste hitta ett stabilt jämvikt

## AI som lärare , Inte arbetskraft

Ett mogna DiSE-system flyttar AI ur den varma vägen:

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

Över tid:

- Statiska detektörer förbättrar (instruerade av AI-labellar
- Heuristiken blir mer precisa (selected by fitness )
- AI hanterar bara nymodighet och mutationer

AI blir:

- Den **orakel** för nya beteenden
- Den **generator** av mutationer
- Den **driftdetektor**
- Den **lärare** som märker gränsfall

Inte en starttids beroende. Adaptiv byggnadsställning

## Behavioural Routing: En ny kategori

Med [YARP Gateway](https://hub.docker.com/r/scottgal/mostlylucid.yarpgateway), den här arkitekturen gör det möjligt att skapa något nytt **beteendemässig vägledning**.

Den traditionella routen är statisk: bana → baksida M SK2 Behavioural routing is reflexive

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

De viktigaste koncepten:

- **Detektorteam** - konfigurerade grupper av detektor som arbetar tillsammans , anpassningsbara per policy
- **De transparenta besluten** - varje routingstillstånd är upplägsen  se bidragsfördelningen
- **Reflexivjustering** - systemet lär sig av sina beslut och justerar vikter över tid
- **Edge-nivåskydd** - robotar når aldrig din baksida ; blockerad vid routern

Det här är inte bara "'", det är en ny routing primitiv där trafikflöden formas av lärda beteendemönster, utan bara statiska regler.

## Varför det här spelar roll

De flesta teknikkulturer är rädda

- Nondeterminism
- Drift
- Mutation
- Hallucinationer
- Kritsiga beteenden

DiSE använder dessa som **byggmaterial**.

Statiska system dör. Utvecklingssystem överleverM SK1

Alla industrier som handskas med motståndare kommer i slutändan behöva sådana arkitekturer

- Bot-detektor
- Fraudmotorer
- Adaptiva firewalls
- LLM ekosystem
- Self-optimera mikrotjänster
- Autonoma debuggingssystem
- **Behavioural routing** - trafikstrukturering baserat på lärda mönster

## Vad är DiSE?

Låt mig förklara vad detta är.

- **Inte " stora LLMs överallt "** - LLM är dyra . Använd dem strategiskt
- **Inte " som ersätter affärslogiken med AI** - Heuristiken är snabbare och mer förutsägbar
- **Inte "släpper systemet att köra wild** - Evolutionen är riktad , begränsad M SK2 styrd
- **Inte "AutoML på steroider** - Det här handlar om beteendet , inte bara om modelljustering

DiSE är kontrollerad

- Omringad av begränsningar
- styrd av explicita passformsfunktioner
- minnet - vet
- Versionerade
- Bevarad att användas

It's *riktad* evolution - styrdM SK1 inte slumpmässigt .

## Försök det

[mestlucid.botdetection](https://www.nuget.org/packages/mostlylucid.botdetection/) implementerar dessa principer

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

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

Konfigurera för produktion med lärande aktiverat:

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

Titta på hur den utvecklas.

## Slutsatsen

DiSE-Architektur är att byta från mjukvara som maskiner till programvara som organismer

Det är "'" som är arkitekturen för ":".

- Anpassningsförmåga
- Robusthet
- Kontrollerad evolution
- Layerad kognition
- minnet-driven lärande
- Utveckling + urval
- Strategiskt beteende

Statiska arkitekturer kan inte hålla i nivå med dynamiska miljöer. Attikare utvecklas . Användare utvecklas

System måste utvecklas också.

Om du vill ha system som bara körs
Om du vill ha system som **överleva** - bygga dem med DiSE