Partie 1 Description d’un pipeline: Sous-strateM SK1 Proposer, ConstrainerMSC3 Une composante probabiliste , délimitée par la vérité déterministeMNK5

Mais ce qui se passe quand vous avez multiples Proposants? Multiple LLMs? Modèles de vision parlant avec des modèles de texte ? Heuristique s'alimentant dans les réseaux neuronauxM SK3

Il s’agit de MoM restreint Fuzzy (CFMoMM SK1 sélection restreinte de plusieurs proposers, validé par rapport à la vérité partagée . Non

Le CFMoM est un modèle où plusieurs composantes probabilistes proposent des signaux, mais seulement la logique déterministe peut les combinerM SK1 valider, ou agir sur euxMSC3

La règle:

1. Les modèles publient des signaux. Aucun langage naturel entre les composants.
2. Sous-strate stocke les faits et les preuves. Typed, schémaM SK1validated, avec des pointeurs vers la source .
3. Constrainer décide. Cross-validatesM SK1 règle les conflits , applique les seuils.

" Dans les systèmes multilatéraux, le substrat commun est la langue, , et le constrainer la grammaire.

---

Terminologie

Avant de plonger dans, corriger le vocabulaire:

Mandat	Importance
CFMoM	Choix restreint Fuzzy MoMM SK1 sélection restreinte de plusieurs soumissionnaires
Sous-strate	Faits + éléments de preuve + budgets
Contrat de signalisation	Comment les composants entrent dans le substrat
Éspace de consensus	Évaluation asynchrone + routage
Conseiller en coordination	Contrôleur final des actionsM SK1 sortie

Note: Consensus L’espace est un bus et une mémoire.

Ces concepts ne sont pas nouveaux.

Invariantes

Elles ne sont pas négociables.

• Seul le constrainer peut déclencher les effets secondaires.
• Les faits doivent être validés par rapport au schéma à l’ingestion. Rejet autrement.
• La preuve doit être ponctuelle-verifiableM SK1 Aucune citation de procès.
• Les signaux sont immuables. Une fois publiée, jamais modifiée .
• Canonisation se produit à l’ingestion. Constrainer assume des faits canoniques.
• Cross-la confiance dans la source n'est pas comparable à moins qu'elle ne soit calibréeM SK1
• Toutes les décisions produisent un dossier de vérification.

---

Ce qui n'est pas

Thing	Pourquoi le CFMoM est différent
Mélange d'experts (MoE)	MoE mélange les sorties du modèle de façon mathématique . CFMoM mixes signals sous contrainte avec les preuves et la politique. M SK1
Chatter de l'agent	Bon nombre de systèmes d'agents passent librement -form messages entre les composantes. Le CFMoM interdit le libreMSC3form interM SK4component messagesMska5 seuls les signaux typeurs entrent dans le substratM Ska6 M Ska7
Routage	Choix de routage quel modèle appeler. Le CMFC accepte plusieurs propositions et restreint la sélection des postes
Voting/Ensembles	Le vote suppose que les extrants sont comparables . Le MOFC exige des faits
Graphiques de style LangChain-	Graphiques transmettent des messagesM SK1 Le CFMoM publie des signaux immuables à un substrat partagé.

CFMoM n’est pas une bibliothèque ou un cadre. Il s’agit d’une règle épistemique: Les composantes probabilistes peuvent proposer, mais seulement les éléments déterministesM SK1 preuves - la logique appuyée peut se combiner ou agir.

---

Pourquoi la communication entre LLM-to-LLM échoue

Lorsque deux LLM communiquent par le biais de la langue naturelle, vous obtiendrez des échecs de combinaison. Même si chaque choc est presque correctM SK2 les erreurs se combinent plus rapidement que vous ne l’espérez

Déplacement sémantique: Chacun des modèles interprète légèrement différemment . Le modèle A dit MSC2 l'utilisateur semble frustré MSC3 Le model B lit que, à mesure que SMC4l'utilisateur est en colère MSC5 le modèle C s'élargit jusqu'à ESC6 un utilisateur hostile détecté SMC7 Trois pièges S MC8 trois interprétations MSc9 une conclusion erronée .

blanchiment de confiance: Le modèle A est 80% certain de quelque chose . Il indique le modèle B dans une prose fluente

Amplification des hallucinations: Modèle A invente un détail plausible . Le modèle B s’en bâtit sur celui-ci

Instabilité du format: Les sorties du modèle A sont JSON . Parfois. Le modèle B l’analyseMSC3 Par momentsM SK4 Des défaillances silencieuses se propagent

L’instinct est d’ajouter plus de stimulants pour faire appliquer le format. Mais les contraintes douces frappent entre les composantes tout comme elles frachent au sein des composantes.

Le fix: oblige toutes les communications intercomponentnelles de l’ensemble des composantes à travers un espace déterministe partagé.

Qu’est-ce que "Les modèles ne parlent pas" signifie dans la pratique

Il s’agit de la règle dure.

• Les modèles ne consomment jamais d’autres modèles' les sorties directementM SK1 Non "résumer ce que le modèle A a dit ".
• Ils ne consomment que des registres de substrat. qui passe le schéma + vérifie les preuves à l’ingestionM SK1
• L’explication face à l’homme- est générée la dernière fois et n’est jamais retourné au système.
• Si vous trouvez que vous écrivez un prompt qui renvoie à un autre modèle's réponse, vous avez violé le modèleM SK1

Cela tue le ", mais mon agent peut résumer l’autre agent " la trousse de détournement M SK2 Cette trousse est la façon dont commence la dérive sémantique

---

Le contrat de signalisation

Le cœur du modèle est un enregistrement type que chaque composant doit utiliser.

Références à la preuve

Premièrement, définir ce que signifie :

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

Ce n’est pas une chaîne. Il s’agit d’un pointeur vers un matériau source vérifiable . Chaque revendication doit citer ce qu’elle est fondée sur Locator , ou tout autre schéma d'emplacement - son schéma est déterminé par Kind.

Le dossier de signature restreint

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

Pourquoi cela fonctionne?

• Les faits sont schema-validés lors de l'ingestion: FactsSchemaId indique un schéma qui définit ce que palette_dominant_hue signifie, quel type il est, quelles unités il utilise . Aucun avis Dictionary<string, object>. Les schémas sont des schémas JSON ( ou équivalents), versionnés et fixés à l’écrouillage
• La canonisation se produit lors de l'ingestion: Types stablesM SK1 Unités stables≥, Normalisation stable. Les coordonnateurs sont ISO 8601. Les couleurs sont hexMska5 Les coordonnées sont WGSM Ska6 Le constrainer suppose des faits canoniquesMske7
• La preuve est structurée: Points vers des sources vérifiablesM SK1 non descriptions de prose.
• Confidence est définie: "SelfM SK2estimation de la probabilité d'exactitude". La confiance non calibrée n'est jamais comparée entre les sourcesMSC4 Dans le constrainerMska5 traiter le croisementM Ska6la confiance dans la source comme un poids seulement après l'étalonnageM ska7 utiliser par ailleurs parMka8les seuils de sourceMSKA9
• Les emplacements sont des aides facultatives.: Pour repérer et regrouper les données, non pour établir la véritéM SK2
• Les zones requises doivent être remplies ou le signal est rejeté. Des champs facultatifs sont permis.

Ingestion: Où se trouve la validation

Les signaux sont validés et canoniques lorsqu’ils pénètrent dans le substrat,, pas quand ils sont traités par le constrainerM SK1

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

À l’heure où le constérnateur voit un signal, il est déjà programmé-validM SK2 canonicalised , et les éléments de preuveMSC4 vérifiésMNK5 Le consérnateur décide seulementMST6 il ne nettoie pasMSS7

Niveaux de vérification des preuves

_evidenceStore.VerifyExists est en train d’effectuer un travail réel. Ces sont les niveaux:

• Il existe: chunk de référenceM SK1frame/request ID existe dans le magasin
• Portée-Valid: Limites d'étendue (Start, EndM SK3 sont dans le matériau de source
• Content-hash match: Le pointeur d'évidence correspond à l'attente hashM SK1version (optionnel mais recommandé)
• Permis: L'appelant est autorisé à faire référence à ces éléments de preuve.

Les signaux qui manquent à un niveau quelconque sont rejetés lors de l’ingestion. Aucune preuve partielleM SK1

La distinction critique: Embeddings vs Facts

C'est là que de nombreuses architectures multi-agentes se trompent.

Embeddings vous donner une géométrie de distance qui correspond à la similitude. Ils sont probabilistesM SK1 juste moins étonnants que les langages naturels . Deux signaux ayant des embeddings similaires le pouvoir être sur la même chose.

Faits + Evidence sont la vérité. La chose qui signifie le même " par rapport aux composants doit être

• Caractéristiques mesurables typées (carton de palette,ID d'objetsM SK2tampes horaires )
• Indicateurs de la preuve (chunk-12,cadreM SK2
• N'impliquant pas la similitude seule

Les embeddings vous aident à trouver des signaux qui le pouvoir Les faits vérifient qu’ils sont.

Exemple réelle: Détection du Bot

À l'intérieur Détection des bottes, Les détecteurs de vagues 0 et les LLM de vague 2 communiquent par DetectionContribution:

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

L’enregistrement est la contrainte. Le LLM ne peut pas rambler. Il doit remplir les espaces de défectuositéM SK2 Le détecteur UserAgent et le LLM produisent la même forme de sortieMSC3 Les composantes en aval n’ont pas besoin de savoir qui l’a produite .

---

L'espace du consensus

Le substrat partagé n'est pas un stockage passive. Il coordonne activement le flux de signaux.

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

Traitement de signaux asynchrones

Les spécialistes ne s’attendent pas les uns sur les autres. Ils transmettent des signaux à mesure qu’ils se terminent:

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

Détecteurs rapides (Contrôle de l'agent d'utilisateurM SK1Analyse des titres) ne bloquent pas les signales lentement (Analyse de la LLMMSC4Paternités comportementalesMNK5 L'espace consensuel accroît les signaux au fil du temps MNK6 Les signales précoces peuvent déclencher des sorties anticipéesMMK7 Les signaux tardifs reflètent ou superfluentMRK8

---

Spécialisation et profondeur

Avec un contrat de signalisation partagée, les spécialistes peuvent se concentrer sur ce qu’ils font le mieux.

Division naturelle du travail

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

Accord modique croisé

Les deux spécialistes publient sur le même substrat avec des données types Faits. Mais les faits provenant de domaines différents ne peuvent pas être comparés directement.

Lorsque le spécialiste du texte produit entity_color: "blue" et le spécialiste de l'image produit palette_dominant_hex: "#0000CC", comment vérifier l’entente ?

Non égalité brute. "blue" != "#0000CCM SK4 en tant que chaînesMSC5 Vous avez besoin d'un résout.

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

(Le Contains La logique ci-dessus est illustrée. Dans la productionM SK1 les résoluteurs sont enregistrés par paire de schéma + clé d’information , non héuristique sous-stringiqueMSC4

Cross-la comparaison du schéma n'est pas possible par défaut Vous n'en obtiendrez que si vous enregistrez un résout explicite. C'est une caractéristique de sécuritéM SK1 pas une limitation.

Le constrainer de coordination utilise un registre des résoluteurs:

1. Utiliser des embeddings pour regrouper les signaux (cheapM SK1 fuzzy)
2. Pour chaque paire de faits, trouver le résoluteur (ou utiliser l'exactitude par défaut -matchM SK3
3. Resolver canonicalise et comparer avec la tolérance appropriée
4. Merger si résolu, drapeau s'il est en conflit

Aucune langue naturelle n’est requise. Des désaccords sont détectés , non cachésM SK2 Cross- Les faits modaux sont comparés dans leur espace canonique communMSC4

---

Le conseiller en coordination

Dans la partie 1,, le constrainer était un gardien de porteM SK1 valider , réécrire, ou rejeterMSC4

Dans la partie 2,, le constrainer de coordination est un orchestrateur. ItM SK1

1. Cross-Validités: Les signaux des différents spécialistes sont-ils d’accord sur les faits?
2. Résoudre les conflits: Lorsque les spécialistes ne sont pas d’accord, comment procéderM SK2
3. Gestion des budgets: Combien de spécialistes doivent-ils invoquer pour cette saisie?
4. Application des seuils de consensus: Combien d’accord avant l’action?

Le constrainer est déterministe. Il n’y a pas de LLM, aucune logique probabilisteM SK1 aucun " appels d’arbitrage". Chaque décision suit des règles explicitesMST4 C’est la garantie architecturale qui fait fonctionner le reste du modèleMSC5

La vérification en trois étapes

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

Le point de vue clé: embeddings propose, Les faits déterminent. La similitude de l’incorporation suggère que " ces signaux pourraient être reliés

La fonction décisionnelle

La décision du constrainer' est déterministe . Pas de LLM, pas d'héuristiqueM SK3 pas de MSC4judgmentMST5 Voici le fluxMSP6

1. Candidats au groupe par embedding similarity (cheap clustering)
2. Filtre par vérification de la validité du schéma et des preuves ( déjà effectuée à l’ingestion , mais peut être réexaminéeM SK2check)
3. Résoudre les faits dans l'espace de comparaison canonique par le biais du registre des résoluteurs
4. Calcul de la note d'accord par grappe: la fraction des faits requis qui sont résolusM SK1convenus entre les sources distinctes ≥N
5. Appliquer la politique: seuil d’accord minimum, nombre minimal de sources , par - seuils de confiance dans les sources
6. Sélectionner l'action: fusionner s'il est convenu , dégrader si ce n'est pas le cas

Chaque étape est une fonction déterministe.

---

Mélange de modèles avec rétroaction objective

L’espace de consensus permet une chose puissante: apprentissage indépendant à partir d'une vérité objective partagée.

Le cycle d'apprentissage

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

Pourquoi cela fonctionne?

1. Les décisions sont attribuées: Le RAG indique quel modèle propose ce
2. Les résultats sont objectifs: Les composantes déterministes mesurent ce qui s’est réellement passé
3. Les commentaires sont partagés, mais le pondération est indépendante: Chaque LLM voit les mêmes données de résultat mais décide comment les ajuster

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

Apprentissage indépendant, vérité partagée

Chaque LLM peut interroger le RAG différemment:

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

Les contraintes qui permettent l'apprentissage

Cela ne fonctionne que parce que la rétroaction est Objectif.

Sans rétroaction déterministe
"Le modèle A a estimé qu’il fonctionne bienM SK2		3	4	Le taux de conversion était :
"Le modèle B n’est pas d’accord avec le résultatM SK2			\ \ "	Le Bot a été confirmé par un brouillon de miel
"Les modèles se disputent quant à la qualitéM SK2			\ "	Sommaire cité

La couche déterministe mesure la réalité. Les LLM ne peuvent pas s’opposer aux mesuresM SK1 Chaque modèle apprend de la même vérité fondamentale mais s’adapte indépendamment en fonction de sa propre histoire et de ses priorités .

Spécialisation d'urgence

Au fil du temps, les modèles se spécialisent naturellementM SK1

• Le modèle A apprend qu’il excelle dans la prise de décisions prudentes.
• Le modèle B apprend qu’il excelle dans les cas à bord, est invoqué lorsque d’autres sont incertains
• Le modèle C apprend profondément son domaine , devient l’expert pour ce type de signal

Aucun orchestrateur central n’attribue des rôles. La spécialisation découle de la rétroaction objective sur les résultats réels .

---

Pourquoi les modèles frontaliers rendent-ils cela plus important

Perception contraire à l’intuition: Les meilleurs modèles rendent les substrats partagés PLUS critiques, pas moins.

Au fur et à mesure que les modèles s’améliorent, le risque augmente car
Produits plus sophistiqués	Plus de risque d’erreur subtile
Augmentation de la confiance	Les signaux superconfidents se propagent plus rapidement
Capacités plus étendues	Tentation accrue à surmonter les contraintes de type
Améliorer la cohérence semble-t-elle	Plus difficile à détecter lorsqu’ils ne sont pas d’accord sémantiquement

Un modèle frontalier qui communique avec un autre modèle frontier par le biais de la langue naturelle n’est pas plus sûr que deux petits modèles faisant la même chose.

La solution est la même: communication de force par des espaces partagés déterministesM SK1 Le modèle d'implantation ne s'intéresse pas si le promoteur est petit ou frontalitaire. Le même espace vectoriel . Les mêmes faits typesMSC4 Les same constraintsMNK5

---

Évolution sans rupture

Parce que la communication se produit par l’entremise d’enregistrements types et de mises en place partagées:

• Swap text specialist from GPT-4 to Claude without touching other components
• Ajouter un nouveau spécialiste (audio analyzer) sans modifier ceux existants
• Améliorer le modèle d'implantation à l'échelle de tous les composants atomiquement

Versionnement du modèle d'intégration

Vous voulez mettre à niveau de all-MiniLM-L6-v2 à nomic-embed-text-v1.5. Mais tous vos signaux stockés ont des embeddings du modèle antérieur.

La solution: dual -write with multiple embeddings.

Parce que Embeddings est une liste de EmbeddingRef, la migration est directe :

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

Points clés:

• Chaque emplacement porte son ModelId. Aucune estimation.
• Dual-write est simplement attaché à une liste. Les vieux lecteurs fonctionnent encore.
• Comparaison des accords de grappe, non cosine brute similaritéM SK1
• Tourner après le seuil (eM SK1g., 95% la même,-accord de regroupement,).
• Les faits sont stables. Même si les embeddings changent, les faits types restent la vérité fondamentaleM SK1

---

Modes de défaillance et retournements

Ce modèle brille lorsque les choses vont mal. Le commandement - le cadre de système signifie que les défaillances sont explicites et récupérables.

Faits conflictuels

Deux spécialistes déclarent des valeurs différentes pour le même fait. Le résoluteur ne peut les concilierM SK1

Réponse: Inscrire le conflit dans son contexte completM SK1 Ne pas fusionner. Dégrader la sortie pour indiquer une confiance réduite . Élargir facultativement jusqu’à un brouillard de coupures M SK4un autre spécialiste ou un examen humainMSC5

La preuve manquante ou invalide

Un signal arrive avec des indicateurs de preuve qui ne sont pas existants, sont hors de portéeM SK1 ou n’ont pas été vérifiés par le hash.

Réponse: Rejet du signal lors de l’ingestion . Il ne pénètre jamais dans le substrat M SK2 La composante proposée est notifiée et peut essayer à nouveau avec des preuves valables .

Aucun consensus

Trop peu de signaux, ou trop de désaccords pour atteindre le seuil politiqueM SK1

Réponse: Retourner à une ligne de base déterministe (eMSC2gM SK3 classification par défaut, résultat antérieur cachéMska5 ou explicite mska6données insuffisantesM Ska7 réponseMka8 Si configuréM ska9 demander un examen humainMSKA10 Ne croyez jamaisMske11

Evidence inchangée

La preuve était valable à l’ingestion, mais elle a expiré depuis.

Réponse:Contrôleur de l’entraînementM SK1temps de travail-deMSC3vérification d’utilisation (IsStillAuthorisedAndAvailableLe signal est exclu de la décision en cours avec "l’état d’avancement des preuvesM SK3la raison pour laquelle on a procédé à l’audit.

Source unique de l’échec de la vérité

Le substrat lui-même est non disponible.

Réponse: Interrupteur de circuitsM SK1 Aucun signal ne peut être ingéré ou traité . Le système dégrade à des valeurs par défaut sûres ou à des lignes d'entrée pour le traitement ultérieur . Il s'agit d'un panneau de l'infrastructure

Le modèle n’empêche pas les défaillances. Il les fait hauturieux, localisésM SK1 et récupérables.

---

Liste de vérification de la mise en œuvre

Pour la construction d'équipes multi-agent systems:

1. Choisissez un modèle d'implantation pour tous les composants (eMSC1gM SK2tous-MiniLMMST4LMSS5vMS6
2. Définir le contrat de signalisation (ConstrainedSignal + EvidenceRef) avant de construire un spécialiste
3. Définir les unités canoniques et la normalisation pour tous les faits (ISO 8601 coordonnateurs de temps, couleurs hexM SK3 WGSMSC4 cordonneurs de coordons
4. Construire d'abord l'espace de consensus (agrégation de signauxM SK1évaluation asynque)
5. Chaque spécialiste produit des signaux, jamais langue naturelle à d'autres spécialistes
6. Constrainer de coordination valide l'accord sur les faits, ne met pas en place une similitude
7. Résolveurs de registres pour le croisement-comparaison des faits modaux M SK1noms de couleur vs hex, etcMSC3
8. Enregistrez tous les signaux avec l'attribution pour le débugging et l'évolution
9. Mesure objective des résultats (conversions
10. Décision d'entreposage + paires de résultats dans le RAG long-
11. Permettre aux modèles de demander leur propre histoire pour l'apprentissage indépendant
12. Échanger les composants une à la fois, vérifier que les signaux correspondent toujours au schéma

---

La stratégie est le système

Partie 1: Les contraintes créent un comportement utile dans les composantes individuelles.

Partie 2: Les contraintes partagées créent un comportement cohérent entre les composants.

L’espace de consensus n’est pas un outil de middleware. Il s’agit d’un substrat étendu. Lorsque les spécialistes communiquent par le biais d’éléments factuels plutôt que de langage typés , par des indicateurs de preuves plutôt qu’une proseM SK3, les contraintes qui rendent les composantes individuelles fiables font en sorte que l’ensemble du système soit fiable.

Plusieurs postulants. Une vérité partagée. Le même modèleM SK2

Les modèles ne parlent pas l’un avec l’autre. Ils publient sur le substrat . Le constérnateur vérifie la validité M SK2 Le résultat est mesuré

Partie 1 restreint un modèle . Partie 2 restreinte le partage des modèles spatiaux

Il s’agit du MoM . Fuzzy Constrained

---

Notation

• "Les modèles ne parlent pas 't talkM SK2 = aucune sortie libreM SK1les données du modèle sont transmises à d'autres modèles. Seulement les registres des substrats qui ont fait l'objet de vérifications d'ingestion
• Examen des preuves à la date de la décision est pour approbation/retention seulementM SK1 non correction. La correction a été établie lors de l’ingestion .
• Résultat de l'entente = fraction des faits exigés qui sont résolusM SK1convenus entre les sources distinctes≥N . Il est déterministe

---

La série

Partie	Pattern MSC2 Axe MSC3
1	Fuzziness restreinte Composante unique
2 ≥	MoM constrémenté Fuzzy	MoM restreint		Cet article
3	Traçage de contexte fuzzy restreint	Temps / mémoire
4	Sommaire de l'image	Mise en œuvre pratique

Partie 1 confine une composante probabiliste unique avec des limites déterministes.

Partie 3 Cette architecture s’étend le long de l’axe du temps.

Partie 4 montre les trois modèles mis en œuvre dans ImageSummarizer—une ondeM SK1basée sur un pipeline d'analyse de l'image où plusieurs vagues publient des signaux à un substrat partagé et la sélection déterministe restreint le résultat