# Eingeschränkte Fuzzy MoM-:-Signalverträge über Agent Chatter

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

[Teil](/blog/constrained-fuzziness-pattern) beschrieben eine Pipeline, die von einer probabilistischen Komponente mit deterministischer Wahrheit begrenzt wird.

Aber was passiert, wenn man *Mehrfach* Vorschlagende mehrer LLMs ,? , Vision-Modelle sprechen mit Textmodellen ,? , Heuristik in neuronale Netzwerke einspeisen , ? ,

Das ist eingeschränkte Fuzzy MoM **eingeschränkte Auswahl von mehreren Antragstellern**Nicht " let viele Modelle sprechen ". , nicht Routing , . .

> *CFMoM ist ein Muster, in dem mehrere probabilistische Komponenten signale vorschlagen, die aber nur deterministische Logik kombinieren können.*

Die Regel

1. **Modelle Veröffentlichung von Signalen** Keine natürliche Sprache zwischen den Komponenten
2. **Substrat speichert Fakten und Beweise** Typisiert mit Zeigern zur Quelle
3. **Constrainer entscheidet:** Cross---Validierungen - , - löst Konflikte -, - erzwungen Schwellenwerte

> Das gemeinsame Substrat ist die Sprache und der Constrainer ist die Grammatik.

[TOC]

---


## Terminologie

Vor dem Tauchen in Beenden Sie das Vokabular

Der Begriff „|" bedeutet „|"
|------|---------|
| **CFMoM** Beschränkte Auswahl von mehreren Bewerbern
| **Unterlage** Fakten Fakten Fakten Informationen Informationen Informationen über die Budgets
| **Signalvertrag** Wie Komponenten in das Substrat schreiben
| **Konsensraum** Speichern Sie das Routing-Routing, um die Auswertung des Assync-Verfahrens zu ermitteln.
| **Koordinierungsbeschränkung** Endgültiger Gatekeeper für Aktionen

**Anmerkung:** Consensus Space ist ein Bus und Speicher, nicht ein Schiedsrichter, sondern kann die Ingestion durchführen.--Zeit-Validierung (-Schema-,-Evidenz-Existenz-), aber nie Entscheidungen treffen.

Dies sind keine neuen Konzepte, sie sind das Teil-Muster, das über Komponenten erweitert wird.

### Invarianten

Diese sind nicht ,-'verhandelbar , :'

- **Nur der Constrainer kann Nebenwirkungen auslösen.**
- **Fakten müssen gegen Schema bei der Einnahme validieren** Anderenfalls ablehnen
- **Der Nachweis muss Zeiger sein.** Keine Prosa-Zitate
- **Signale sind unveränderlich** Einmal veröffentlicht, nicht geändert, nicht verändert
- **Canonicalisation geschieht bei der Einnahme ..-** Constrainer geht von kanonischen Fakten aus
- **Das Vertrauen in die Quelle ist nicht vergleichbar, es sei denn kalibriert.**
- **Alle Entscheidungen produzieren einen Audit-Rekord**

---


## Was das nicht ist

Warum CFMoM anders ist
|-------|------------------------|
| **Mischung von Experten** MoE mischt Modellausgänge mathematisch – .® CFMoM-Mischungen *Signale unter Einschränkungen* mit Evidenz und Politik
| **Agent chatter** Viele Agenten-Systeme passieren frei-.form Nachrichten zwischen den Komponenten... CFMoM verbietet freies -.form inter--.component Nachrichten, die nur eingegebene Signale in das Substrat eingeben.
| **Routing** Routing wählt aus *welches Modell anzurufen ist*CFMoM akzeptiert mehrere Vorschläge und beschränkt die Auswahl nach
| **Abstimmungen Assembles** Die Abstimmung geht davon aus, dass die Ergebnisse vergleichbar sind.
| **LangChain---Stilgraphen** Graphen übergeben Botschaften – . – CFMoM veröffentlicht unveränderliche Signale zu einem gemeinsamen Substrat –. – | –

CFMoM ist keine Bibliothek oder ein Framework.Es ist eine epistemische Regel. **probabilistische Komponenten können vorschlagen, ,, aber nur deterministisch,,, Evidenz, -, unterstützte Logik kann kombinieren oder handeln**

---


## Warum LLM---to---LLM-Kommunikation fehlschlägt

Wenn zwei LLMs über natürliche Sprache kommunizieren, erhalten Sie Compounding-Ausfälle, auch wenn jeder Hopfen meistens korrekt ist., ?Fehler Verbindung schneller als Sie erwarten.

