Del 1 beskrev en pipeline : Substrate, Förespråkare M SK2 Konsträngare МSK3 En sannolikhetskomponent MSC4 begränsad av deterministisk sanning .

Men vad händer när du har flera förespråkare ? Flera LLMs? synmodeller som talar med textmodeller? Heuristik som matas in i nervnätverk

Det är begränsad fuzzy MoM (CFMoM): begränsad val från flera proposer, validerat mot gemensam sanning. Inte " låter många modeller prata

CFMoM är ett mönster där flera sannolikhetskomponenter föreslår signaler, men bara deterministisk logik kan kombineras, validera, valida eller agera på dem.

Reglerna:

1. Modell publicerar signaler. Inga naturliga språk mellan komponenterna.
2. Substrate lagrar fakta och bevis Inskriven, schemat -validerad, med pekar till källanM SK3
3. Konsträngare bestämmer Cross-ValiderarM SK1 löser konflikter , tvingar upp tröskeln

"I multi-system är det delade substratet språket, ,, och konstrainern grammatiken.

Terminologi

Innan du dyker in i, stämda vokabulären:

Nota: Konsensutrymmet är en bus och minne, inte en arbiter . Det kan utföra inspegningM SK2 tidsvalidation ( schematMska4 bevis existeringMske5 men aldrig fattar beslutMka6 beslut lever i konstrainernMkka7

De är inte nya koncept.

Invarianter

De är olämpliga

• Bara konstrainern kan utlösa biverkningar.
• Faktum måste valideras mot schemat vid intag Avfärda annars.
• Evidens måste vara pekarlig Inga citat från tidningar.
• Signaler är oföränderliga. När den publicerades
• Canonisering sker vid ingestion Constrainer antar kanoniska fakta.
• Cross- källförtroende är inte jämförbart om det inte är kalibrerat
• Alla beslut ger ett auditregister

Vad det här inte är

CFMoM är inte en bibliotek eller ett ramverk. Det är en epistemisk regel sannolikhetskomponenter kan föreslå

Varför LLM-till-LLM kommunikation misslyckas

När två LLM kommunicerar med hjälp av naturlig språk

Semantisk drift: Varje modell tolkar lite annorlunda . Modell A säger att | " | användaren verkar frustrerad | ." | Model B läser att ♫ " | käyttäjän är arg | МSK5 | Modell C skalar upp till |" | fiendlig användaren upptäckts |

Förtygelsettorring: Modell A är | 80% | säker på något | МSK2 | Det talar om modell B i flytande prose |. | Modell B behandlar det som fakta eftersom språket låter säkert |

Förstärkning av hallucinationer: Modell A uppfinner ett trovärdigt detaljerat . Modell B bygger på det, . Modell C citerar det som etablerat

Ostabilitet i format: Modell A utsätter JSON . Ibland M SK2 Modell B tolkar det . Ibland

Instinkt är att lägga till mer drivkraft för att införa format.

Fixen tvingar all kommunikation mellan komponenterna genom ett gemensamt deterministiskt utrymme

Vad "-modeller inte talar om " betyder i praktiken

Detta är den svåra regeln.

• Modeller ingerar aldrig andra modeller Nej " sammanfatta vad Model A sa
• De äter bara upp substratrekord. som passerade schemat + beviskontroller vid intag .
• Människo---förklaring skapades sist och aldrig återförs till systemet.
• Om du hittar dig att skriva en prompt som referenserar ett annat model, du har överträdt mönstret

Det här dödar """, men min agent kan summera den andra agenten.

Signalkontraktet

I hjärtat av mönstret finns ett tryckt rekord som varje komponent måste använda.

Evidensreferenser

Först definiera vad

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

Detta är inte en sträng. Det är en pekare på verifierbar källmaterial . Varje påstående måste citera vad det är baserat på Locator ytterhandlar spans, bångboxar , tidstämpningarM SK2 eller någon annan platsskema - dess schema bestäms av Kind.

KonstrainedSignal Record

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

Varför det här fungerar

• Faktum är schema-validerad vid intag: FactsSchemaId pekar på ett schema som definierar vad palette_dominant_hue betyder ",", vilken typ den är, , , vilka enheter den använder, . , ingen affischer Dictionary<string, object>. Schemer är JSON-schemar ( eller motsvarighet till
• Kanonalisering sker vid ingestion: Stabila typar , stabila enheter, stabil normaliseringM SK3 Timmstämningar är ISO | | 8601. Färger är hex |. | Koordinatorer är WGS | МSK6 | Konstrainern antar kanoniska fakta
• Evidens är strukturerad: Indikator till verifierbar källmaterial
• Tillit är definierat: ♫ " ♫ Själva ♫ ♫- ♫ uppskattad sannolikhet att vara korrekt ♫ ". ♫ Okalibrerad självförtroende är aldrig jämförd mellan olika källor ♫
• Embeddings är optionella hjälpmedel: För att få fram och gruppa data , inte för att bevisa sanning
• De nödvändiga luckorna måste fyllas eller signalerna avfärdas. Optionella fält är tillåtna.

Ingestion: Var validering finns

Signaler är validerade och kanonialiserade när de kommer in i substratet , inte när konstrainern processar dem:

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

När konstrainern ser ett signal, så är det redan schemat, -, korrekt,,, kanonikerat, , och beviset, M SK4, bekräftat.

Evidensbekräftelsenivåer

_evidenceStore.VerifyExists gör ett verkligt arbete. Det här är nivåerna

• Det finns: Referenced chunkM SK1frame/request ID existerar i butiken
• Scope-vallig: Spansgränser | ( | Start |, | End | МSK3 | finns inom källmaterialet
• innehåll-hash match: Evidence pointer matches expected hash
• Berättelser: Ansökaren är tillåten att referensera detta bevis.

Signaler som misslyckas vid någon nivå avförs när de ingras.

Den kritiska skillnaden: Embeddings mot fakta

Det är där många multi-agentarchitecturer går fel

Embeddings ger dig en avstånds geometri som korrelerar med likhet. kraft att vara ungefär samma sak

Faktum + Evidens är sanningen.

• Tiktade mätbara kännetecken ( palettbehållare , objektidentityderM SK2 tidstämpningar)
• Evidensspetsar (chunk
• Inte att lägga in likheter enbart

Embeddinger hjälper dig att hitta signaler som kraft är ungefär samma sak. Fakter bekräftar att de är.

Ett verkligt exempel: Bot-detektor

I Bot-detektor, Detektorer för våg | 0 | och LLMs för drag |2 | kommunicerar via DetectionContribution:

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

Recording IS the constraint. The LLM cannot ramble. It must fill slotsM SK2 The UserAgent detector and the LLM produce the same shaped output . Downstream components do not need to know which one produced itMSC4

Konsensrummet

Samma substratet är inte passivt lagret. Det koordinerar aktivt signalflödet.

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

Asynkroniserad signalbehandling

Specialister väntar inte på varandra.

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

Vinniga detektörer (UserAgent check, header analysisM SK2 blockerar inte de långsamman ( LLM-analysMska4 beteendemönsterMske5 Konsensrampen samlar in signaler över tidM Ska6 tidiga signaler kan utlösa tidiga utgångar Mska7 Senare signaler raffinera eller överrida

Specialisering och djup

Med ett gemensamt signalkontrakt kan specialister fokusera på vad de gör bäst

Natural Division of Labor

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

Modära överenskommelser

Båda experterna publicerar på samma substrat med utskrivna fakta, men fakta från olika områden kan inte jämföras direkt.

När textspecialisten producerar entity_color: "blue" och bildensspecialisten skapar palette_dominant_hex: "#0000CC", hur kan man kontrollera överenskommelsenM SK1

Inte rå jämlikhet. " blå" != | | "#0000 | CC | " | som strängar

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

(De Contains Logiken ovan är illustrerande. I produktionen

Cross- skema jämförelse är omöjligt standardmässigt Du får det bara genom att registrera en explicit lösningslösning.

Koordineringskonstrainern använder en lösningsregister:

1. Använd embeddings för att sammanskilja klustersignaler ( billigt , fuzzy
2. För varje faktapar , hitta lösningen ( eller använda det förutsägda exakta
3. Resolver kanonifieras och jämförs med den lämpliga toleransen
4. Merge om löst, flagga om motsägelse

Inga naturliga språk behövs. Skillnaden är upptäckta , inte gömd. QuerskillnadM SK3 molnbundna fakta är jämförda i deras gemensamma kanoniska utrymme

Koordineringscoach

I del 1, var konstrainern en grindvakt : validera M SK2 skriva om , eller avfärda

I delen 2, är koordineringskonstrainern musiker. It:

1. Cross-validates: Är signaler från olika specialister överens om fakta?
2. Löser konflikter: När specialister inte håller med om
3. hanterar budgeter: Hur många specialister ska inkalla för denna input
4. Inspekterar konsensuss trösklar: Hur mycket överenskommelse innan handlingen

Konstrainern är deterministisk. Det innehåller inget LLM, ingen sannolikhetslogik , inga " uttalande anslutningar M SK3 Varje beslut följer specifika regler . Detta är den arkitektoniska garanteran som gör resten av mönstret att fungera

Den tre- -steppen- -övervakning

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

Den viktigaste insikten embeddings proposal, Faktum bestämmer. Embeddings likhet antyder " att de här signalerna kan vara besläktade

Beslutsfunktionen

Konsträngarens beslut är deterministiskt.

1. Gruppenkandidater genom att lägga in likhet ( Günstig klustering)
2. Filter genom validitet och bevisbekräftelse på schemat. ( görs redan vid inspetsningen, ♫ ♫ , ♫ men kan göras om igen.
3. Lösa fakta in i en kanonisk jämförelseruta via en lösningsregister
4. Beräkna överenskommelsens poäng per kluster : bråkdelen av de nödvändiga fakta som är lösbara-bestämda över M SK2N olika källor
5. Apply policy: minimalt avtalade tröskel, , minimala källantal, ,, per -, källans trovärde trösklar
6. Sektion: sammanfoga om man har kommit överens , nedgradera om det inte sker M SK2 eskalera om konfigurerat

Varje steg är en deterministisk funktion

En blandning av modeller med objektiv feedback

Konsensuven gör det möjligt att skapa något kraftfullt oberoende lärande från gemensam objektiv sanning.

Lärningsloopet

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

Varför det här fungerar

1. De besluten är tillskrivna: RAG säljer vilken modell som föreslår vad
2. Resultaten är objektiva: Deterministiska komponenter mäter vad som faktiskt hände
3. Feedback är gemensamt men viktering är oberoende: Varje LLM ser samma resultatdata men bestämmer hur den ska anpassas

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

Självständigt lärande, Samlad sanning

Varje LLM kan fråga RAG annorlunda:

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

Begränsningen som möjliggör lärande

Detta fungerar bara för att återkopplingen är objektiv.

Deterministiska lager mäter verkligheten . LLMs kan inte argumentera med mätningar. Varje modell lär sig från samma grunden, men anpassar sig självständigt baserat på sin egen historia och prioriteringar

Emergent Specialization

Med tiden specialiserar sig modellerna på naturlig väg

• Modell A lär sig att det är bättre på försiktiga beslut
• Modell B lär sig att det är bättre i randfall., blir uppmanad när andra är osäkra
• Modell C lär sig sin doma djupt. ” , ” blir experten på den signaltypen

Ingen central orkester avgör roller

Varför är Frontier-modeller viktigare?

Motintuitiv insikt: bättre modeller gör delade substrater mer kritiska, inte mindre.

Ett gränsmodell som kommunicerar med ett annat gränsmodell genom naturlig språk är inte säkrare än två små modeller som gör samma sak.

Bestämningen är densamma: kraftkommunikation genom deterministiska decentraliserade utrymmen . Embeddingsmodellen bryr sig inte om förslaget är litet eller främre

Evolution utan brytning

Eftersom kommunikation sker genom skrivna rekord och delade inbäddar

• Swap textspecialist från GPT-4 till Claude utan att röra vid andra komponenter
• Lägg till en ny specialist (audioanalysator) utan att modifiera existerande
• Gör uppgradering av inbäddade modeller över alla komponenter atomiskt

Versionering av Embedding-modellen

Du vill uppgradera från all-MiniLM-L6-v2 till nomic-embed-text-v1.5. Men alla dina lagrade signaler har inbäddar från den gamla modellen

Lösningen

För att Embeddings är en lista av EmbeddingRef, migration är enkel

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

Nyckelpunkter:

• Varje inbäddar bär sitt ModelId. Ingen gissning.
• Dual-skriver bara lägger sig till en lista Gamla läsare fungerar fortfarande.
• Vergleicha klusteröverenskommelser, inte råkosinelikhet
• Flytta efter tröskel (
• Faktum är stabila. Även om inbäddar ändras

Misslyckande Modi och Fallbacks

Det här mönstret strålar när saker går fel.. Kontrolen.

Konflikerande fakta

Två specialister rapporterar olika värden för samma fakta. Lösaren kan inte sovita ihop dem.

Svaret: Protokollera konflikten med hela sammanhanget . Merge inte samma sak . Degradera utgången för att indikera minskat självförtroende

Missande eller oäkta bevis

Ett signal kommer med bevispunkter som inte existerar

Svaret: Den avfärdar signalen när den är inlagd . Den går aldrig in i substratet

Inget konsensus

För få signaler, ,, eller för mycket oenighet för att möta gränsen

Svaret: Falla tillbaka till en deterministisk baseline ♫ ( ♫ e ♫ . ♫ g ♫ МSK3 ♫ standardklassificering ♫

Stall Evidence

Evidens var geldig vid intag men har sedan dess löst sig.

Svaret: Konsträngare, ', tid, -, av -, användandekontroll.IsStillAuthorisedAndAvailable) fångar den här punkten . Signalen är utesluten från den nuvarande päätöksen med " bevis förlösta | " | revīzijasgrund | . | Politiken kan kräva en omställning |- | analys om nytt bevis behövs | МSK6

En enda källa till sanningens misslyckande

själva substratet är inte tillgängligt.

Svaret: Rutorbrytare . Inga signaler kan intas eller behandlas. Systemen förvandlas till säkra standard eller köer med inputer för senare bearbetandeM SK3 Det här är ett infrastrukturellt misslyckande

Pattern hindrar inte misslyckanden. Det gör dem högljudd , lokaliserad, och återvinningsbar.

Implementeringskontrolllista

För teambuilding med flera agentsystem

1. välja ONE inbäddade modeller för alla komponenter (eM SK1g ., alla-MiniLMMska4LM Ska5vMka6
2. Definiera signalkontraktet (ConstrainedSignal + EvidenceRef) före att bygga någon specialist
3. Definiera kanoniska enheter och normalisering för alla fakta (ISO 8601 tidstämpningarM SK2 hex färger, WGSMska4 koordsMka5
4. Att skapa konsensus först (signal aggregation, asynkt utvärderingM SK2
5. Varje specialist producerar signaler, aldrig naturlig språk för andra specialister
6. Koordineringskonstrainer bekräftar överenskommelsen om fakta, inte lägger in likhet
7. Registrera lösningsmedel för cross-modal fakta jämförelse (färg namn vs hexMSC2 etcM SK3
8. Protokollera alla signaler med attributering för lösning och utveckling
9. mäta resultat objektivt (
10. Store beslut + utfall par i lång RAG
11. Låt modeller fråga om sin egen historia för självständigt lärande
12. Swap komponenter ett i taget, verifiera signaler som fortfarande matchar schemat

Systemet är grunden

Del 1: Begränsningar skapar ett användbart beteende i enskilda komponenter.

Del 2: Samlade begränsningar skapar ett konsekvent beteende över komponenter.

Konsensuven är inte ett mellanprogram, det är ett utvidgnet substans. När specialister kommunicerar genom dataskrivna fakta istället för språk.

Flera förespråkare . En gemensam sanning. Samma mönster

Modellen pratar inte med varandra . De publicerar dem på substratet. Konstrainern bekräftar. Utgången mätsM SK3 RAG minns . Varje modell lär sigMSC5

Del 1 begränsade en modell . Del | 2 | begränsar rymdmodellens del

Det är den begränsade fuzzy MoM.

Notation

• "Modellar inte talar = inga fria - modellernas utgångar fedras in i andra modeller M SK2 Bara substratprotokoll som har passerat ingestionskontroller
• Evidens om "-", Bekräftelse vid beslutet är tillförlitlig/ bara förbehållelse , inte korrekthet
• Fördragets poäng = en bråkdel av de nödvändiga fakta som är lösbara - som är överensfattade över ♫ ≥ ♫ N olika källor ♫. ♫ Det är deterministiskt ♫

Serien

Del 1 begränsar en enda sannolikhetskomponent med deterministiska gränser.

Del 3 sträcker ut den här arkitekturen längs tidens axeln.