# Кухня з DiSE ( Частка МSK1 Збудові системи, які вчаться МSK2 Пристосовуються , і розвиваються

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

Більшість програмних архітекторів вважають, що система статична

> **Nota:** Це частина 4 з серії "Cooking with DiSEM SK2 МSK3 Погляньте [Частина 1](/blog/semantidintelligence-part1), [Час 2: Окончате навчання](/blog/blog-article-cooking-dise-part2-apprenticeships), і [Частина 3: Ненадійні Боги](/blog/blog-article-cooking-dise-part3-untrustworthy-gods) для фона. Цей artykuł - це архітектурний огляд МSK1, а тепер ми маємо працюючу програму CM SK2 [найбільш зрозуміле.botdetection](/blog/botdetection-introduction).

**Найголовніша концепція: Руйтинг поведінкиM SK1** Ця архітектура дає можливість створити нову категорію -, де прозорі МSK1 пристосовні МSK2 команди " детекторів та систем навчання рефлікційно об 'єднують рух на основі з' ясованих моделей поведінки [Перехідник YARP](https://hub.docker.com/r/scottgal/mostlylucid.yarpgateway), Bots never reach your backend . Or use the middleware to build behavioural routing directly into your app layer

[TOC]

## Проблема: Статичні системи у динамічному світі

Протягом багатьох років ми створили програмне забезпечення на кшталт часового графіку. Введення і виведення. Виведення і вихід. Правила. Трубопроводи. Тести. Розгортання. Всі лінійні. Усі передбачувані.

Але сучасні системи, особливо штучний інтелект, збільшені, більше не поводяться як годинники. Вони поводяться, як екосистеми.

- Атакатори змінюють свої методи
- Пользовачі змінюють свою поведінку
- Требування змінюються з часом
- Середовище постійно змінюється

Статичні архітектори не можуть keep up . МСК1 , patch one hole "," , three more appear

**Архітектура DiSE** (Рейденційна синтетична еволюція ) ставиться до програмного забезпечення так само, як біологи ставляться до організмів МSK2 як до чогось, що має адаптуватися MSC3 себе M SK4 виправляти , і покращуватись під тиском MST6

## Основна ідея – : – системи, які розвиваються

Традиционна архітектура:

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

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

Система DiSE має чотири основні поведінки:

| Застосування МSK1 Що він робить МSK2 Біологічний еквівалент |
|-----------|--------------|----------------------|
| **Усвідомити** | Збирати сигнали з навколишнього середовища
| **Оцінювати** | Сигнали відбитків проти голів МSK1 Нервова система МSK2
| **Мутати** | генерувати варіативи стратегії | Генетична мутація МSK2
| **Вибрати** | Утримуйте те, що працюєM SK1 відкидайте те, чого не працює 't МSK3 Природний відбір МSK4

Це не метафора, це те, як ваша система з часом розвивається у розумнішій формі

## Конкретний приклад: Виведення котла

