Parte 1 descrive un tubo di tubature: SubstrateM SK1 Proponente, ConduttoreMSC3 Un componente probabilistico , delimitato dalla verità deterministicaMNK5

Ma cosa succede quando si ha più volte. Proponenti? Multiple LLMs? Modelli visivi che parlano con i modelli di testo ? Heuristica che alimenta le reti neuraliM SK3

Che è un MoM limitato Fuzzy (CFMoM): Selezione limitata da più proposeri., validato contro la verità condivisaM SK1 Non " lasciare che molti modelli parlino". Non guidareMSC4

Il CFMoM è un modello in cui molti componenti probabilistici propongono segnali, ma solo la logica deterministica può combinareM SK1 validare , o agire su di essi.

La regola:

1. I modelli pubblicano segnali. Nessun linguaggio naturale tra i componenti.
2. Il substrato contiene fatti e prove. Indicato, schemaM SK1validato , con puntatori alla fonte.
3. Il coordinatore decide. Cross-validate, risolve i conflittiM SK2 impongono i sogliamenti .

"In sistemi multiM SK1agenti, il substrato condiviso è la linguaMSC3 e il constrainere è la grammatica ."

Terminologia

Prima di immergersi in, correggere il vocabolario:

Nota: Consensus Spazio è un bus e una memoria, non è un arbitro. Può eseguire l'ingestioneM SK2validazione temporale (schemaMNK4 prove dell'esistenzaMKK5 ma non prende decisioniMZK6 Le decisioni vivono nel constrainerMMK7

Questi non sono concetti nuovi. Sono la parte 1 che si estende attraverso i componentiM SK2

Invarianti

Non sono négociabili.

• Solo il constrainer può attivare effetti collaterali.
• I fatti devono essere validi contro il schema durante l'ingestione. Reject otherwise.
• Le prove devono essere puntate- verificabiliM SK1 No prose citations.
• I segnali sono immutabili. Una volta pubblicato, mai modificato.
• La Canonizzazione avviene all'ingestione. Constrainer assume fatti canonici.
• Cross-La fiducia nella fonte non è comparable a meno che non sia calibrataM SK1
• Tutte le decisioni producono un rapporto di audito.

Quello che non è

CFMoM non è una biblioteca o un framework. È una regola epistemica: I componenti probabilistici possono proporre, ma solo le prove deterministicheM SK1 la logica sostenuta può combinare o agire.

Perché la comunicazione tra LLM-to-LLM fallisce

Quando due LLM comunicano attraverso il linguaggio naturale, si ottengono errori di composizione. Anche se ogni salto è più o meno correttoM SK2 gli errori si compongono più velocemente di quanto si possa aspettare

Drift semantice: Ogni modello interpreta leggermente in modo diversoM SK1 Il modello A dice " l'utente sembra frustrato ." Il Modello B legge che come "\ l'utilizzatore è arrabbiato\ ."\ Il modello C si estesa a "\ L'utilizatore ostile è stato rilevato\ ."\ Tre saltamenti\ M SK8\ Tre interpretazioni\ MSC9\ una conclusione sbagliata\ MST10\

Lavado di fiduciaIl modello A è 80% sicuro di qualcosa. Dice il modello B in prosa flessibile . Il modello B lo tratta come un fatto perché la lingua suona certaM SK4 L'incertezza viene buttata via ogni volta che salta.

Amplificazione dell'allucinazione: Il modello A inventa un dettaglio plausibile . Il Modello B lo costruisce su di esso. Il Modo C lo cita come stabilitoM SK3 L'allucinazione diventa caricoMSC4 trasportareMST5

Instabilità di formato: Il modello A produce JSONM SK1 Qualche volta. Il Modello B lo analizza . Qualcuna volta . Si propagano errori silenziosiMSC5

L'istinto è aggiungere più spinta per imporre il formato. Ma le restrizioni morbide falliscono tra i componenti proprio come falliscono dentro i componenti.

La stabilizzazione: forza tutta la comunicazione interaM SK1componente attraverso uno spazio deterministico condiviso.

Cosa significa "Modelli che non parlano" nella pratica

Questa è la regola difficile.

• I modelli non ingestiscono mai altri modelli' outputs directly. No "summare cosa ha detto il modello A ".
• Ingoiano solo i dati dei substrati. che ha passato il schema + prove di controllo all'ingestione.
• L'esplicazione dell'uomo- è generata ultimamente. e non viene mai rimessa nel sistema.
• Se vi ritrovate a scrivere un prompt che riferisce ad un altro modello, la risposta di '., avete violato il modello.