**Semantische Drift**Jedes Modell interpretiert etwas anders als das Modell A sagt, dass der Benutzer frustriert scheint.Das Modell B liest, dass, wie ",der Benutzer wütend ist..", das Modell C eskaliert, um ",feindlichen Benutzer entdeckt..", Drei Hops, ,, drei Interpretationen, ein falscher Schluss...

**Vertrauenswäsche**Es sagt Modell B in fließenden Prosa , . , Modell B behandelt es als Tatsache, weil die Sprache klingt bestimmte ,. , Ungewissheit wird an jedem Hopfen ausgewaschen .

**Halluzination Verstärkung**Modell A erfindet ein plausibles Detail Das Modell B baut darauf auf Das Modell C nennt es als etabliertes Modell Die Halluzination wird zur Belastung

**Formatinstabilität**Das Modell A liefert JSON-.. Manchmal schneidet das Modell B es aus. Manchmal vermehren sich die Silent-Ausfälle von ..

Der Instinkt ist, mehr Aufforderungen hinzuzufügen, um Format zu erzwingen... Aber weiche Einschränkungen scheitern zwischen den Komponenten genauso wie sie in Komponenten fehlschlagen....

Die Fix-:-Kraft alle Inter---Komponente Kommunikation durch einen gemeinsamen deterministischen Raum

### Was bedeutet "-Modelle in der Praxis?

Dies ist die harte Regel.

- **Modelle, die keine anderen Modelle aufnehmen** Keine Zusammenfassung dessen, was Modell A sagte
- **Sie nehmen nur Substrataufzeichnungen auf** das Schema bestanden hat, das Beweiskontrollen bei der Aufnahme durchgeführt hat,
- **Human--'facing Erklärung wird zuletzt generiert** und wird nie wieder in das System eingespeist
- **Wenn Sie sich finden, schreiben Sie eine Aufforderung, die Verweise auf ein anderes Modell.**Sie haben das Muster verletzt.

Dies tötet das -", aber mein Agent kann den anderen Agenten zusammenfassen -" loophole - . , Das Schlupfloch ist, wie semantische Drift beginnt - . ,

---


## Der Signalvertrag

Das Herz des Musters ist ein typisierter Datensatz, den jede Komponente verwenden muss... keine Prosa-.. Keine freie Ausgabe von -.

### Nachweise

Zunächst definieren Sie, was "?Beweis bedeutet.

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

Dies ist kein String, es ist ein Zeiger auf überprüfbares Ausgangsmaterial. `Locator` Feldgriffe Spannweiten ,-Grenzkästen ,-Timestamps,- oder andere Lageschemas (--Schema) wird durch `Kind`.

### Der eingeschränkte Signalrekord

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

### Warum das funktioniert

- **Fakten werden bei der Einnahme validiert**: `FactsSchemaId` verweist auf ein Schema, das definiert, was `palette_dominant_hue` bedeutet: ,,,', welcher Typ es ist ,,', welche Einheiten es verwendet ,MSSK2' Kein ad , -'hoc `Dictionary<string, object>`Die Schemata sind JSON-Schema oder ein Äquivalent von ),, versioniert und gepinnt.
- **Canonicalisation geschieht bei Einnahme**Stable types: Stabile Einheiten: stabiler Normalisierung: konstanter Normierung: stabile Standard-Zeitstempel: ISO-Farben sind Hexus: .; Koordinaten: WGS, 84.; der Constrainer geht von kanonischen Fakten aus.
- **Die Beweise sind strukturiert.**Hinweise auf nachprüfbares Ausgangsmaterial
- **Vertrauen ist definiert**Nicht kalibrierte Konfidenz wird nie über Quellen verglichen. Im Constrainer behandelt , das cross-Vertrauen als Gewicht nur nach der Kalibrierung.
- **Einbettungen sind optionale Hilfsmittel**Für Retrieval und Gruppierungen, nicht für die Ermittlung der Wahrheit, nicht
- **Erforderliche Slots müssen ausgefüllt werden oder das Signal wird abgelehnt.** Optionale Felder sind erlaubt

### Ingestion: :, wo die Validierung lebt

Signale werden validiert und kanonischisiert, wenn sie in das Substrat gelangen, nicht wenn der Constrainer sie verarbeitet.

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

Wenn der Constrainer ein Signal sieht, ist es bereits schema.-.gültig.MS K2. kanonischisiert.,. und Evidenz.MS-K4.verifiziert.

### Nachweisniveaus

