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, Del 2: Högskoleutbildningar, och Del 3: Götter som inte kan lita på för bakgrunden. Den här artikeln är en överblick på arkitekturen | - | och nu har vi ett fungerande C implementering mestlucid.botdetection.

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, Boter når aldrig din baksida . Eller använda mellanvaran för att bygga beteendetsriktning direkt in i din app-skikt

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:

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:

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

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

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

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

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

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

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

// 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:

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

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

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.

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:

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

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:

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:

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

{
  "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:

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:

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

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 implementerar dessa principer

dotnet add package Mostlylucid.BotDetection

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

Konfigurera för produktion med lärande aktiverat:

{
  "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