# Стримані неяскраві MoM: Сигнальні контракти через Agent Chatter

<!-- category -- AI,Patterns,Architecture,LLM,DiSE -->
<datetime class="hidden">2026-01-06T15:00</datetime>

[Частина 1](/blog/constrained-fuzziness-pattern) описана трубопроводом: СубстратM SK1 Пропонент, КонстрейнаторMSC3 Один можливий компонентМSK4 обмежений детерміністичною правдою .

Але що трапляється, коли *численні* proposers? Множество LLM ? Моделі візуалізації, які спілкуються з текстовими моделями

Це обмежений фузі МСМ МSK0CFMoM): **обмежений вибір з кількох учасників**, підтверджується за принципом спільної правдивості . Не МSK2 дозволяє багатьма моделям розмовляти МSK3 Не спрямовує МСК4

> *CFMoM - це модель, в якій багато можливих компонентів запропонують сигнали ,, але тільки детерміністична логіка може об 'єднати МSK1 підтвердити М SK2 або діяти на них M SK3*

Правила:

1. **Моделі публікують сигнали.** Немає природної мови між компонентами.
2. **Субстрат зберігає факти та докази.** Введімо, схемуМSK1 зашифрованеM SK2 з наказівками на джерело.
3. **Контренер вирішує.** Кросс-validatesM SK1 вирішує конфлікти

> " В мульти-M SK1 агентних системах МSK2 спільним субстратом є мова ,, а констренером - граматика

[TOC]

---


## Термінологія

Перед тим, як занурюватись у воду, треба встановити словник