[найбільш зрозуміле.botdetection](https://github.com/scottgal/mostlylucid.nugetpackages/tree/main/Mostlylucid.BotDetection) є першим C# втіленням принципів DiSE

### Перцепція: Архітектура чорних столів

Система використовує **черниковий оркестр** - детектори дають докази спільного стану , активізують інші детекторі, коли сигнали накопичуються МSK2

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

Багато детекторів запускаються **в паралельних хвилях**. Кожна з них додає певного шматка доказів . Система сприймає навколишнє середовище за допомогою багатьох лінз

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

### Оcena: Взвешений консенсус з сигмоїдом

Докази об 'єднуються у рішення, використовуючи сигмоїдну трансформацію - це правильно підштовхує сильні сигнали з високого МSK1важких детекторів МSK2

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

Оцінка не є єдиною моделлю, яка приймає рішення **важливий консенсус** через численні спеціалізовані детектори - і, головне ,, коли штучний інтелект не мав МSK2 не запускав МSK3 ймовірність **встромлений** щоб уникнути надмірної впевненісті:

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

### Учасний вихід: Оптимізація швидкого шляху

Система не запускає усіх детекторів

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

В produkcji, **високий-запроси довіри виходять під M SK1ms** після того, як тільки 2-3 детектори згодні МSK1 Полна труба працює лише в невизначних випадках

### Маршрутні розривники: СамовідтворенняM SK1Healing

Детектори можуть не працювати. Система захищає себе:

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

Невдачі детектори тимчасово вимкнені. Після похолодженняM SK1 вони' спробували ще раз (halfМSK4открий станMSC5 Це **тиск вибору на рівні інфраструктури**.

### Мутація: Система навчання

Коли система визначає з великою впевненістю, це **вчиться** шляхом публікації на уроковий автобус:

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

Це feds into the weight store , updating the heuristic detector' learned weights over timeM SK2

## Когнітивна база

Натомість одного мозку "AIM SK1 DiSE використовує шарову когніцію

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

| Слой МSK1 Швидкість МSK2 Задача | До прикладу виявления Bot
|-------|-------|---------|----------------------|
| **Статична гавритика** | МSK1ms МSK2 Інстинктивні реакції | Знані моделі UA для роботів
| **Детектори** МSK0 <10ms МSK2 Обстеження траєкторії | Аналитика заголовків
| **Вивчений герістичний** МSK0 1-5ms МSK2 Динамічна класифікація | Логічна регресія з засвоєними вагими
| **ЛЛМ** МSK0 50-500ms | Глибоке обґрунтування МSK3 Анализ нових моделей мSK4
| **Навчання** | Фонґл МSK1 Формування пам 'яті МSK2 Обновлення ваги , зміни репутації M SK4

Найголовніша ідея: система вивчає свої власні вага в реальному часіМSK1 timі МSK2 Ніяких зовнішніх моделей МЛ не вимагаєтьсяM SK3 Хирystyczny детектор починає з розумних початкових показників та розвивається на основі зворотнього зв 'язку від детектора .

> **Майбутнє:** Моделі ONNX з RAG та вмонтуванням заплановані для v2. Текуча геристична модель ' її вихідні дані служать як ярлики тренування для майбутніх тренувань моделей МSK2 Архітектура вже має M SK3 генетичні artefakти M SK4 М SK5 вклади МSK6 вагами \ , сигнали \), які роблять доdanie напряму синтетичної еволюції простим.

Це відображає біологічне пізнання:

- **Вроджена імунна система** → Статична гуристика
- **Пристосована імунна система** → Зрозуміла эвристичні моделі
- **клітини пам 'яті** → Весовий магазин МSK1 репутація

## Хирічний детектор: Навчання без зовнішніх моделей

Тут – МСК0 – це розумний біт, МСК1 – замість відправлення зовнішнього ML-модуля, МSK2 – система вивчає власний класифікатор, використовуючи просту логістичну регресію з динамічним виділенням властивостей.

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

Функції динамічно виділяються з запиту та сукупних доказів:

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

Нова функція автоматично отримує початкову вагу і з часом вчиться.. Система відкриває, що має значення

## В магазині для худоби: Простійне навчання

Вагу зберігається в SQLite і оновується через експоненційну середню руханість:

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

Це **мутація через спостереження**. Кожна розпізнавання вчить систему чогось . З часом МSK2 веси сходяться до оптимальних показників для ваших конкретних дорожніх маршрутів МSK3

## Галюцинації як мутація

У DiSE галюцинація LLM не є багом, а генеруючим субстратом еволюції.

високий LLM з температурою 0 °С, який пропонує десять варіантів правила виявлення не є галюцинаційним **мутація генома** системи:

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

Потім мутації оцінюються на основі даних з історії:

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

Лише найкращі з них виживають до виробництва. Це перетворює LLM на **еволюційних операторів**.

## Konfiguracja на основі геному

В центрі DiSE знаходиться **політична система** - названі конфігурації, які визначають поведінку детектора

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

Політики визначають:

- **детектори FastPath** - запускає паралельно , під МSK2 ms
- **Шлях штучного інтелекту** - Хирystyczny (1-5msM SK2 і МSK3, або LLM МSK4 ms+)
- **Тривалість** - коли піти на ранній вихідM SK1 коли заблокувати
- **Переходи** - автоматична ескалація до інших політиків, коли невідомо
- **У відсотках на -** - важливість детектора музики для кожного випадку

Система може **перехід між політиками на середину**. Невизначні результати швидкого переходу зростають до повної демонстрації **адаптивна маршрутизація** - геном реагує на докази в реальному часі

Ви не маєте't відправляти статичні конфигураціїM SK1 Ви відправляєте **застосовані види** що адаптуються до руху.

## Функції фітнесу: Що виживає

Кожна система DiSE оптимізується під час тренування:

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

Ми не оптимізуємо лише для точності **виживання в динамічному середовищі**.

Надто багато штучного інтелекту → високі витрати , погана затримка МSK2
Надто мало штучного інтелекту → погано розпізнавати нові атаки .
Надто агресивний → хибні позитивиM SK1 роздратовані користувачі.
Надто гнучкий → затоплення дротівM SK1

Система повинна знаходити стабільне рівновагу. тиск спричиняє еволюціюM SK1

## штучний інтелект як вчитель

Зріла система DiSE переводить штучний інтелект з гарячого шляху:

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

З часом:

- Статичні детектори покращують
- Геуристика стає точнішою (вибрана в залежності від пристосованостіM SK1
- штучний інтелект керує лише нововведенням та мутацією

штучний інтелект стає:

- І **оракль** для нових способів поведінки
- І **генератор** мутацій
- І **детектор дрейфу**
- І **вчитель** що позначає кордонні випадки

Не залежність від часу запуску. Адаптивні скелі.

## Руйтинг поведінки: Нова категорія

З [Перехідник YARP](https://hub.docker.com/r/scottgal/mostlylucid.yarpgateway), ця архітектура дає можливість створити щось нове **поведінкова маршрутизація**.

Традиційне маршрутизування є статичним: шляхом M SK1 зворотньою системою . Реакційно-руйтинговий маршрутізування є рефлексивним: характеристиками руху МSK4 динамічними рішеннями щодо маршрутізаціїMSC5

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

Ключові поняття:

- **Команди детекторів** - конфігуровані групи детекторів, які працюють разом , врегулювані за політикою
- **Прозорі рішення** - кожне рішення щодо маршрутізації можна пояснити МSK1 бачите ventilation вкладу МSK2
- **Рефлікційне налаштування** - система вчиться від своїх рішень і з часом змінює навантаження
- **Утримка решітки** - Bots never reach your backend ; blocked at the router

Це не лише ' не тільки " виявлення робота на краю \." це МSK3 новий примітивний маршрутинг, де потоки руху формуються за допомогою вчилих моделей поведінки \ , \ а не лише статичних правил \ МSK5\

## Чому це важливо

Більшість інженерних культур бояться

- Нондетермінізм
- Рух
- Мутація
- Галюцинація
- Невідкладна поведінка

DiSE використовує їх як **будівельні матеріали**.

Статичні системи зникають. Еволюційні системи виживають .

Кожна індустрія, яка працює з опонентами - drift ,, , чи масштабний тиск - врешті-решт потребує такої архітектури

- Розпізнавання Bot
- Мотори шахрайства
- Адаптивні стіни
- Екосистеми LLM
- Саморобна оптимізація мікросервисів
- Автономні системи розладів
- **Руйтинг поведінки** - формування дорожнього руху на основі вчиних шаблонів

## Що таке DiSE?

Дозвольте мені пояснити, що це таке

- **Не так. "великі LLM всюдиM SK1** - LLM дорого коштує . Використовуйте їх стратегічно
- **Не "замінювати логіку бізнесу з допомогою штучного інтелекту** - Геуристика швидша і більш передбачувана
- **Не "оставить систему працювати безладноM SK1** - еволюція спрямована , обмежена МSK2 управляється
- **Не "AutoML на стероидахM SK1** - Йдеться про поведінку , не тільки про налаштування моделей M SK2

DiSE контролюється, поясняюча еволюціяM SK1

- Обмежені обмеженнями
- керовані явною функцією пристосованості
- Пам 'ять-свідомий
- Версії
- Безпека для використання

МSK0 *спрямований* еволюція - орієнтованаM SK1 не випадкова.

## Попробуйте

[найбільш зрозуміле.botdetection](https://www.nuget.org/packages/mostlylucid.botdetection/) реалізує ці принципи:

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

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

Сконфигурувати для виробництва з вправою навчання:

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

Дивіться, як він розвивається.

## Завершення

Архітектура DiSE - це перехід від програмного забезпечення як машини до програмного обеспечения як організми

Це архітектура

- Пристосованість
- Реsiliентність
- Керована еволюція
- Подібне пізнання
- Пам 'ять-революційне навчання
- Вибір мутацій +
- Стратегичне ставлення

Статичні архітектори не можуть впоратися з динамічними середовищами. Атакуючі еволюціонують . Gebruikачі еволюцують МSK2 Побажання еволюції M SK3

Системи мусять розвиватися також.

Якщо ви хочете, щоб системи просто працювали, будуйте їх так, як раніше
Якщо ви хочете **вижити** - збудувати їх за допомогою DiSE