Questo uccide il ", ma il mio agente può riassumere l'altro agente.

Il contratto di segnale

Il cuore del modello è un registro digitato che ogni componente deve usare. Niente proseM SK1 Nient'altro libero-Output formaMSC3 Slot che devono essere riempitiMST4

Riferizioni alle prove

Primo, definire cosa significa "evidenceM SK2

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

Non è una stringa. E' un indicatore del materiale sorgente verificabileM SK1 Ogni affermazione deve citare ciò su cui si basa. Locator il campo manipola i spans, le scatole di piegamentoM SK1 i timmagrammi , o qualsiasi altro schema di localizzazione - il suo schema è determinato da Kind.

L'archivio del segnale limitato

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

Perché funziona?

• I fatti sono schema-validati all'ingestione.: FactsSchemaId punta a un schema che definisce cosa palette_dominant_hue significa, quale tipo èM SK1 quali unità usa. Nessun annuncio -hoc Dictionary<string, object>. I schemi sono schema JSON ( o equivalenti), versione e pinnedM SK3
• La Canonizzazione avviene durante l'ingestione.: Tipi stabiliM SK1 Unità stabile, Normalizzazione stabile~. I tasti sono ISO 8601. Le colori sono hexMNK5 Le coordinate sono WGSMRK6 Il constrainer assume fatti canoniciMMK7
• Le prove sono strutturate.: Indicatori di materiale sorgente verificabileM SK1 non descrizioni di prosa.
• La fiducia è definita.: "Self-estimazione della probabilità di correttezzaM SK3La fiducia non calibrata non viene mai confrontata tra le fontiMSC4 Nel constrainerMska5 trattare la fiducia incrociataMNK6la fiducia nella fonte come un peso solo dopo l'analisiMMK7 altrimenti usare per SNK8salti di sorgenteMRK9
• Gli imbedding sono degli aiuti opzionali.: Per recuperare e raggruppare, non per stabilire la veritàM SK2
• Le slot necessarie devono essere riempite o il segnale viene rifiutato. Sono possibili campi opzionali.

Ingestione: Dove vive la Validazione

I segnali sono validi e canonicaizzati quando entrano nel substrato, non quando vengono processati dal constrainer:

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

Fino al momento in cui il constrainer vede un segnale, è già schema- validaM SK2 canonicaizzata , e proveMSC4 verificateMSSK5 Il consTrainatore decide solo; non pulisce .

livelli di verifica delle prove

_evidenceStore.VerifyExists Sta facendo un lavoro reale. Questi sono i livelli:

• Esiste: Un blocco di riferimentoM SK1frame/l'ID della richiesta esiste nel negozio
• Scope-Valo: Limiti di Spanne (StartM SK2 End) sono all'interno del materiale sorgente.
• Contenuto-hash match: Evidence pointer matches expected hashM SK1versione (optional but recommended)
• Permissioni: L'appelante è autorizzato a riferire queste prove (per i sistemi multiM SK2tenant systems)

I segnali che mancano a qualsiasi livello vengono rifiutati all'ingestione. Niente prove partialiM SK1

La distinzione critica: L'incoraggiamento contro i fatti

Questo è il punto in cui molte architettura multi-agent vanno storte.

Inserzioni vi da una geometria di distanza che correla con la somiglianza. Sono probabilistici, solo meno agitati del linguaggio naturaleM SK2 Due segnali con embeddings simili Potenza essere più o meno la stessa cosa.

I fatti + Le prove La cosa che " significa lo stesso " per tutti i componenti deve essere :