`_evidenceStore.VerifyExists` tut wirkliche Arbeit, das sind die Levels, das ist

- **Bestehend**Im Store existiert die Referenznummer /./«Request ID
- **Geltungsbereich**Die Span-Grenzen sind innerhalb des Ausgangsmaterials.
- **Inhalt: --Hash-Match**Evidence-Pointer-Matches erwartete Hash-/-Version Optional, aber empfohlen
- **Genehmigungen**Der Anrufer darf diese Evidenz für Multi---Tenantsysteme aufzeigen.

Signale, die jedes Niveau ausfallen, werden bei der Aufnahme abgelehnt.

### Die kritische Unterscheidung · :-Embeddings gegen Fakten

Dies ist, wo viele Multi---Agent Architekturen falsch gehen

**Einbettungen** dir eine Distanzgeometrie zu geben, die mit Ähnlichkeit korreliert... sie sind probabilistisch... nur weniger wackelig als natürliche Sprache... zwei Signale mit ähnlichen Einbettungen. *könnte* seien Sie ungefähr die gleiche Sache...

**Fakten Beweismaterial** sind die Wahrheit... die Sache, die "bedeutet die gleiche "e über Komponenten muss sein...

- Getippte messbare Merkmale (-Palettenbehälter ,-Objekt-IDs,-Zeitstempel
- Evidenzzeiger (-Kunke--12,-Rahmen
- KEINE Ähnlichkeit allein einbetten

Einbettungen helfen Ihnen, Signale zu finden, die *könnte* seien über die gleiche Sache ... . Facts überprüfen, dass sie *sie werden*.

### Echtes Beispiel: Bot-Erkennung

Im [Bot-Erkennung](/blog/botdetection-introduction),-Wellen-Detektoren und Wellen-LLMs kommunizieren über `DetectionContribution`:

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

Der Datensatz IST die Einschränkung ,. , Das LLM kann nicht versäumen .. , Es muss Steckplätze füllen ?. , Der UserAgent-Detektor und das LLM produzieren den gleichen geformten Ausgang , . , Downstream-Komponenten müssen nicht wissen, welche man produziert es .... ,

---


## Der Raum des Konsenses

Das gemeinsame Substrat ist kein passiver Speicher, sondern koordiniert aktiv den Signalfluss.

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

### Asynchrone Signalverarbeitung

Spezialisten warten nicht auf einander, sie tragen Signale bei, wie sie beenden, :

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

Schnelle Detektoren Benutzer-Kontrolle ,-Header-Analyse )-Blockieren Sie nicht auf langsamen nicht (-LLM Analyse ,-Verhaltensmuster ).-Der Konsensraum sammelt Signale im Laufe der Zeit.-Frühsignale können frühe Ausgänge auslösen..-Spätsignale verfeinern oder überschreiben.

---


## Spezialisierung und Tiefe

Mit einem gemeinsamen Signalvertrag können sich Spezialisten auf das konzentrieren, was sie am besten tun

### Natürliche Arbeitsteilung

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

### Grenzüberschreitendes --Modalabkommen

Beide Spezialisten veröffentlichen auf das gleiche Substrat mit getippten Fakten, aber Tatsachen aus verschiedenen Bereichen können nicht direkt verglichen werden.

Wenn der Textspezialist produziert `entity_color: "blue"` und der Bildspezialist produziert `palette_dominant_hex: "#0000CC"`Wie überprüfen Sie die Vereinbarung?

**Nicht rohe Gleichheit** Sie benötigen einen Resolver.

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

*(" `Contains` Logik oben ist illustrativ...... in der Produktion.. ..,...Resolver werden von Schemapaaren registriert.*

**Der Vergleich von Cross---Schema ist standardmäßig nicht möglich.** Sie erhalten es nur, indem Sie einen expliziten Resolver registrieren.Dies ist eine Sicherheitsfunktion.

Der Coordination Constrainer verwendet ein Resolver-Register.

1. Embeddings verwenden, um Signale zusammen zu clusteren
2. Für jedes Faktenpaar finden Sie den Resolver.
3. Resolver kanonischisieren und mit entsprechender Toleranz vergleichen
4. Zusammenführen, wenn aufgelöst – ,-Flagge bei Konflikten

Keine natürliche Sprache erforderlich..-Abstimmungen werden erkannt, ,- nicht versteckt.MSC2-Cross---modale Fakten werden in ihrem gemeinsamen kanonischen Raum verglichen.

---


## Der Koordinierungszwänger

Im Teil war der Constrainer ein Gatekeeper, der : validiert, , validieren oder das , zurückweisen

Im Teil ist der Koordinationszwänger ein **Orchester**,. , es , : ,

1. **Kreuz---Validierungen**Die Signale verschiedener Spezialisten stimmen auf Fakten überein.
2. **Löst Konflikte auf**Wenn Spezialisten nicht einverstanden sind, wie man mit ? umgeht
3. **Verwaltung von Budgets**Wie viele Spezialisten können für diesen Input aufgerufen werden?
4. **Durchsetzung von Konsensschwellen**Wie viel Einigung vor der Aktion?

**Der Constrainer ist deterministisch.** Es enthält keine LLM.,... keine probabilistische Logik... keine Anrufe... jede Entscheidung folgt expliziten Regeln... das ist die architektonische Garantie, die den Rest der Musterarbeit macht.

### Die drei Schritte

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

Die wichtigsten Erkenntnisse **embeddings propose-,-Fakten entscheiden**Die Einbettung der Ähnlichkeit deutet darauf hin, dass diese Signale verwandt sein könnten.

### Die Entscheidungsfunktion

Die Constrainer-Entscheidung von ' ist deterministisch... Nein LLM...,. keine Heuristik.

1. **Kandidatengruppe** durch Einbettung von Ähnlichkeiten
2. **Filtern** durch Schema-Validität und Beweisverifizierung bereits bei der Aufnahme gemacht , aber kann re ,- ,check , ) ,
3. **Fakten lösen** in kanonischen Vergleichsraum über Resolver Registry
4. **Ergebnis der Berechnung von Vereinbarungen** pro Cluster Der Bruchteil der erforderlichen Fakten, die Resolver sind -, die über verschiedene Quellen vereinbart werden
5. **Politik anwenden**Mindestgrenze für die Vereinbarung: Mindestanzahl der Quellen: Mindestschwelle für das Vertrauen in -
6. **Aktion auswählen**Verschmelzen, wenn vereinbart, ,, degradieren, wenn nicht, falls konfiguriert, eskaliert

Jeder Schritt ist eine deterministische Funktion, jede Entscheidung erzeugt einen Audit-Rekord.

---


## Mischung von Modellen mit objektivem Feedback

Der Konsensraum ermöglicht etwas Mächtiges **unabhängiges Lernen aus geteilter objektiver Wahrheit**.

### Die Lernschleife

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

### Warum das funktioniert

1. **Entscheidungen werden zurückverwiesen**Die RAG speichert, welches Modell vorgeschlagen, was
2. **Ergebnisse sind objektiv**Deterministische Komponenten messen, was tatsächlich passiert ist
3. **Feedback wird geteilt, aber Gewichtung ist unabhängig**Jeder LLM sieht die gleichen Ergebnisdaten, entscheidet aber wie man sich anpasst

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

### Unabhängiges Lernen, geteilte Wahrheit

Jeder LLM kann die RAG anders abfragen.

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

### Die Beschränkung, die das Lernen ermöglicht

Dies funktioniert nur, weil Feedback ist **Ziel**.

Nicht deterministisches Feedback mit Deterministischem Feedback
|-------------------------------|----------------------------|
Modell Ein Gedanke, dass es gut tat, "...|.".Umwandlungsrate war 3.2%".|.
Das Modell B war mit dem Ergebnis nicht einverstanden.
Modelle argumentieren über Qualität"|.".Zusammenfassung zitierte gültige Stücke von ".|.

Die deterministische Schicht misst die Realität..-LLMs können nicht mit Messungen argumentieren..-Jedes Modell lernt aus der gleichen Grundwahrheit, passt sich aber unabhängig an seine eigene Geschichte und Prioritäten an.MSC2-

### Emergente Spezialisierung

Im Laufe der Zeit sind die Modelle natürlich spezialisiert.

- Modell A lernt, dass es bei vorsichtigen Entscheidungen ausgezeichnet wird.,. wird höher gewichtet für High--.
- Modell B lernt, dass es sich bei Randfällen auszeichnet wird aufgerufen, wenn andere unsicher sind
- Modell C lernt seine Domäne tief – wird zum Experten für diesen Signaltyp

Kein zentraler Orchestrator weist Rollen zu... Spezialisierung ergibt sich aus objektivem Feedback über die tatsächlichen Ergebnisse....

---


## Warum Frontier-Modelle dies wichtiger machen

Gegenintuitive Einsicht **bessere Modelle machen gemeinsame Substrate mehr kritisch**.

Das Risiko steigt, weil das Risiko steigt.
|---------------------|------------------------------|
Mehr Potenzial für subtile Missverständnisse
Mehr Vertrauen Überbewusste Signale verbreiten sich schneller
Mehr Versuchung zum Überspringen von Typ-Beschränkungen
Besser beim scheinbaren kohärenten Erkennbarmachen, wenn sie semantisch uneins sind

Ein Grenzmodell, das über eine natürliche Sprache mit einem anderen Grenzmodell kommuniziert, ist nicht sicherer als zwei kleine Modelle, die dasselbe tun.

Die Fixierung ist die gleiche ,: , Kraft-Kommunikation durch deterministische gemeinsame Räume , . , Das Einbettungsmodell kümmert sich nicht, wenn der Antragsteller klein oder Grenze ist , . , Gleicher Vektorraum , . , Gleiche getippte Fakten ,. , Dieselbe Einschränkungen ,

---


## Evolution ohne Bruch

Denn Kommunikation geschieht durch getippte Datensätze und geteilte Einbettungen

- Tauschen Sie Textspezialist von GPT--4.00 bis Claude, ohne andere Komponenten zu berühren
- Fügen Sie einen neuen Spezialisten hinzu, ohne bestehende zu verändern.
- Einbettungsmodell über alle Komponenten atomar aufrüsten

### Version des Einbetten-Modells

Sie möchten ein Upgrade von `all-MiniLM-L6-v2` zu `nomic-embed-text-v1.5`Aber alle Ihre gespeicherten Signale haben Einbettungen aus dem alten Modell.

**Die Lösung – :- dual---write mit mehreren Einbettungen –.-**

Weil `Embeddings` ist eine Liste von `EmbeddingRef`Migration ist einfach

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

Wesentliche Punkte

- **Jede Einbettung trägt sein ModellId-.** Keine Vermutungen
- **Dual---Write ist nur an eine Liste angehängt** Alte Leser arbeiten noch...
- **Clustervereinbarung vergleichen**Nicht rohe Kosinus-Ähnlichkeit
- **Nach der Schwelle umdrehen** (-e-.-g-.,-D-95%-gleiches --Cluster-Abkommen
- **Die Fakten sind stabil.** Selbst wenn sich die Einbettungen ändern, bleiben die eingetippten Tatsachen die Grundwahrheit.

---


## Failure Modes und Fallbacks

Dieses Muster glänzt, wenn die Dinge schief gehen Das Steuerelement-.System-Framing bedeutet, dass Ausfälle explizit und wiederherstellbar sind.

### Widersprüchliche Tatsachen

Zwei Spezialisten berichten über unterschiedliche Werte für die gleiche Tatsache Der Resolver kann sie nicht in Einklang bringen

**Ansprechen**Protokollieren Sie den Konflikt mit dem vollen Kontext.....Verschmelzen Sie nicht... Degradieren Sie die Ausgabe, um ein reduziertes Vertrauen anzuzeigen... Optional eskalieren Sie zu einem Tiebreaker.

### Fehlende oder ungültige Beweise

Ein Signal kommt mit Evidenzzeigern an, die nicht vorhanden sind.

**Ansprechen**Die vorgeschlagene Komponente wird benachrichtigt und kann mit gültigen Beweisen erneut versuchen.

### Kein Konsens

Zu wenige Signale oder zu viel Meinungsverschiedenheit, um die politische Schwelle zu erreichen.

**Ansprechen**Rückfall auf ein deterministisches Ausgangsresultat (Ausgangsweise .Auszugsweise Standardklassifikation .,Ausgangsergebnis ,Auslagerung vorheriges Ergebnis ,Austritts- oder explizite "Ungenügende Daten"Ausstiegs-).Wenn konfiguriert ,Ausgriffs-Menschung anfordern

### Sachbeweis

Der Nachweis war bei der Einnahme gültig, hat aber seitdem abgelaufen., wurde Müll gesammelt oder hatte Berechtigungen widerrufen.

**Ansprechen**:-Constrainer'-Zeit--of---Use-Kontrolle`IsStillAuthorisedAndAvailable`Das Signal wird von der aktuellen Entscheidung ausgeschlossen, wenn die Prüfungsgrundlage des " von der derzeitigen Entscheidung ausgeschlossen ist.

### Einzige Quelle des Scheiterns der Wahrheit

Das Substrat selbst ist nicht verfügbar

**Ansprechen**Keine Signale können aufgenommen oder verarbeitet werden. , System degradiert zu sicheren Standardeinstellungen oder Warteschlangen Eingänge für die spätere Verarbeitung ,. , Dies ist Infrastruktur-Ausfall , , , nicht Musterfehler , . .

Das Muster verhindert nicht Ausfälle, es macht sie **loud-,-lokalisiert und wiederherstellbar**.

---


## Checkliste für die Umsetzung

Für Teams, die Multi---Agentensysteme aufbauen

1. **EIN Einbettungsmodell wählen** für alle Komponenten
2. **Definieren Sie den Signalvertrag** (`ConstrainedSignal` + `EvidenceRef`Vor dem Bau eines Spezialisten
3. **Definition kanonischen Einheiten und Normalisierung** für alle Fakten (-ISO-Zeitstempel ,-Hexenfarben ,-WGS84-Koordinierung
4. **Bauen Sie zuerst den Konsensraum** Signal-Aggregation - Assync-Evaluierung
5. **Jeder Spezialist erzeugt Signale**Keine natürliche Sprache für andere Spezialisten
6. **Coordination Constrainer bestätigt Einigung über Fakten**Nicht embeddende Ähnlichkeit
7. **Registerbevollmächtigte** für den Vergleich der cross-Modalitäten von ( mit Farbnamen gegen Hex-, usw..)
8. **Alle Signale protokollieren** mit Zuschreibung für Debugging und Evolution
9. **objektive Messung der Ergebnisse** (-Konversionen Genauigkeit ,-Latenz
10. **Ergebnispaare speichern** in langanhaltender RAG
11. **Lassen Sie Modelle ihre eigene Geschichte abfragen** für unabhängiges Lernen
12. **Komponenten einzeln wechseln**Verifizieren von Signalen, die noch mit Schema übereinstimmen

---


## Das Substrat ist das System

Teil-Beschränkungen erzeugen nützliches Verhalten in einzelnen Komponenten.

Teil **Gemeinsame Einschränkungen schaffen kohärentes Verhalten über Komponenten hinweg**

Der Konsens-Raum ist nicht Middleware.Es ist das Substrat erweitert, wenn Spezialisten kommunizieren durch getippte Fakten statt Sprache.,... durch Evidenzzeiger anstelle von prosa.,... die Einschränkungen, die einzelne Komponenten zuverlässig machen, machen das ganze System zuverlässig.

Mehrere Antragsteller – eine gemeinsame Wahrheit – gleiches Muster – .

Die Modelle sprechen nicht miteinander, sie veröffentlichen auf dem Substrat, der Constrainer validiert, das Ergebnis wird gemessen, die RAG erinnert sich an ., jedes Modell lernt .,

**Teil Beschränkt ein ModellBeschränkt einen Teil Begrenzt die Raummodelle Teilen**

Das ist die eingeschränkte Fuzzy MoM-.

---


## Notation

- **Modelle sprechen nicht mit "** Weitere Modelle werden zugeführt.Nur Substrat-Datensätze, die Aufnahmeprüfungen bestanden.
- **Nachweise bei der Entscheidung** ist zur Autorisierung bestimmt.... nur zur Aufbewahrung.... nicht zur Richtigkeit.
- **Bewertung der Vereinbarung** Fraktion der benötigten Fakten, die resolver sind -... über unterschiedliche Quellen von ≥... Es ist deterministisch.

---


## Die Reihe

Teil - Muster - Achse - |
|------|---------|------|
| 1 | [Beschränkte Fuzziness](/blog/constrained-fuzziness-pattern) Einteilige Komponente
Dieser Artikel wurde von 2, | und ( verstopft.
| 3 | [Beschränkte Fuzzy Kontext Drackging](/blog/constrained-fuzzy-context-dragging) Zeit-Speicher (MSK)
| 4 | [Bildzusammenfassung](/blog/constrained-fuzzy-image-intelligence) Praktische Umsetzung

**Teil** schränkt eine einzelne probabilistische Komponente mit deterministischen Grenzen ein

**Teil** dehnt diese Architektur entlang der Zeitachse aus Modelle können bemerken ,, , aber Engineering entscheidet, was fortbesteht .. , Die Beschränkung wird Speicher selbst , . ,

**Teil** zeigt alle drei Muster umgesetzt in [ImageSummarizer](https://github.com/scottgal/lucidrag)Bildanalyse-Pipeline auf Basis von -, bei der mehrere Wellen Signale zu einem gemeinsamen Substrat veröffentlichen und deterministische Auswahl den Ausgang begrenzt