| Срок МSK1 Матеріал МSK2
|------|---------|
| **CFMoM** | Стриманий невизначеній MoMM SK1 стриманий вибір з кількох претендентів |
| **Субстрата** МSK0 Факти + докази МSK2 бюджети ♫ ( ♫ детерміністичне ♫ МSK4 ♫
| **Сигнальний контракт** | Як компоненти пишуть на підґрунт МSK1
| **Космічний консенсус** | магазин МSK1 маршрутизація МSK2 асинхове оцінювання |
| **Керівник координації** | Останнє стеження за діямиM SK1виход МSK2

**Nota:** Консенсус Космічний простір - це автобус і пам 'ять МСК0 не арбітер МSK1 Він може виконувати поглинання МСК2 перевірку часу MСК3 схема М СК4 існування доказів М סК5 але ніколи не приймає рішень М S К6 рішення живуть в констренерах М Ш К7

Це не нові поняття.

### Інваріанти

Це неможливі

- **Тільки констренер може викликати побічні ефекти.**
- **Факти повинні підтверджуватись під час вживання схемою.** Відкидати інакше.
- **Докази повинні бути указівними.** Ніяких цитат проза.
- **Сигнали не змінюються.** Коли це було опубліковано,
- **Канонізація відбувається під час вживання.** Контренер приймає канонічні факти.
- **Кросс-заufaння до джерела не подібне, якщо його не калибруютьM SK1**
- **Всі рішення дають запис аудиту**

---


## Що це не так?

| Те, що МSK1 Чому CFMoM відрізняється |
|-------|------------------------|
| **Поєднання експертів (MoEM SK1** | MoE математично змішує моделі *сигнали під обмеженнями* з доказами та політикою
| **Поговори з агентом** | Багато агентних систем проходять безкоштовно -формовані повідомлення між компонентами МSK2 CFMoM застерігає від вільного M SK3формові повідомлення між komponentами -формовані повідомлення з компонентів MSC5 тільки типовані сигнали входять до підґрунтя MST6 M ST7
| **Руйтинг** | Вибір маршрутізації *який модель викликати*. CFMoM приймає багато заявок і обмежує роботу над вибором
| **Голосування/Схожі** | Голосування припускає, що продуктивні результати є подібними . CFMoM вимагає фактів МSK2згоду рівня перед порівнянням
| **Графи стилі LangChain-** | Графи передають повідомленняM SK1 CFMoM публікує непомінні сигнали на об 'єднаному підґрунті

CFMoM - це не бібліотека чи рамка. Це епістемічне правилоM SK1 **ймовірністичні компоненти можуть запропонувати,, але тільки детерміністичнеM SK1 докази -закріплена логіка може об 'єднатися або діяти.**

---


## Чому зв 'язок між LLM- і -LLM не працює

Коли два ЛЛМ спілкуються за допомогою природної мови, ви отримуєте помилки у комп 'ютерному комп' ютері. Навіть якщо кожен крок є більш-менш правильнимM SK2 помилки з' являються швидше, ніж ви сподіваєтесь .

**Семантичний дрейф**: Кожна модель інтерпретує дещо по-іншому . Модель А каже: МSK2користувач здається розчарованим МSK3 Моделі Б пишуть, що як M"користувач наštvaний МСК5 Моделя C ескалізується до МСК6 злодійний użytkownik виявлений МСМ7 Три стрибки ММСК8 три інтерпретації МСК9 одна неправильна висновка МУСК10

**Прайня довіру**: Модель А - це МSK1 впевнені в чомусь МSK2 Вони розповідають моделью Б у плавній прозе . Моделя Б сприймає її як факт, тому що мова звучить певною

**Підсилення галюцинацій**: Модель А вигадує правдоподібний деталі . Моделя B будує його на ньому МSK2 Моделія C робить його таким, яким він є

**Нестабільність формату**: Модель А випромінює JSONM SK1 Інколи. Моделя B це аналізує

Інстинкт полягає в тому, щоб додати більше стимулів для втілення формату . Але м 'які обмеження провалюються між компонентами так само, як вони провалюються всередині компонентів.

Установка ":" змушує все взаємозв 'язок між компонентами МSK1 через спільний детерміністичний простір

### Що "моделі не говорятьM SK1 означає в практиці

Це важке правило.

- **Моделі ніколи не вживають інші моделі** Ні " підсумувати те, що сказав Модель А ".
- **Вони сприймають лише записи на підлозі** що передала схему + перевірки доказів на прийомі МSK1
- **Людське-бачення генерується останнім** і ніколи не повертається в систему.
- **Якщо ви самі написали про prompt, який відноситься до іншої моделі' реакція**, ви порушили шаблон

Це вбиває ", але мій агент може підсумувати інший агент " прогалина МSK2 Ця прогалинка - це те, як починається семантичне дрейфування

---


## Сигнальний контракт

Серце шеми - це записані записи, які кожна компонента повинна використовувати.

### Довідники

Перше - визначити, що означає

```csharp
public record EvidenceRef(
    string Kind,                    // "chunk", "frame", "timestamp", "request", "row"
    string Store,                   // namespace (e.g., "documents", "video-frames")
    string Id,                      // chunk-12, frame-0042, t=00:13:21.200, req-abc
    JsonElement? Locator = null,    // span, bbox, row-range - schema depends on Kind
    string? ContentHash = null      // optional hash for version verification
);
```

Це не стрічка. Це наказник на перевірямі джерела матеріалиM SK1 Кожне твердження має цитувати те, на чому воно базується `Locator` champ handles spans, bounding boxes , timestampsM SK2 or any other location scheme - its schema is determined by `Kind`.

### КонstrainedSignal Record

```csharp
public record EmbeddingRef(string ModelId, float[] Vector);

public record ConstrainedSignal(
    string Id,                                      // stable identifier
    string SourceId,                                // component name/version
    string FactsSchemaId,                           // "bot-detection/1.0", "summarization/2.1"
    DateTimeOffset At,                              // when produced
    string? CorrelationId,                          // ties signals to one input/request
    string? SubjectId,                              // what this signal is about, if known
    JsonElement Facts,                              // schema-validated, not ad-hoc object
    IReadOnlyList<EvidenceRef> Evidence,            // what it's based on
    float Confidence,                               // self-estimated probability of correctness
    IReadOnlyList<EmbeddingRef>? Embeddings = null  // optional, supports multi-model migration
);
```

### Чому це працює?

- **Факти - це схема-validated at ingestion**: `FactsSchemaId` вказує на схему, яка визначає `palette_dominant_hue` означає, який тип він має , які одиниці він використовує `Dictionary<string, object>`. Schemas are JSON Schema (or equivalentM SK2 versioned and pinned.
- **Канониалізація відбувається під час вживання**: Стабільні типиМSK1 Стабилні одиниціM SK2 Стальне нормування. Замітки на timestamps - це стандарти ISO 8601. Колірні кольори - це гекс МSK5 Координації - це WGSMSC6 Констренер припускає канонічні фактиMСК7
- **Доwody структуровані**: Показники на перевіряючу інформацію з джерела , не прозаї описи МSK2
- **Упевненість визначена**МSK0 " Самотність МSK2оцінена ймовірність правильності ". Невиміркована впевненість ніколи не порівнюється з іншими джерелами M SK4 В констренійері МСК5 сприймати перетинну впевненість М СК6 джерело як вагу лише після калібрації M СК7 інакше використовувати один за один М סК8 вихідні схилі М S К9
- **Вбудова - це опціональна допомога.**: Для відтворення та групування , не для ustalenia правдивості МSK2
- **Потрібні slots повинні бути заповнені, інакше сигнал відкидається.** Дозволено вільні поля.

### Вживлення: Де проходить перевірки

Сигнали підтверджують та каніонізуються, коли вони потрапляють до субстрату,, а не тоді, коли їх обробляє констренерM SK1

```csharp
public async Task IngestAsync(ConstrainedSignal signal)
{
    // Hard fail if schema invalid
    _schemaRegistry.Validate(signal.FactsSchemaId, signal.Facts);

    // Canonicalise units, formats, types
    _canonicaliser.Apply(signal.FactsSchemaId, ref signal);

    // Verify evidence pointers exist and are in scope
    foreach (var evidence in signal.Evidence)
        _evidenceStore.VerifyExists(evidence);

    await _store.WriteAsync(signal);
}
```

До того часу, як констренер побачить сигнал: МСК0 , він вже є схемою; "-", Вартівний ; ",", каноникалізований; , МSK3 , і докази: , - , підтверджений; .

### Рівень перевірки доказів

`_evidenceStore.VerifyExists` робить реальну роботу. Це рівніM SK1

- **Існує**: Референційний фрагментM SK1фразма/ID запиту існує в магазині
- **Спектр-правильний**: Span bounds (Start, EndM SK3 are within the source material
- **Содержание-hash погоду**: Доказчик доказів співпадає з очікуваним hashM SK1версію (опціонально, але запропоновано
- **Дозволяти**: Телефону дозволяється віднестись до цих доказів

Сигнали, які не досягають будь-якого рівня, відкидаються під час вживання. Ніяких частинних доказівM SK1

### Критична відмінність: Втілення проти фактів

Тут багато мульти--агентних архітектур пішло не так

**Вбудова** дасть вам відстанню геометрію, яка корелює з подібністю. Вони можливими , лише менш хитрими, ніж природний моваM SK2 Два сигнали з схожими вбудовами *сила* бути майже таким же

**Факти + Доwody** є правдою. МСК0. Те, що МСК1 означає те ж саме. МSK2 в усіх компонентах має бути

- Надруковані вимірювані характеристики (палетні контейнериM SK1 ID об 'єктів, замітки часуMSC3
- Доказники доказів (chunk-12, frameM SK2
- Не вставляючи однаковості наодинці

Вбудова допоможе вам знайти сигнали, *сила* бути майже те ж саме. МСК0. Факти підтверджують, що вони *є*.

### Справжній приклад: Виявление Bot

В [Розпізнавання Bot](/blog/botdetection-introduction), Детектори хвиль МSK1 і LLM МSK2 спілкуються через `DetectionContribution`:

```csharp
DetectionContribution.Bot(
    source: "UserAgent",        // or "LLM"
    category: "BotSignature",
    confidence: 0.85,
    reason: "Contains automation keyword",
    weight: 1.0
);
```

Рекорд - це обмеження. LLM не може плутати. Він має заповнювати slotsM SK2 Детектор UserAgent і LLM виробляють один і той самий вид виходуМSK3 Допоміжні компоненти не потребують знати, який саме його виробив

---


## Космічний консенсус

Сподіваний субстрат не є пасивним зберіганням. Він активно координує потік сигналуM SK1

```mermaid
flowchart TB
    subgraph Specialists["Specialist Proposers"]
        S1[Text Analyzer]
        S2[Image Processor]
        S3[Behavioral Model]
        S4[Domain Expert LLM]
    end

    subgraph Consensus["Consensus Space (includes Ingestion Gate)"]
        C1[Ingestion Gate]
        C2[Signal Aggregator]
        C3[Async Evaluator]
        C4[Cluster by Embedding]
    end

    subgraph Constrainer["Coordination Constrainer"]
        B1[Verify Facts + Resolve]
        B2[Conflict Resolution]
        B3[Budget Management]
    end

    subgraph Output["System Output"]
        O1[Coordinated Response]
        O2[Audit Trail]
    end

    S1 --> C1
    S2 --> C1
    S3 --> C1
    S4 --> C1

    C1 --> C2 --> C3 --> C4

    C4 --> B1 --> B2 --> B3 --> O1
    B3 --> O2

    style Consensus stroke:#ef4444,stroke-width:3px
    style Constrainer stroke:#22c55e,stroke-width:2px
```

### Асинхронне оброблення сигналів

спеціалісти не чекають один на одного. Вони додають сигнали, коли вони закінчуютьM SK1

```csharp
public class ConsensusSpace
{
    private readonly ConcurrentDictionary<string, ConstrainedSignal> _signals = new();

    public async Task ContributeAsync(ConstrainedSignal signal)
    {
        _signals.TryAdd(signal.Id, signal);

        // Trigger evaluation without blocking the contributor
        _ = Task.Run(async () =>
        {
            var evaluation = await _evaluator.EvaluateAsync(signal);
            await _distributor.DistributeAsync(evaluation);
        });
    }

    public IDisposable Subscribe<T>(Func<T, Task> handler)
        where T : ConstrainedSignal
    {
        // Components subscribe to signals they care about
    }
}
```

Найшвидкіші детектори ( перевірка агента користувачаM SK1 аналіз заголовків) не блокують повільних МSK3 аналіз LLMM4 поведінкові моделіMSC5 Консенсусний простір накопичує сигнали впродовж часу . Ранні сигнали можуть призвести до ранніх виходів

---


## спеціалізація та глибина

З спільним контрактом на сигнали specialistи можуть зосередитися на тому, що вони роблять найкраще

### Природний відділ праці

```csharp
public class TextSpecialist : ISpecialist
{
    public async Task<ConstrainedSignal> AnalyzeAsync(InputData input, string correlationId)
    {
        var entities = await ExtractEntitiesAsync(input.Text);
        var sentiment = await AnalyzeSentimentAsync(input.Text);

        var facts = JsonSerializer.SerializeToElement(new
        {
            entities = entities.Select(e => e.Label).ToArray(),
            sentiment_score = sentiment.Score,
            sentiment_label = sentiment.Label
        });

        return new ConstrainedSignal(
            Id: Guid.NewGuid().ToString(),
            SourceId: "TextSpecialist/1.2",
            FactsSchemaId: "text-analysis/1.0",
            At: DateTimeOffset.UtcNow,
            CorrelationId: correlationId,
            SubjectId: input.Id,
            Facts: facts,
            Evidence: entities.Select(e => new EvidenceRef(
                "span", "documents", input.Id,
                JsonSerializer.SerializeToElement(new { Start = e.Start, End = e.End }))).ToList(),
            Confidence: CalculateConfidence(entities, sentiment),
            Embeddings: [new EmbeddingRef("all-MiniLM-L6-v2", _embedder.Embed(entities, sentiment))]
        );
    }
}

public class ImageSpecialist : ISpecialist
{
    public async Task<ConstrainedSignal> AnalyzeAsync(InputData input, string correlationId)
    {
        var objects = await DetectObjectsAsync(input.Image);
        var palette = await ExtractPaletteAsync(input.Image);

        var facts = JsonSerializer.SerializeToElement(new
        {
            objects = objects.Select(o => o.Label).ToArray(),
            palette_dominant_hex = palette.Dominant.ToHex(),
            palette_accent_hex = palette.Accent.ToHex()
        });

        return new ConstrainedSignal(
            Id: Guid.NewGuid().ToString(),
            SourceId: "ImageSpecialist/2.1",
            FactsSchemaId: "image-analysis/1.0",
            At: DateTimeOffset.UtcNow,
            CorrelationId: correlationId,
            SubjectId: input.Id,
            Facts: facts,
            Evidence: objects.Select(o => new EvidenceRef(
                "region", "images", input.Id,
                JsonSerializer.SerializeToElement(o.BoundingBox))).ToList(),
            Confidence: CalculateConfidence(objects, palette),
            Embeddings: [new EmbeddingRef("all-MiniLM-L6-v2", _embedder.Embed(objects, palette))]
        );
    }
}
```

### Кросс-МСК0 -Modальна угода

Обидві спеціалісти публікують на одному підґрунті з задрукованими фактами. Але факти з різних домен не можна порівняти безпосередньо

Коли текстовий спеціаліст `entity_color: "blue"` і спеціаліст з обробки зображень `palette_dominant_hex: "#0000CC"`, як перевірити угоду

**Не сирова рівність.** "блакитнийM SK1 МSK2 | | "#0000CC | МSK4 | як штрихи . Вам потрібен розладник

```csharp
public interface IFactResolver
{
    bool CanResolve(string factNameA, string factNameB);
    FactAgreement Resolve(JsonElement factA, JsonElement factB);
}

public class ColorResolver : IFactResolver
{
    public bool CanResolve(string a, string b) =>
        (a.Contains("color") && b.Contains("hex")) ||
        (a.Contains("hex") && b.Contains("color"));

    public FactAgreement Resolve(JsonElement factA, JsonElement factB)
    {
        // Canonicalise both to RGB space
        var colorA = ParseToRgb(factA);
        var colorB = ParseToRgb(factB);

        // Tolerance-based comparison in perceptual space
        var distance = CieDeltaE(colorA, colorB);
        return new FactAgreement(distance < 10.0, distance);
    }
}
```

*(The `Contains` вищезгадана логіка є ілюстративною. В процесі виробництваM SK1 розшифроватори записуються за допомогою схемної пари + ключ фактів , не субстронну геріуристикуMSC4*

**Крестовий-по замовчуванню неможливий порівняння схемM SK1** Ви отримуєте його лише зареєструючи експлицимний розв 'язувач. Це безпечна властивість

Констренер координації використовує реєстр розробників:

1. Використовуйте вбудова, щоб об 'єднати кластерні сигнали разом (швидкі , неяскраві МSK2
2. Для кожної пари фактів, знайдіть розшифровувач M SK1 або використовуйте початковий точний -match)
3. Резолери канониколізують і порівнюють з відповідною толерантністю
4. Об 'єднати, якщо вирішено Флаг ,, якщо суперечить

Ніяких природніх мов не вимагається. Розбіжності відображаютьсяМSK1 не приховані МSK2 КрестніM SK3 модальні факти порівнюються у їхньому спільному канонічному просторі.

---


## Контренер координації

У частині 1, констренер був охоронцем

У частині 2, констренер координації - **оркестр**МSK0 Це:

1. **Кросс-validates**: Чи сигнали різних експертів погоджуються з фактамиM SK1
2. **Вирішує конфлікти**МSK0 Коли експерти не погоджуються, як даліM SK2
3. **Керує бюджетами**: Скільки фахівців потрібно викликати для цього введенняM SK1
4. **Втілює шкали консенсусусу**МSK0 Скільки домовленості перед діями?

**Констренер детермінативний.** У ньому немає LLM, ніякої логіки ймовірностіM SK1 ніяких " викликів судження". Кожне рішення слідує прямим правиламMSC4 Це архітектурна гарантія, яка робить решту шаблону дієвим

### Перевірка трьох кроків

```csharp
public class CoordinationConstrainer
{
    public async Task<CoordinatedResult> ConstrainAsync(
        IReadOnlyList<ConstrainedSignal> signals)
    {
        // Step 1: Cluster candidates by embedding (cheap, fuzzy)
        var clusters = ClusterByEmbedding(signals);

        // Step 2: Within each cluster, verify agreement on FACTS (hard)
        var verified = new List<ConstrainedSignal>();
        foreach (var cluster in clusters)
        {
            // Time-of-use re-check: evidence may have expired or been GC'd since ingestion
            var withValidEvidence = cluster.Where(s =>
                s.Evidence.Any() && _evidenceStore.IsStillAuthorisedAndAvailable(s.Evidence)).ToList();

            var factAgreement = VerifyFactAgreement(withValidEvidence);
            if (factAgreement.Agreed)
                verified.AddRange(factAgreement.Signals);
            // Disagreeing signals are logged for analysis, not merged
        }

        // Step 3: Check consensus threshold (policy, hard)
        if (verified.Count < _policy.MinimumSignals)
        {
            if (_policy.AllowEscalation)
                return await EscalateToTiebreakerAsync(signals);
            else
                return CoordinatedResult.Degraded("Insufficient consensus");
        }

        // Step 4: Merge and apply output constraints
        var merged = MergeSignals(verified);
        return ApplyOutputConstraints(merged);
    }

    private FactAgreement VerifyFactAgreement(IReadOnlyList<ConstrainedSignal> cluster)
    {
        // Agreement is on Facts via rules registry, not raw equality
        foreach (var (signalA, signalB) in AllPairs(cluster))
        {
            var result = _rules.CheckAgreement(
                signalA.FactsSchemaId, signalA.Facts,
                signalB.FactsSchemaId, signalB.Facts);

            if (!result.Agreed)
                return new FactAgreement(false, cluster, result.ConflictingFact);
        }
        return new FactAgreement(true, cluster, null);
    }
}

// The rules registry handles type-appropriate comparison
public class FactAgreementRules
{
    private readonly Dictionary<string, IFactResolver> _resolvers = new();
    private readonly IFactResolver _defaultResolver = new DefaultFactResolver();

    public void Register(string factPattern, IFactResolver resolver) =>
        _resolvers[factPattern] = resolver;

    public AgreementResult CheckAgreement(
        string schemaA, JsonElement factsA,
        string schemaB, JsonElement factsB)
    {
        // Cross-schema: use resolvers to map between schemas
        if (schemaA != schemaB)
            return CheckCrossSchemaAgreement(schemaA, factsA, schemaB, factsB);

        // Same schema: compare fact by fact
        foreach (var prop in factsA.EnumerateObject())
        {
            if (!factsB.TryGetProperty(prop.Name, out var valueB))
                continue;

            var resolver = FindResolver(prop.Name);
            var result = resolver.Resolve(prop.Value, valueB);
            if (!result.Agreed)
                return new AgreementResult(false, prop.Name);
        }
        return new AgreementResult(true, null);
    }

    private IFactResolver FindResolver(string factName) =>
        _resolvers.FirstOrDefault(r => factName.Contains(r.Key)).Value
        ?? _defaultResolver;
}

public class DefaultFactResolver : IFactResolver
{
    public bool CanResolve(string a, string b) => true;

    public FactAgreement Resolve(JsonElement a, JsonElement b)
    {
        return a.ValueKind switch
        {
            JsonValueKind.Number => ResolveNumeric(a, b),     // Tolerance
            JsonValueKind.String => ResolveString(a, b),     // Exact match
            JsonValueKind.True or JsonValueKind.False =>
                new FactAgreement(a.GetBoolean() == b.GetBoolean(), 0),
            _ => new FactAgreement(a.GetRawText() == b.GetRawText(), 0)
        };
    }

    private FactAgreement ResolveNumeric(JsonElement a, JsonElement b)
    {
        var va = a.GetDouble();
        var vb = b.GetDouble();
        var tolerance = Math.Max(Math.Abs(va), Math.Abs(vb)) * 0.001; // 0.1%
        return new FactAgreement(Math.Abs(va - vb) <= tolerance, Math.Abs(va - vb));
    }

    private FactAgreement ResolveString(JsonElement a, JsonElement b) =>
        new FactAgreement(a.GetString() == b.GetString(), 0);
}
```

Найголовніша думка: **Запропоновані введення вкладів**. Схожість вбудованих сигналів вказує на те, що МSK1 ці сигнали можуть бути пов 'язані МSK2 Порівняння фактів підтверджує МСК3 ці символи згодні МСК4

### Функція прийняття рішень

Вибір констренера - детерміністський. МСК1 - без ЛЛМ. МSK2 - без геуристики, МСК3 - без МСК4 - без судимості, МSK5 - ось такий потік.

1. **Групи кандидатів** шляхом введення подібності ( дешеве кластеруванняM SK1
2. **Фильтр** за допомогою перевірки правдивості схеми та доказів. ( вже зроблено при вживці МSK1 але може бути перероблено МSK2 перевірено )
3. **Вияснити факти** в канонічний простір порівняння за допомогою реєстру розладників
4. **Вирахуйте рахунок угоди** за кластер : відсоток необхідних фактів, які є вирішованими - узгоджені між МSK2N різними джерелами
5. **Застосувати політику**: мінімальний початковий рівень згоди , мінімальне число джерел МSK2 на - шкали рівня довіри до джерела
6. **Вибір дії**: об 'єднати, якщо домовлено , погіршувати, якщо ні МSK2 ескалювати, якщо конфігуровано

Кожен крок є детерміністичною функцією

---


## Поєднання моделей з об 'єктивним зворотнім зв' язком

Консенсусний простір дозволяє щось потужне: **незалежне навчання від об 'єктивної реальності**.

### Об 'єднання вчитися

```mermaid
flowchart TB
    subgraph Specialists["Specialist LLMs"]
        S1[Model A]
        S2[Model B]
        S3[Model C]
    end

    subgraph Consensus["Consensus Space"]
        C1[Signal Aggregation]
        C2[Decision Selection]
    end

    subgraph Action["Deterministic Execution"]
        A1[Execute Decision]
        A2[Measure Outcome]
    end

    subgraph Memory["Long-Running RAG"]
        M1[Decision Record]
        M2[Objective Outcome]
        M3[Attribution]
    end

    subgraph Feedback["Independent Learning"]
        F1[Model A reviews own history]
        F2[Model B reviews own history]
        F3[Model C reviews own history]
    end

    S1 --> C1
    S2 --> C1
    S3 --> C1
    C1 --> C2 --> A1 --> A2

    A2 --> M1 --> M2 --> M3

    M3 --> F1 --> S1
    M3 --> F2 --> S2
    M3 --> F3 --> S3

    style Memory stroke:#3b82f6,stroke-width:3px
    style Feedback stroke:#22c55e,stroke-width:2px
```

### Чому це працює?

1. **Вироки приписуються**: РАG зберігає, яка модель запропонувала, що
2. **Результати є об 'єктивними**: Детерміністичні компоненти вимірюють, що насправді відбулося
3. **Відповідь ділиться, але вага є незалежною**: Кожна LLM бачить ті самі результати, але вирішує, як пристосувати

```csharp
public record DecisionRecord(
    string DecisionId,
    string ProposingModel,           // Which LLM proposed this
    ConstrainedSignal OriginalSignal,   // What it claimed
    float ConsensusScore,            // Agreement at decision time
    DateTime Timestamp
);

public record OutcomeRecord(
    string DecisionId,
    bool ObjectiveSuccess,           // Deterministic measurement
    Dictionary<string, float> Metrics,  // What we measured
    TimeSpan TimeToOutcome
);
```

### Незалежне навчання, Поширена правда

Кожен LLM може запросити RAG по-різному:

```csharp
// Model A: Conservative, focuses on avoiding failures
var modelAContext = await _memory.QueryAsync(
    "decisions WHERE ProposingModel = 'ModelA' AND ObjectiveSuccess = false",
    limit: 100
);
// Learns: "I was overconfident when X, be more cautious"

// Model B: Aggressive, focuses on missed opportunities
var modelBContext = await _memory.QueryAsync(
    "decisions WHERE ProposingModel != 'ModelB' AND ObjectiveSuccess = true",
    limit: 100
);
// Learns: "Others succeeded where I hesitated, be bolder on pattern Y"

// Model C: Specialist, focuses on its domain
var modelCContext = await _memory.QueryAsync(
    "decisions WHERE Domain = 'security' ORDER BY ObjectiveSuccess DESC",
    limit: 100
);
// Learns: "These security patterns work, reinforce them"
```

### Обмеження, що дозволяють навчатись

Це працює тільки тому, що зворотній зв 'язок **цілеспрямова**.

| Без детерміністичного зворотнього зв 'язку | З детерминістичним зворотнім зв' язком МSK2
|-------------------------------|----------------------------|
МSK0 " Модель А вважала, що все добре
МSK0 " Модель Б не згодна з результатомM SK2 ♫ | ♫ ♫ МSK4 ♫ Bot confirmed by honeypot ♫
МSK0 "Models argue about qualityM SK2 ♫ ♫ | ♫

Детермінативний шар вимірює реальність. ЛСМ не можуть сперечатися з вимірюваннямиМSK1 Кожна модель вчиться від тієї ж базової істини, але адаптується незалежно, спираючись на власну історію та пріоритетиM SK2

### Невідкладна спеціалізація

З часом, моделі природньо спеціалізуютьсяM SK1

- Модель А вчить, що вона відмінна від обережніх рішень.
- Модель B вчить, що вона відмінна у крайніх випадках , викликається, коли інші непевні
- Модель C глибоко вивчає свій домен - МСК0 стає експертом для такого типу сигналу

Жоден центральний організатор не визначає ролей МСК0 спеціалізація виникає з об 'єктивного зворотнього зв' язку на реальних результатах МSK1

---


## Чому Frontier Models роблять це важливішим

Поперечний інтуїтив **кращі моделі роблять спільні субстрати критичнішими, а не менш важливими**.

| По мірі того, як моделі покращуютьсяM SK1 | Ризик зростає, тому що
|---------------------|------------------------------|
| Розвинені результати | Більше можливості для непорозуміння
| Гостріша впевненість | Надмірна впевненість сигналів швидко розповсюджується
| Поширені можливості | Ще більше спокушання відмовитися від обмежень в типі МSK2
| Краще, коли вони виглядають послідовними | важче розпізнавати, коли не погоджуються семантично

Модель кордону, яка спілкується з іншою моделью кордону за допомогою природної мови, небезпечніша, ніж дві маленькі моделі, які роблять те ж саме.

Це те ж саме: зв 'язок силою через детермінативний спільний простір . Вбудована модель не має значення, чи запропонуючий маленький, чи кордонний МSK2 Те ж векторне простір, що і МSK3 Те саме типу фактів М SK4 Те same constraintsМSK5

---


## Еволюція без розриву

Тому що зв 'язок відбувається за допомогою надрукованих записів та спільного вмонтування:

- Переміняйте текстового експерта з GPT-4 на Claude, не торкаючись інших компонентів
- Додайте новий спеціаліст (аudio analyzerM SK1 без зміни існуючих
- модернізувати модель вміщування по всіх компонентах атомно

### Версію моделі вбудованості

Ви хочете оновити з `all-MiniLM-L6-v2` до `nomic-embed-text-v1.5`. Але всі ваші накопичені сигнали мають вбудовані від старої моделіM SK1

**Рішення: двойний-писати з багатьма вбудовамиM SK2**

Тому що `Embeddings` це список `EmbeddingRef`, міграція простаM SK1

```csharp
public class EmbeddingMigration
{
    // Phase 1: Dual-write (new signals get both embeddings)
    public ConstrainedSignal EnrichWithDualEmbedding(ConstrainedSignal signal)
    {
        var oldVector = _oldModel.Embed(signal.Facts);
        var newVector = _newModel.Embed(signal.Facts);

        return signal with
        {
            Embeddings =
            [
                new EmbeddingRef("all-MiniLM-L6-v2", oldVector),
                new EmbeddingRef("nomic-embed-text-v1.5", newVector)
            ]
        };
    }

    // Phase 2: Compare agreement rates
    public async Task<MigrationReport> CompareAgreementAsync()
    {
        var signals = await _store.GetRecentSignalsAsync(limit: 10000);

        var oldClusters = ClusterByEmbedding(signals, s =>
            s.Embeddings?.FirstOrDefault(e => e.ModelId == "all-MiniLM-L6-v2")?.Vector);
        var newClusters = ClusterByEmbedding(signals, s =>
            s.Embeddings?.FirstOrDefault(e => e.ModelId == "nomic-embed-text-v1.5")?.Vector);

        // Do the same Facts end up in the same clusters?
        var agreementRate = CalculateClusterAgreement(oldClusters, newClusters);

        return new MigrationReport(agreementRate, threshold: 0.95);
    }

    // Phase 3: Flip readers after threshold met
    public void CompleteMigration()
    {
        // Update config to use new model for queries
        // Keep old embeddings for rollback if needed
        // Optionally prune old embeddings after confidence period
    }
}
```

Ключевые моменти:

- **Кожна вбудова має свій ModelId.** Ніяких припущень.
- **Dual-write просто приєднується до спискуM SK1** Старі читачи досі працюють.
- **Порівняйте кластерні угоди**, не сирова схожість косинуM SK1
- **Повертатися після шкали** МСК0еМSK1g., M SK3 те ж саме МSK4угода про кластер ).
- **Факти стабільні.** Навіть якщо вбудова змінюється, надруковані факти залишаються базовою правдоюM SK1

---


## Моди провалу та невдачі

Цей візерунок світиться, коли щось йде не так. KontrolаM SK1системний кадр означає, що невдачі є експлицивними і відновлюваними

### Конфліктні факти

Двоє експертів стверджують різні значення для одного й того ж факту. Резолетор не може їх змиритиM SK1

**Відповідь**: Записати конфлікт з повним контекстомM SK1 Не об 'єднати. Погіршувати вихідний сигнал, щоб показати зниження довіри

### Погані або неправильні докази

Сигнал приходить з свідченнями, які не існують

**Відповідь**: Відкидати сигнал при поглинанні . Він ніколи не входить до підґрунтя M SK2 Пропонуючий компонент повідомлений і може повторити спробу за допомогою надійних доказів

### Жодного консенсусу

Надто мало сигналів МSK0 або надто багато суперечок, щоб досягнути політичного бар 'єру .

**Відповідь**: Повертатися до детерміністичної базової лінії (e.gM SK3 початкова класифікація МSK4 зашифрований попередній результат МSK5 або експлуатальний M"недосталь даних МСК7 реакція МК8 Якщо конфігуровано МПС9 просити людський огляд МУС10 Ніколи не здогадуватися МБС11

### Залишена доказність

Дослідження були ефективними під час вживання, але з того часу вийшли на пенсію.

**Відповідь**МSK0 Конструктор ' час МSK2 з МSK3 перевірка використання`IsStillAuthorisedAndAvailable`) спіймає цеM SK1 Сигнал виключений з теперішнього рішення, з МSK2 доказ не підтверджений МSK3 причина аудиту . Поліція може потребувати переробки М SK5аналізу, якщо необхідні свіжі докази M SK6

### Єдиний джерело невдачі в правді

Сам субстрат не доступний.

**Відповідь**: Маршрутний розривникM SK1 Ніяких сигналів не можна втягувати чи обробляти . Система деградує на безпечні погані або черги входів для подальшого обробки МSK3 Це - порушення інфраструктури M SK4 а не порушення шаблону .

Модель не запобігає невдачі. Вона робить їх **гучний, локалізованийM SK1 і відновлюваний**.

---


## Перечень перевірок щодо втілення

Для команд, що будують багатовимірні системи агентів

1. **Виберите одну модель вмонтування** для всіх компонентів (eM SK1g ., всі-MiniLMMSC4LMska5vMske6
2. **Визначати контракт сигналу** (`ConstrainedSignal` + `EvidenceRef`) перед тим, як побудувати будь-яку specialistу
3. **Визначати канонічні одиниці та нормування** для всіх фактів (ISO МSK1 timestamps, hex colorsM SK3 WGSMSC4 coords )
4. **Побудувати консенсус спочатку** (аgregація сигналівM SK1 асинхове оцінювання)
5. **Кожен спеціаліст виробляє сигнали**, ніколи не розмовляти природною мовою іншим експертам
6. **Констренер координації підтверджує угоду щодо фактів**, не вміщує схожості
7. **Зареєструвати розв 'язання** для krzyżа-модальний порівняння фактів M SK1назви кольорів проти шестиугольникаМSK2 і т.п.
8. **Зареєструвати всі сигнали** з приписом для виправлення і еволюції
9. **Об 'єктивно виміряти результати** (конверсіїM SK1 точность, затримкаMSC3
10. **Результати пар з магазином +** в довгостроковій RAG
11. **Дозвольте моделям задати питання про власну історію** для незалежного навчання
12. **Поміняти компоненти один за одним**, перевіряє, чи сигнали все ще підходять до схеми

---


## Субстрат - це система

Частина 1: Конsträngії створюють корисне поведінку в окремих компонентахM SK1

Частина 2: **Поширені обмеження створюють послідовне поведінку між компонентами.**

Консенсусний простір - це не середній інструмент , а розширений підґрунт . Коли експерти спілкуються за допомогою надрукованих фактів, а не мови.

Множество кандидатів МСК0 Одна спільна правда МSK1 Те ж саме

Моделі не розмовляють одне з одним. МСК0. Вони публікують їх на субстраті. МSK1. Констренер підтверджує результати. .. Результат виміряється. МСК3. РАГ запам 'ятовує. MСК4. Кожна модель вивчає.

**Частина 1 обмежує модель . Część МSK2 обмежить простірні моделі поділу МSK3**

Це обмежений туманний MoM.

---


## Занотація

- **" Моделі не говорять** = безкоштовнийM SK1модельні виходи fed-in в інші моделі . Лише записи субстрат, які проходили контроль за інгредіацією МSK3
- **Перевірка доказів на момент прийняття рішення** для отримання дозволу/вживання лишеM SK1неправильність. Правильність була доведена під час вживанняMSC3
- **Результат угоди** = відсоток необхідних фактів, які є розв 'язливими

---


## Серіал

| частина МSK1 візерунок МSK2 вісь |
|------|---------|------|
| 1 | [Стримана неясність](/blog/constrained-fuzziness-pattern) | Едина компонента МSK1
МSK0 2 ♫ ♫ МSK2 ♫ Конsträngно-фузійний МоМ ♫ ( ♫ Цей artykuł ♫
| 3 | [Перетягування обмеженого неясного контексту](/blog/constrained-fuzzy-context-dragging) МSK0 Час / пам 'ять |

**Частина 1** обмежує одну можливу складову з детермінативними межами.

**Частина 3** розширює цю архітектуру вздовж часової осі.