• Attribuzioni misurabili tipificate (palette bins,ID di oggettiM SK2timetamps )
• Indicatori di prove (chunk-12,frameM SK2
• Non inserisce una singola somiglianza.

Gli inserimenti aiutano a trovare segnali che Potenza Si tratta di la stessa cosa. I fatti dimostrano che Si tratta di un sistema multifunzionale..

Esempio reale: Detezione del bot

In Detezione del botI rilevatori , Wave 0 e i LLM di Wave ≥2 comunicano attraverso DetectionContribution:

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

L'archivio è il limite. Il LLM non può ramblere. Deve riempire gli orizzontiM SK2 Il rilevatore UserAgent e il LLM producono la stessa forma di output . I componenti in avalanche non hanno bisogno di sapere quale l'ha prodotto.

Lo spazio del consenso

Il substrato condiviso non è un almacenamiento passivo. Coordina attivamente il flusso di segnali.

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

Traduzione asynchrona di segnali

Gli specialisti non si aspettano l'un l'altro. Contribuiscono ai segnali quando completano:

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

Dettatori veloci (Check dell'agente d'utente,analisi dei titoliM SK2 non bloccano quelli lenti (analisi del MLMMska4 modelli comportamentaliMske5 L'area consensuale accumula i segnali nel tempoMSC6 I segnali precoci possono provocare la decommissione precoceMNK7 I signali tardi riparano o superano l'autorizzazioneMK8

Specializzazione e profondità

Con un contratto di segnale condiviso, gli specialisti possono concentrarsi su ciò che fanno meglio.

Divisione naturale del lavoro

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

Accordo Cross-Modale

Entrambi specialisti pubblicano su lo stesso substrato con i dati inviati. Ma i dati provenienti da domeni diversi non possono essere confrontati direttamente.

Quando il specialista del testo produce entity_color: "blue" E l'immagine specialista produce. palette_dominant_hex: "#0000CC", come si verifica l'accordo?

Non uguaglianza cruda. "blueM SK1 != "#0000CC" come se fossero delle stringheMSC5 Avete bisogno di un risolvitore.

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

(La Contains La logica precedente è illustrativa. In produzione, i risolventi sono registrati da una coppia di schemi M SK2 la chiave di fatto , non l'euristica substringaleMSC4

Cross-la comparazione del schema è impossibile per défaut. Lo si ottiene solo registrando un risolvente esplicito. Questa è una funzione di sicurezza, non una limitazioneM SK2

Il constrainer di coordinazione usa un registro di risolvitori:

1. Utilizzate degli embedding per mettere insieme i segnali di un gruppo (cheapM SK1 fuzzy)
2. Per ogni coppia di fatti, trovate il risolvatore (o usate l'esatto predefinito -matchM SK3
3. I solventi canonicalizzano e si confrontano con una tolleranza adeguata.
4. Unire se risolveto, bandiera se contraddittorio

Non c'è bisogno di linguaggio naturale. I discorsi sono rilevati, non nascostiMSC2 CrossM SK3 i fatti modali vengono confrontati nel loro spazio canonico condiviso .

Il coordinatore

Nella parte 1, il constrainer era un guardiano della portaM SK1 validare, riscrivereMSC3 o rifiutare .

Nella parte 2, il constrainer di coordinazione è un orchestratore. It:

1. Cross-Validità: I segnali provenienti da diversi specialisti sono d'accordo su fattiM SK1
2. Risolve conflitti.: Quando i specialisti non sono d'accordo, come procedereM SK2
3. Gestisce i budget.: Quanti specialisti dovremmo chiamare per questo input?
4. Si applicano soglia di consenso.: Quanto consenso prima dell'azione?

Il constrainer è deterministico. Non contiene nessun LLM, nessuna logica probabilistica, niente MSC2 chiamate di giudizioM SK3 Ogni decisione segue regole espliciteMST4 Questa è la garanzia architettonica che fa funzionare il resto del modelloMSV5

La verifica in tre fasi

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

Il punto di vista chiave: Proporzione di inserzioni, Decideno i fatti. La somiglianza embedding suggerisce " Questi segnali potrebbero essere correlatiM SK2 La comparazione dei fatti conferma " questi segnali sono d'accordo."

La funzione decisionale

La decisione del constrainer' è determinista. No LLMM SK2 no heuristicsMSC3 no MST4judgmentMSV5 Ecco il flussoMSS6

1. Candidati di gruppo (cheap clustering)
2. Filtrare per verificare la validità del schema e le prove ( già fatto all'ingestioneM SK1 ma può ri-controllareMSC3
3. Risolvere i fatti In uno spazio di comparazione canonico attraverso il registro dei risolvatori.
4. Computare il punteggio dell'accordo. per gruppo: la frazione di fatti necessari che sono risoltiM SK1consenti tra ≥N fonti diverse.
5. Applicare la politica: minima soglia di consensoM SK1 minimo numero delle fonti, per - soglia della fiducia nelle fonti
6. Selezionare l'azione: fusione se accettatoM SK1 degradazione se non approvato , escalazione se configurata

Ogni passo è una funzione deterministica. Ogni decisione produce un registro di audito.

Mistura di modelli con feedback oggettivo

L'area consensuale consente qualcosa di potente: L'apprendimento indipendente da una verità oggettiva condivisa.

La spirale dell'apprendimento

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

Perché funziona?

1. Le decisioni sono attribuite.: Il RAG si chiede quale modello abbia proposto cosa.
2. I risultati sono oggettivi.: Componenti deterministice misurano cosa è successo davvero.
3. Il feedback è condiviso, ma il weighting è indipendente.: Ogni LLM vede gli stessi dati sul risultato ma decide come adattarlo.

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

L'apprendimento indipendente, La verità condivisa

Ogni LLM può fare una domanda diversa al RAG:

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

Il vincolo che permette l'apprendimento

Questo funziona solo perché il feedback è obiettivo.

La stratagemma determinista misura la realtà. I LLM non possono discutere con le misurazioni. Ogni modello impara dalla stessa verità ma si adatta indipendentemente basandosi sulla propria storia e sulle sue prioritàM SK2

Specializzazione emergente

Nel tempo, i modelli si specializzano naturalmente:

• Il modello A impara ad essere eccezionale nelle decisioni prudenti, viene weighted higher for high-stakes inputs
• Il modello B impara ad essere eccellente nei casi marginali, viene invocato quando gli altri sono incerti.
• Il modello C impara il suo dominio profondamente, diventa l'esperto per quel tipo di segnale.

Nessun orchestratore centrale assegna ruoli. La specializzazione emerge dal feedback oggettivo sui risultati reali.

Perché i modelli Frontier lo rendono più importante

Percezione controintuitiva: I migliori modelli rendono i substrati condivisi più critici, non meno.

Un modello frontiere che comunica con un altro modello frontiera attraverso il linguaggio naturale non è più sicuro di due piccoli modelli che fanno lo stesso. I modi di fallimento sono più sofisticati, non eliminatoM SK2

La soluzione è la stessa: comunicazione di forza attraverso spazi condivisi deterministici. al modello embedding non importa se il proponente è piccolo o frontiereM SK2 lo stesso spazio vettoreMSC3 Lo stesso tipo di fattiMST4 Gli stessi limitiMSS5

Evolution senza fratture

Perché la comunicazione avviene attraverso registrazioni stampate e inserzioni condivise:

• Swap text specialist from GPT-4 to Claude senza toccare altri componenti
• Add new specialist (audio analyzer) without modifying existing ones
• Riparare il modello di embedding su tutti i componenti a livello atomico.

Versionare il modello di embedding

Volete aggiornare da all-MiniLM-L6-v2 All'incirca. nomic-embed-text-v1.5. Ma tutti i vostri segnali memorizzati hanno inserzioni del vecchio modello.

La soluzione: dual-write with multiple embeddingsM SK2

Perché Embeddings è una lista di EmbeddingRef, la migrazione è semplice:

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

punti chiave:

• Ogni inserzione ha il suo ModelId. Senza indovinare.
• Duale-write sta solo appendendo a una lista. I vecchi lettori lavorano ancora.
• Confrontare l'accordo di gruppo, non somiglianza di cosine brutteM SK1
• Girare dopo il soffitto (eM SK1g., 95% ugualeMST4accordo di gruppoMSST5
• I fatti sono stabili. Anche se le inserzioni cambiano, i dati tipizzati rimangono la verità fondamentaleM SK1

Mode di fallimento e fallimenti

Questo schema brilla quando le cose vanno storte. Il controllo-il sistema di montaggio significa che i fallimenti sono espliciti e recuperabiliM SK2

Fakti contraddittivi

Due specialisti riportano valori diversi per lo stesso fatto. Il risolvente non li può conciliare.

Risponsione: Registrare il conflitto con il contesto completo. Non unireM SK2 Degradare la produzione per indicare una riduzione della fiduciaMSC3 Escalare opzionalmente ad un breaker (un altro specialista o revisione umanaMST5

Esempi scomparsi o invalidi

Un segnale arriva con dei puntatori di prove che non esistono, sono fuori campo di applicazioneM SK1 o non riescono a verificare l'hash.

Risponsione: Rimetta il segnale all'ingestione. Non entra mai nel substratoM SK2 Il componente proposto è avvisato e può riprovare con prove valide.

Nessun consenso.

Troppo pochi segnali, o troppe divergenze per raggiungere il punto limite della politica.

Risponsione: Tornare a una linea di base deterministica (e.gM SK3 classificazione predefinitaMSC4 risultato precedente archiviatoMST5 o esplicitato "dati insufficientiMS" rispostaM). Se configurataSSM9 chiedere un'analisi umanaMSSM10 Non indovinare maiMSS11

La prova stalla

Le prove erano valide al momento dell'ingestione ma sono passate da quando è finita la validità, è stato spazzaturaM SK1 è stata raccolta, o le autorità sono state revocateMSC3

Risponsione:ConstruitoreM SK1il tempo -di-controllo dell'uso (IsStillAuthorisedAndAvailable) cattura questoM SK1 Il segnale è escluso dalla decisione attuale con "la prova staccata"la ragione della revisioneMSC4 La politica può richiedere una riconsiderazioneMST5l'analisi se servono prove nuoveMSV6

Una sola fonte di fallimento della verità

Il substrato stesso non è disponibile.

Risponsione: Interruttore intermittente. Nessun segnale può essere ingettato o processatoM SK2 Il sistema si degrada a valori di default sicuri o a quei input in fila per il ulteriore processo . Si tratta di un fallimento dell'infrastrutturaMSC4 non di uno fallimento del modelloMST5

Il modello non impedisce i fallimenti. Li fa forte, localizzato, e recuperabile.

Lista di controlli per la implementazione

Per le squadre che costruiscono sistemi multi-agenti:

1. Scelgono ONE modello di inserzione. per tutti i componenti (eM SK1g., tuttiMSL3MiniLMMST4LMSV5vMSS6
2. Definire il contratto del segnale. (ConstrainedSignal + EvidenceRef) prima di costruire un specialista
3. Definire le unità canoniche e la normalizzazione per tutti i fatti (ISO 8601 tasti temporaliM SK2 colori hex, WGSMska4 coordinateMske5
4. Costruire prima lo spazio di consenso. (agregazione di segnaliM SK1evaluazione asynca)
5. Ogni specialista produce segnali., mai linguaggio naturale per altri specialisti
6. Coordinazione constrainer valida l'accordo sui fatti, non inserisce una somiglianza
7. Registrare i risolventi per la croce-comparazione di fatti modali M SK1nomi di colore vs hex, ecc.
8. Registrare tutti i segnali con l'attribuzione per la debugging e l'evoluzione.
9. misurare i risultati in modo oggettivo. (conversioniM SK1 precisione, latenzaMSC3
10. Store decision + outcome pairs in RAG lungo-in funzione.
11. Lasciate che i modelli chiedano la propria storia. per l'apprendimento indipendente.
12. scambiare componenti uno alla volta, verificare i segnali che corrispondono ancora al schema.

Il substrato è il sistema

Parte 1: Le restrizioni creano un comportamento utile in singoli componenti.

Parte 2: Constrizioni condivise creano un comportamento coerente tra i componenti.

Lo spazio di consenso non è un middleware. È il substrato esteso. Quando gli specialisti comunicano tramite dati tipocati invece che attraverso la lingua , attraverso indicatori di prove invece che tramite proseMSC3 le restrizioni che rendono affidabili i singoli componenti rendono affidabile l'intero sistemaM SK4

Molti proponenti. Una verità condivisa. Lo stesso schemaM SK2

I modelli non parlano l'un con l'altro. Loro pubblicano al substrato. Il constrainer lo verificaM SK2 Il risultato viene misuratoMSC3 Il RAG ricordaMST4 Ogni modello imparaMSV5

Parte 1 restringe un modello. Parte \2 restringisce la condivisione dei modelli spazialiM SK3

Questo è il Restritto Fuzzy MoM.

La notazione

• "Modelli non usano 'non parlano = nessuna libera-formi di output dei modelli vengono inserite in altri modelliM SK2 Solo le registrazioni sui substrati che passano i controlli dell'ingestione .
• Evidenza ri-verificazione alla decisione-tempo è per l'autorizzazione/ solo conservazione , non correttezzaM SK2 La correttività è stata stabilita all'ingestione.
• Il punteggio dell'accordo = frazione di fatti necessari che sono risolvibili-consenti tra ≥N fonti diverseM SK3 E' deterministicoMSC4

La serie

Parte 1 restringe un singolo componente probabilistico con limiti deterministici.

Parte 3 Questa architettura si estende lungo l'asse temporale. I modelli possono notare, ma l'ingegneria decide cosa persistaM SK2 Il vincolo diventa la memoria stessa .