Back to "एजेंट चैटर पर संबन्धित अस्पष्ट MoM: संकेत संविदाएं"

This is a viewer only at the moment see the article on how this works.

To update the preview hit Ctrl-Alt-R (or ⌘-Alt-R on Mac) or Enter to refresh. The Save icon lets you save the markdown file to disk

# एजेंट चैटर पर संबन्धित अस्पष्ट MoM: संकेत संविदाएं

<datetime class="hidden">2026-01-06T15:00</datetime>

[भाग 1](/blog/constrained-fuzziness-pattern) एक पाइपलाइन का वर्णन किया गया: उपstrateM SK1 प्रस्तावक, कंसट्रेनर . एक संभाव्यात्मक घटकMSC4 निर्धारणात्मक सत्य से घेरे हुए

लेकिन क्या होता है जब आप *बहुविध* प्रस्तावक? बहुल LLMs? दृश्य मॉडल पाठ मॉडल से बात करने के लिए ? तंत्रिका नेटवर्कों में फीडिंग हाइउरिसिक्स

यह संकीर्ण अस्पष्ट मोएम है (CFMoM): **अनेक प्रस्तावकों से सीमित चयन**साझा सत्य के विरुद्ध वैध किया गया।

> *एफसीएमओएम एक ऐसा पैटर्न है जहां बहुसंभाव्यात्मक घटक संकेतों को प्रस्तावित करते हैं, लेकिन केवल निर्णायक तर्क संयोजन कर सकता है*

नियम

1. **मॉडल संकेत प्रकाशित करते हैं** घटकों के बीच कोई प्राकृतिक भाषा नहीं
2. **उपstrate तथ्यों और साक्ष्यों को भंडारित करता है** टाइप किया गया, स्कीमा
3. **कंस्ट्रेनर decides.** क्रॉस

> बहुविध में अभिकर्ता प्रणालियों में साझा आधार भाषा है और अनुप्रवर्तक व्याकरण है

[TOC]

---

## शब्दावली

में डुबोने से पहले शब्दावली निश्चित करें

| अवधि | अर्थ |
|------|---------|
| **सीएफएमओएम** | प्रतिबंधित अस्पष्ट MoM: अनेक प्रस्तावकों से प्रतिबंधित चयन
| **उपstrate-type** तथ्य
| **संकेत संविदा** अवयव substrate में कैसे लिखते हैं
| **सहमति अंतरिक्ष** स्टोर + रूटिंग
| **समन्वय कंस्ट्रेनर** क्रियाओं के लिए अंतिम द्वारपाल

**नोट** सहमति अंतरिक्ष एक बस और स्मृति है।

ये नई अवधारणाएं नहीं हैं।

### अपरिवर्तक

ये गैर-negotiable हैं

- **केवल कंस्ट्रेनर side effects को ट्रिगर कर सकता है**
- **तथ्यों को इंजेक्शन पर स्कीमा के विरुद्ध वैध होना चाहिए** अन्यथा अस्वीकार करें
- **प्रमाण संकेतक होना चाहिए** कोई गद्य उद्धृति नहीं
- **संकेत अपरिवर्तनीय हैं** एक बार प्रकाशित
- **पाचन में कैनोनिकलीकरण होता है** कंसट्रेनर canonical facts को मानता है
- **Cross-स्रोत विश्वसनीय नहीं है जब तक न कैलिब्रेटेड**
- **सभी निर्णयों से एक लेखापरीक्षा रिकार्ड बनाता है**

---

## क्या यह नहीं है

बात | क्यों CFMoM भिन्न है
|-------|------------------------|
| **विशेषज्ञों का मिश्रण** | मोई मॉडल आउटपुट को गणितीय रूप से मिश्रित करता है *प्रतिबंधों के तहत संकेत* प्रमाण और नीति के साथ
| **एजेंट चैटर** कई एजेंट प्रणालियां मुक्त रूप से गुजरती हैं।
| **रूटिंग** | रूटिंग चयन करता है *जिस मॉडल को बुलाना है*सीएफएमओएम बहुविध प्रस्ताव स्वीकार करता है और चयन पद को प्रतिबंधित करता है
| **मतदान** | मतदान से अनुमान लगाया जाता है कि आउटपुट तुलनात्मक हैं
| **लंगचैन---शैली ग्राफ** | ग्राफ संदेश पास करते हैं. CFMoM एक साझा सतह पर अपरिवर्तनीय संकेत प्रकाशित करता है

CFMoM एक लाइब्रेरी या फ्रेमवर्क नहीं है **संभाव्यात्मक घटकों को प्रस्तावित कर सकते हैं, लेकिन केवल निर्णायक खंडों को दर्शाता है**

---

## क्यों LLM-to-LLM संचार विफल है

जब दो एलएलएम प्राकृतिक भाषा के माध्यम से संचार करते हैं

**अर्थ-विचलन**प्रत्येक मॉडल थोड़ा अलग-अलग व्याख्या करता है।

**विश्वसनीयता धोना**मॉडल ए एक बात के बारे में निश्चित है।

**भ्रम संवर्धन**मॉडल ए एक सच्चे विवरण का आविष्कार करता है मॉडल बी इस पर बनाता है मॉडल सी इसे स्थापित के रूप में उद्धृत करता है

**ढाँचा अस्थिरता**मॉडल ए आउटपुट JSON

ढाँचा को लागू करने के लिए अधिक प्रोत्साहन जोड़ना स्वाभाविक है

एक साझा निर्णायक अंतरिक्ष के माध्यम से सभी अंतःसमूह संचार को बाध्य करता है

### क्या " मॉडल व्यवहार में बात नहीं करते

यह कठिन नियम है

- **नमूने कभी अन्य नमूनाओं को प्रत्यक्ष रूप से इंजेस्टर नहीं करते** क्या मॉडल ए ने कहा summarise
- **वे केवल अवयव रिकॉर्ड ingest** जिसने स्कीमा को पास किया है + इंजेक्शन पर साक्ष्य जांच
- **मानव-मुखी व्याख्या अंतिम रूप से उत्पन्न की गई है** और कभी भी प्रणाली में वापस नहीं दिया जाता है
- **यदि आप स्वयं को एक प्रॉ prompt कि अन्य मॉडल को संदर्भित लिखने के लिए मिल जाता है**आपने पैटर्न को तोड़ दिया है

यह मारता है ", लेकिन मेरी एजेंट अन्य एजेंट का सारांश कर सकता है

---

## संकेत संविदा

पैटर्न का हृदय एक टाइप किए गए रिकार्ड है कि प्रत्येक घटक को प्रयोग करना चाहिए।

### साक्ष्य संदर्भ

पहला , क्या परिभाषित करता है

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

यह एक स्ट्रिंग नहीं है। `Locator` क्षेत्र हैंडल स्पैन, बंडिंग बाक्सों, समयtampsM SK2 या किसी अन्य स्थान योजना MSC3 इसकी योजना द्वारा निर्धारित की जाती है `Kind`.

### प्रतिबंधित हस्ताक्षर अभिलेख

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

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

### यह क्यों काम करता है

- **तथ्य schema-प्रसव पर वैध हैं**: `FactsSchemaId` एक स्कीमा कि क्या परिभाषित करने के लिए संकेत करता है `palette_dominant_hue` इसका मतलब है कि यह किस प्रकार का है `Dictionary<string, object>`. स्कीमा JSON स्किमा है | या समतुल्य | ), | संस्करणित और पिन्ड |
- **पाचन में कैनोनिकलीकरण होता है**स्थिर प्रकारें1 स्थिर इकाइयां2 स्थिर मानकीकरण3 समय स्टाम्प आईएसओ हैं4 रंग हेक्स है5 निर्देशांक WGS हैं6 कंसट्रेनर मानक तथ्यों को मानता है7
- **साक्ष्य संरचनात्मक है**: सत्यापनीय स्रोत सामग्री के लिए संकेतक
- **विश्वसनीयता परिभाषित है**: "Self-estimated probability of correctnessM SK3 Uncalibrated confidence is never compared across sourcesMSC4 In the constrainerMSP5 treat crossMST6source confidence as a weight only after calibrationM ST7 otherwise use perM st8source thresholdsMst9
- **एम्बेडिंग वैकल्पिक सहायक हैं**पुनःप्राप्ति और समूहन के लिए , सत्य स्थापित करने के लिए नहीं
- **वांछित स्लॉट भरे जाने चाहिए या संकेत अस्वीकृत किया जाता है** वैकल्पिक क्षेत्र स्वीकार्य हैं

### इनग्रेज़न: जहाँ वैधीकरण रहता है

संकेतों को सत्यापित और कैनोनिकीकृत किया जाता है जब वे अवयव में प्रवेश करते हैं

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

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

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

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

जब कंस्ट्रेनर एक संकेत देखता है, तो यह पहले से ही स्कीमा है।

### साक्ष्य सत्यापन स्तर

`_evidenceStore.VerifyExists` वास्तविक कार्य कर रहा है

- **मौजूद है**: संदर्भित खंड/फ्रेमM SK2अनुरोध आईडी भंडार में मौजूद है
- **Scope-valid**: स्पैन किनारे
- **सामग्री-hash मैच**: Evidence pointer matches expected hash
- **अनुमतियाँ**कॉलर को इस साक्ष्य को संदर्भित करने की अनुमति दी जाती है

कोई भी स्तर असफल होने वाले संकेतों को इंजेक्शन पर अस्वीकृत किया जाता है

### महत्वपूर्ण विभेद: तथ्यों की तुलना में सम्मिलन

यह है जहाँ बहुत से बहुअभिकर्ता अभियांत्रिकी गलत हो जाते हैं

**सम्मिलित** आप को एक दूरी ज्यामिति जो समानता के साथ संगत करता है। *शक्ति* एक ही बात के बारे में होना

**तथ्य + साक्ष्य** यह बात है कि "में एक ही मतलब है, सभी अवयवों में " होना चाहिए

- टाइप किए मापन योग्य विशेषताएँ (पलेट बिन्सM SK1 ऑब्जेक्ट IDs, टाइमस्टैम्प्स )
- प्रमाण संकेतक
- एकल समानता सम्मिलित नहीं कर रहा है

एम्बेडिंग आपको संकेत खोजने में मदद करता है कि *शक्ति* एक ही बात के बारे में होना चाहिए *हैं*.

### वास्तविक उदाहरण

में [बोट खोज](/blog/botdetection-introduction), तरंग 0 डिटेक्टर और तरंग (Wave) | 2 | LLMs के माध्यम से संचार `DetectionContribution`:

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

रिकार्ड अवरोध है. एलएलएम रैमबल नहीं कर सकता है . यह स्लॉट भरना चाहिए. उपयोक्ता एजेंट डिटेक्टर और LLM एक ही आकार के आउटपुट का उत्पादन करते हैं\. डाउनस्ट्रीम घटकों को यह जानने की जरूरत नहीं है कि किसने इसे बनाया है

---

## सर्वसम्मति अंतरिक्ष

साझा अवयव निष्क्रिय भंडारण नहीं है

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

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

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

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

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

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

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

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

### अतुल्यकालिक संकेत प्रक्रमण

विशेषज्ञ एक-दूसरे की प्रतीक्षा नहीं करते

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

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

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

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

त्वरित डिटेक्टर (UserAgent जाँच, हेडर विश्लेषणM SK2 धीमी संकेतों पर अवरोध नहीं करता है।

---

## विशेषज्ञता और गहराई

एक साझा संकेत संविदा के साथ-साथ विशेषज्ञ अपने सर्वोत्तम कार्य पर ध्यान केंद्रित कर सकते हैं

### प्राकृतिक श्रम विभाग

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

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

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

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

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

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

### क्रॉस-एमएसके0-मोडल करार

दोनों विशेषज्ञ एक ही आधार पर टाइप किए हुए तथ्यों के साथ प्रकाशित करते हैं

जब पाठ विशेषज्ञ बनाता है `entity_color: "blue"` और छवि विशेषज्ञ उत्पादित करता है `palette_dominant_hex: "#0000CC"`आप करार को कैसे सत्यापित करते हैं

**कच्चे समानता नहीं** à¤•à¥à¤°à¥‡à¤‚

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

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

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

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

*(द `Contains` उपरोक्त तर्क अनुकरणीय है. उत्पादन में, समाधानकर्ता स्किमा युग्म द्वारा पंजीकृत होते हैं*

**स्कीमा तुलना डिफ़ॉल्ट द्वारा असंभव है** यह एक सुरक्षा विशेषता है

समन्वय कंस्ट्रेनर एक हलकर्ता रजिस्ट्री का उपयोग करता है

1. समूह संकेतों को एक साथ सम्मिलित करने के लिए एम्बेडिंग का उपयोग करें
2. प्रत्येक तथ्य युग्म के लिए , हलकर्ता को ढूंढें या डिफ़ॉल्ट सही का उपयोग करें
3. रिसोल्वरों को कैनोनिकास कर दें और उचित सहिष्णुता के साथ तुलना करें
4. यदि हल किया गया है तो मिलाएँ, फ्लैग यदि विरोध करता है

कोई प्राकृतिक भाषा की आवश्यकता नहीं है

---

## समन्वय कंसट्रेनर

भाग में 1, कंस्ट्रेनर एक गेटकीपर था

भाग 2, में समन्वय कंस्ट्रेनर एक है **वाद्यकार**0 यह

1. **क्रॉस**क्या विभिन्न विशेषज्ञों से संकेत तथ्यों पर सहमत हैं
2. **विवादों को हल करता है**: जब विशेषज्ञ आपस में मतभेद करते हैं
3. **बजट का प्रबंधन करता है**कितनी विशेषज्ञों को इस इनपुट के लिए पुकारा जाना है
4. **सहमति सीमाओं को लागू करता है**: कार्रवाई से पहले कितनी सहमति है

**कंस्ट्रेनर डेमोनिस्टिक है** इसमें कोई LLM नहीं है।

### तीन चरण सत्यापन

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

प्रमुख अंतर्दृष्टि **embeddings प्रस्ताव**. सम्मिलित समानता से यह संकेत मिलता है कि "ये संकेत संबद्ध हो सकते हैं

### निर्णय फ़ंक्शन

कंसट्रेनर का निर्णय निर्णायक है।

1. **समूह उम्मीदवार** समानता सम्मिलित करके (चाप क्लस्टरिंग
2. **फ़िल्टरComment** स्कीमा वैधता और साक्ष्य सत्यापन द्वारा
3. **तथ्यों को हल करना** हलकर्ता रजिस्ट्री के माध्यम से मानक तुलना स्थान में
4. **करार स्कोर गणना करें** प्रति क्लस्टर: आवश्यक तथ्यों की भिन्नता है, जो हल करने के लिए हैं
5. **नीति लागू करें**: न्यूनतम समझौता थ्रेसहोल्ड
6. **क्रिया चुनें**यदि सहमत हो तो : विलीन करें

प्रत्येक चरण एक निर्णायक कार्य है

---

## उद्देश्यात्मक प्रतिक्रिया के साथ मॉडलों का मिश्रण

सर्वसम्मति अंतरिक्ष कुछ शक्तिशाली करता है **साझा वस्तुनिष्ठ सत्य से स्वतंत्र सीखना**.

### सीखने का लूप

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

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

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

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

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

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

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

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

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

### यह क्यों काम करता है

1. **निर्णय दिए जाते हैं**: RAG स्टोर्स जो मॉडल प्रस्तावित क्या
2. **परिणाम निष्पक्ष हैं**: निर्णायक घटक क्या वास्तव में हुआ मापते हैं
3. **फीडबैक साझा किया जाता है लेकिन वज़न स्वतंत्र है**: प्रत्येक एलएलएम एक ही परिणाम डेटा देखता है लेकिन कैसे समायोजन करने का निर्णय करता है

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

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

### स्वतंत्र शिक्षण

प्रत्येक LLM RAG को अलग से क्वेरी कर सकता है

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

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

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

### वह अवरोध जो सीखने को सक्षम बनाता है

यह सिर्फ काम करता है क्योंकि फीडबैक है **उद्देश्यपूर्ण**.

निर्णायक पृष्ठपोषण के बिना |
|-------------------------------|----------------------------|
मॉडल ए ने सोचा कि यह अच्छा करता है
मॉडल बी परिणाम से असहमत था
मॉडल गुणवत्ता के बारे में बहस करते हैं

निर्णायात्मक परत वास्तविकता को मापती है

### आपात विशेषज्ञता

समय के साथ-साथ मॉडल स्वाभाविक रूप से विशिष्ट होते हैं

- मॉडल ए सीखता है कि यह सावधानीपूर्ण निर्णयों में श्रेष्ठ है
- मॉडल बी सीखता है कि यह किनारे के मामलों में श्रेष्ठ है
- मॉडल सी अपने डोमेन को गहराई से सीखता है-, उस संकेत प्रकार के लिए विशेषज्ञ बन जाता है

कोई केंद्रीय वादक भूमिकाओं को निर्दिष्ट नहीं करता

---

## why Frontier models make this more important

प्रतिintuitive अंतर्दृष्टि **बेहतर मॉडल साझा सतहों को अधिक महत्वपूर्ण बनाते हैं**.

| जैसे कि मॉडलों में सुधार होता है
|---------------------|------------------------------|
अधिक परिष्कृत आउटपुट
अधिक विश्वसनीय संकेत तेजी से प्रसारित होते हैं
व्यापक क्षमताएं | टाइप प्रतिबंधों को छोड़ने के लिए अधिक आवेग
सुसंगत दिखने में बेहतर

एक सीमांत मॉडल प्राकृतिक भाषा के माध्यम से दूसरे सीमांत नमूने के साथ संचार करने के लिए दो छोटे नमूना एक ही कर रहे हैं से अधिक सुरक्षित नहीं है

स्थिर एक ही है: निर्णायक साझा स्थानों के माध्यम से बल संचार . अंतःकरण मॉडल का ध्यान नहीं है यदि प्रस्तावक छोटा या सीमांत है

---

## विच्छेदन बिना एवोल्यूशन

क्योंकि संचार टाइपेड रिकार्ड और साझा एम्बेडिंग के माध्यम से होता है

- अन्य घटकों को छूते बिना GPT-4 से Claude में पाठ विशेषज्ञ बदलें
- नए विशेषज्ञ जोड़ें (audio analyzer) मौजूदा को परिवर्धित किए बिना
- सभी घटकों पर एटमोनिक रूप से एम्बेडिंग मॉडल अद्यतन करें

### सम्मिलन मॉडल को संस्करणित करना

आप से अद्यतन करना चाहते हैं `all-MiniLM-L6-v2` के लिए `nomic-embed-text-v1.5`लेकिन आपके सभी भंडारित संकेतों में पुराने मॉडल से एम्बेडिंग है

**समाधान: dual-write with multiple embeddings**

क्योंकि `Embeddings` एक सूची है `EmbeddingRef`माइग्रेशन सीधा है

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

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

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

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

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

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

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

प्रमुख बिंदुएं

- **प्रत्येक एम्बेडिंग अपने मॉडल आईडी लेता है** कोई अनुमान नहीं
- **सिर्फ एक सूची में जोड़ रहा है** पुराने पाठक अभी भी काम कर रहे हैं
- **समूह करार की तुलना करें**, नकली कोसाइन समानता नहीं है
- **थ्रेसहोल्ड के बाद फ्लिप करें** (,e,.,g, .,,95%,सही,M SK4,कुलर समझौता
- **तथ्य स्थिर हैं** अगर एम्बेडिंग बदलता है तो भी टाइप किए गए तथ्य आधार सत्य बने रहते हैं

---

## असफल मोड और फेलबैक

जब कुछ गलत हो जाता है तो यह पैटर्न चमकता है

### परस्पर विरोधी तथ्य

दो विशेषज्ञ एक ही तथ्य के लिए भिन्न मूल्यों की रिपोर्ट करते हैं

**प्रतिक्रिया**: पूरी संदर्भ के साथ द्वंद्व को लॉग करें।

### अनुपस्थित या अवैध साक्ष्य

एक संकेत प्रमाण सूचकों के साथ आ जाता है जो मौजूद नहीं हैं

**प्रतिक्रिया**: इंजेक्शन पर संकेत को अस्वीकार करें. यह कभी भी substrate में प्रवेश नहीं करता हैM SK2 प्रस्तावित घटक अधिसूचित किया जाता है और वैध प्रमाणों के साथ पुनः प्रयास कर सकता है

### कोई सहमति नहीं

बहुत कम संकेत या नीति थ्रेसहोल्ड को पूरा करने के लिए अधिक असहमति

**प्रतिक्रिया**: एक निर्णायक आधाररेखा पर वापस आ जाएँ।

### स्थिर साक्ष्य

खुराक पर प्रमाण वैध था लेकिन बाद से समाप्त हो गया है।

**प्रतिक्रिया**कंसट्रेनर`IsStillAuthorisedAndAvailable`यह पकड़ता है।

### सत्य का एकमात्र स्रोत असफलता

सतह स्वयं उपलब्ध नहीं है

**प्रतिक्रिया**सर्किट ब्रेकर

पैटर्न असफलताओं को रोक नहीं करता है **ध्वनियुक्त, localised, और वसूली योग्य**.

---

## क्रियान्वयन जांच सूची

टीम निर्माण के लिए बहुल

1. **एक सम्मिलित मॉडल चुनें** सभी अवयवों के लिए (eM SK1g.,allMSC3MiniLM
2. **संकेत संविदा परिभाषित करें** (`ConstrainedSignal` + `EvidenceRef`किसी विशेषज्ञ के निर्माण से पहले )
3. **मानक इकाइयां और सामान्यीकरण परिभाषित करें** सभी तथ्यों के लिए (ISO | 8601 | समयtamps
4. **सर्वसम्मति को सबसे पहले बनाना** (सिग्नल समुच्चयन,असङ्क मूल्यांकनM SK2
5. **प्रत्येक विशेषज्ञ संकेत उत्पन्न करता है**अन्य विशेषज्ञों के लिए कभी भी प्राकृतिक भाषा नहीं
6. **समन्वय कंस्ट्रेनर तथ्यों पर समझौता को प्रमाणित करता है**, समानता सम्मिलित नहीं कर रहा है
7. **रजिस्टर हलकर्ता** क्रॉस के लिए-मोडल तथ्य तुलना (color names vs hex
8. **सभी संकेतों को लॉग करें** त्रुटिमोचन और विकास के लिए आबंटन सहित
9. **परिणामों को वस्तुनिष्ठ रूप से मापें** (परिवर्तन
10. **भंडारण निर्णय + परिणाम जोड़े** लंबे समय तक चलाने वाले RAG में
11. **मॉडलों को अपने इतिहास की क्वेरी दें** स्वतंत्र शिक्षण के लिए
12. **अवयवों को एक बार में बदलें**, सत्यापित संकेत अभी भी स्कीमा से मिलते हैं

---

## सबस्ट्रैट सिस्टम है

भाग 1: अवरोध व्यक्तिगत घटकों में उपयोगी व्यवहार बनाता है

भाग 2: **साझा अवरोध घटकों के बीच सुसंगत व्यवहार बनाता है**

सर्वसम्मति अंतरिक्ष मध्यप्रणाली नहीं है।

अनेक प्रस्तावक

मॉडल एक-दूसरे से बात नहीं करते।

**भाग 1 एक मॉडल को प्रतिबंधित करता है**

यह नियंत्रित धुंधला MoM है

---

## नोटेशन

- **"मोडलों में नहीं है** मुक्त नहीं है।
- **साक्ष्य पुनः---निश्चय पर सत्यापन---समय** अनुमोदन के लिए है
- **करार अंक** अपेक्षित तथ्यों का fraction, जो हल करने योग्य हैं

---

## द सर्जरी

भाग | पैटर्न
|------|---------|------|
| 1 | [अवरोधित अस्पष्टता](/blog/constrained-fuzziness-pattern) एकल घटक
à¤•à¥à¤°à¥‡à¤‚
| 3 | [प्रतिबंधित अस्पष्ट संदर्भ खींचना](/blog/constrained-fuzzy-context-dragging) समय
| 4 | [छवि सारणी](/blog/constrained-fuzzy-image-intelligence) व्यावहारिक कार्यान्वयन

**भाग 1** एक एकल संभाव्यात्मक घटक को निर्णायक सीमाओं के साथ प्रतिबंधित करता है

**भाग 3** समय अक्ष के साथ इस वास्तुकला को विस्तारित करता है

**भाग 4** सभी तीन पैटर्नों में लागू दिखाता है [ImageSummarizerComment](https://github.com/scottgal/lucidrag)आधारित छवि विश्लेषण पाइपलाइन जहां कई तरंग एक साझा सतह पर संकेत प्रकाशित करते हैं और निर्धारणात्मक चयन आउटपुट को प्रतिबंधित करता है

This is a preview from the server running through my markdig pipeline

AI Architecture DiSE LLM Patterns

एजेंट चैटर पर संबन्धित अस्पष्ट MoM: संकेत संविदाएं

Tuesday, 06 January 2026

भाग 1 एक पाइपलाइन का वर्णन किया गया: उपstrateM SK1 प्रस्तावक, कंसट्रेनर . एक संभाव्यात्मक घटकMSC4 निर्धारणात्मक सत्य से घेरे हुए

लेकिन क्या होता है जब आप बहुविध प्रस्तावक? बहुल LLMs? दृश्य मॉडल पाठ मॉडल से बात करने के लिए ? तंत्रिका नेटवर्कों में फीडिंग हाइउरिसिक्स

यह संकीर्ण अस्पष्ट मोएम है (CFMoM): अनेक प्रस्तावकों से सीमित चयनसाझा सत्य के विरुद्ध वैध किया गया।

एफसीएमओएम एक ऐसा पैटर्न है जहां बहुसंभाव्यात्मक घटक संकेतों को प्रस्तावित करते हैं, लेकिन केवल निर्णायक तर्क संयोजन कर सकता है

नियम

मॉडल संकेत प्रकाशित करते हैं घटकों के बीच कोई प्राकृतिक भाषा नहीं
उपstrate तथ्यों और साक्ष्यों को भंडारित करता है टाइप किया गया, स्कीमा
कंस्ट्रेनर decides. क्रॉस

बहुविध में अभिकर्ता प्रणालियों में साझा आधार भाषा है और अनुप्रवर्तक व्याकरण है

शब्दावली

में डुबोने से पहले शब्दावली निश्चित करें

अवधि	अर्थ
सीएफएमओएम	प्रतिबंधित अस्पष्ट MoM: अनेक प्रस्तावकों से प्रतिबंधित चयन
उपstrate-type तथ्य
संकेत संविदा अवयव substrate में कैसे लिखते हैं
सहमति अंतरिक्ष स्टोर + रूटिंग
समन्वय कंस्ट्रेनर क्रियाओं के लिए अंतिम द्वारपाल

नोट सहमति अंतरिक्ष एक बस और स्मृति है।

ये नई अवधारणाएं नहीं हैं।

अपरिवर्तक

ये गैर-negotiable हैं

केवल कंस्ट्रेनर side effects को ट्रिगर कर सकता है
तथ्यों को इंजेक्शन पर स्कीमा के विरुद्ध वैध होना चाहिए अन्यथा अस्वीकार करें
प्रमाण संकेतक होना चाहिए कोई गद्य उद्धृति नहीं
संकेत अपरिवर्तनीय हैं एक बार प्रकाशित
पाचन में कैनोनिकलीकरण होता है कंसट्रेनर canonical facts को मानता है
Cross-स्रोत विश्वसनीय नहीं है जब तक न कैलिब्रेटेड
सभी निर्णयों से एक लेखापरीक्षा रिकार्ड बनाता है

क्या यह नहीं है

बात	क्यों CFMoM भिन्न है
विशेषज्ञों का मिश्रण	मोई मॉडल आउटपुट को गणितीय रूप से मिश्रित करता है प्रतिबंधों के तहत संकेत प्रमाण और नीति के साथ
एजेंट चैटर कई एजेंट प्रणालियां मुक्त रूप से गुजरती हैं।
रूटिंग	रूटिंग चयन करता है जिस मॉडल को बुलाना हैसीएफएमओएम बहुविध प्रस्ताव स्वीकार करता है और चयन पद को प्रतिबंधित करता है
मतदान	मतदान से अनुमान लगाया जाता है कि आउटपुट तुलनात्मक हैं
लंगचैन---शैली ग्राफ	ग्राफ संदेश पास करते हैं. CFMoM एक साझा सतह पर अपरिवर्तनीय संकेत प्रकाशित करता है

CFMoM एक लाइब्रेरी या फ्रेमवर्क नहीं है संभाव्यात्मक घटकों को प्रस्तावित कर सकते हैं, लेकिन केवल निर्णायक खंडों को दर्शाता है

क्यों LLM-to-LLM संचार विफल है

जब दो एलएलएम प्राकृतिक भाषा के माध्यम से संचार करते हैं

अर्थ-विचलनप्रत्येक मॉडल थोड़ा अलग-अलग व्याख्या करता है।

विश्वसनीयता धोनामॉडल ए एक बात के बारे में निश्चित है।

भ्रम संवर्धनमॉडल ए एक सच्चे विवरण का आविष्कार करता है मॉडल बी इस पर बनाता है मॉडल सी इसे स्थापित के रूप में उद्धृत करता है

ढाँचा अस्थिरतामॉडल ए आउटपुट JSON

ढाँचा को लागू करने के लिए अधिक प्रोत्साहन जोड़ना स्वाभाविक है

एक साझा निर्णायक अंतरिक्ष के माध्यम से सभी अंतःसमूह संचार को बाध्य करता है

क्या " मॉडल व्यवहार में बात नहीं करते

यह कठिन नियम है

नमूने कभी अन्य नमूनाओं को प्रत्यक्ष रूप से इंजेस्टर नहीं करते क्या मॉडल ए ने कहा summarise
वे केवल अवयव रिकॉर्ड ingest जिसने स्कीमा को पास किया है + इंजेक्शन पर साक्ष्य जांच
मानव-मुखी व्याख्या अंतिम रूप से उत्पन्न की गई है और कभी भी प्रणाली में वापस नहीं दिया जाता है
यदि आप स्वयं को एक प्रॉ prompt कि अन्य मॉडल को संदर्भित लिखने के लिए मिल जाता हैआपने पैटर्न को तोड़ दिया है

यह मारता है ", लेकिन मेरी एजेंट अन्य एजेंट का सारांश कर सकता है

संकेत संविदा

साक्ष्य संदर्भ

पहला , क्या परिभाषित करता है

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

यह एक स्ट्रिंग नहीं है। Locator क्षेत्र हैंडल स्पैन, बंडिंग बाक्सों, समयtampsM SK2 या किसी अन्य स्थान योजना MSC3 इसकी योजना द्वारा निर्धारित की जाती है Kind.

प्रतिबंधित हस्ताक्षर अभिलेख

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

यह क्यों काम करता है

तथ्य schema-प्रसव पर वैध हैं: FactsSchemaId एक स्कीमा कि क्या परिभाषित करने के लिए संकेत करता है palette_dominant_hue इसका मतलब है कि यह किस प्रकार का है Dictionary<string, object>. स्कीमा JSON स्किमा है | या समतुल्य | ), | संस्करणित और पिन्ड |
पाचन में कैनोनिकलीकरण होता हैस्थिर प्रकारें1 स्थिर इकाइयां2 स्थिर मानकीकरण3 समय स्टाम्प आईएसओ हैं4 रंग हेक्स है5 निर्देशांक WGS हैं6 कंसट्रेनर मानक तथ्यों को मानता है7
साक्ष्य संरचनात्मक है: सत्यापनीय स्रोत सामग्री के लिए संकेतक
विश्वसनीयता परिभाषित है: "Self-estimated probability of correctnessM SK3 Uncalibrated confidence is never compared across sourcesMSC4 In the constrainerMSP5 treat crossMST6source confidence as a weight only after calibrationM ST7 otherwise use perM st8source thresholdsMst9
एम्बेडिंग वैकल्पिक सहायक हैंपुनःप्राप्ति और समूहन के लिए , सत्य स्थापित करने के लिए नहीं
वांछित स्लॉट भरे जाने चाहिए या संकेत अस्वीकृत किया जाता है वैकल्पिक क्षेत्र स्वीकार्य हैं

इनग्रेज़न: जहाँ वैधीकरण रहता है

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

जब कंस्ट्रेनर एक संकेत देखता है, तो यह पहले से ही स्कीमा है।

साक्ष्य सत्यापन स्तर

_evidenceStore.VerifyExists वास्तविक कार्य कर रहा है

मौजूद है: संदर्भित खंड/फ्रेमM SK2अनुरोध आईडी भंडार में मौजूद है
Scope-valid: स्पैन किनारे
सामग्री-hash मैच: Evidence pointer matches expected hash
अनुमतियाँकॉलर को इस साक्ष्य को संदर्भित करने की अनुमति दी जाती है

कोई भी स्तर असफल होने वाले संकेतों को इंजेक्शन पर अस्वीकृत किया जाता है

महत्वपूर्ण विभेद: तथ्यों की तुलना में सम्मिलन

यह है जहाँ बहुत से बहुअभिकर्ता अभियांत्रिकी गलत हो जाते हैं

सम्मिलित आप को एक दूरी ज्यामिति जो समानता के साथ संगत करता है। शक्ति एक ही बात के बारे में होना

तथ्य + साक्ष्य यह बात है कि "में एक ही मतलब है, सभी अवयवों में " होना चाहिए

टाइप किए मापन योग्य विशेषताएँ (पलेट बिन्सM SK1 ऑब्जेक्ट IDs, टाइमस्टैम्प्स )
प्रमाण संकेतक
एकल समानता सम्मिलित नहीं कर रहा है

एम्बेडिंग आपको संकेत खोजने में मदद करता है कि शक्ति एक ही बात के बारे में होना चाहिए हैं.

वास्तविक उदाहरण

में बोट खोज, तरंग 0 डिटेक्टर और तरंग (Wave) | 2 | LLMs के माध्यम से संचार DetectionContribution:

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

रिकार्ड अवरोध है. एलएलएम रैमबल नहीं कर सकता है . यह स्लॉट भरना चाहिए. उपयोक्ता एजेंट डिटेक्टर और LLM एक ही आकार के आउटपुट का उत्पादन करते हैं. डाउनस्ट्रीम घटकों को यह जानने की जरूरत नहीं है कि किसने इसे बनाया है

सर्वसम्मति अंतरिक्ष

साझा अवयव निष्क्रिय भंडारण नहीं है

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

अतुल्यकालिक संकेत प्रक्रमण

विशेषज्ञ एक-दूसरे की प्रतीक्षा नहीं करते

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

विशेषज्ञता और गहराई

प्राकृतिक श्रम विभाग

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

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

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

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

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

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

क्रॉस-एमएसके0-मोडल करार

दोनों विशेषज्ञ एक ही आधार पर टाइप किए हुए तथ्यों के साथ प्रकाशित करते हैं

जब पाठ विशेषज्ञ बनाता है entity_color: "blue" और छवि विशेषज्ञ उत्पादित करता है palette_dominant_hex: "#0000CC"आप करार को कैसे सत्यापित करते हैं

कच्चे समानता नहीं à¤à¥à¤°à¥à¤

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

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

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

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

(द Contains उपरोक्त तर्क अनुकरणीय है. उत्पादन में, समाधानकर्ता स्किमा युग्म द्वारा पंजीकृत होते हैं

स्कीमा तुलना डिफ़ॉल्ट द्वारा असंभव है यह एक सुरक्षा विशेषता है

समन्वय कंस्ट्रेनर एक हलकर्ता रजिस्ट्री का उपयोग करता है

समूह संकेतों को एक साथ सम्मिलित करने के लिए एम्बेडिंग का उपयोग करें
प्रत्येक तथ्य युग्म के लिए , हलकर्ता को ढूंढें या डिफ़ॉल्ट सही का उपयोग करें
रिसोल्वरों को कैनोनिकास कर दें और उचित सहिष्णुता के साथ तुलना करें
यदि हल किया गया है तो मिलाएँ, फ्लैग यदि विरोध करता है

कोई प्राकृतिक भाषा की आवश्यकता नहीं है

समन्वय कंसट्रेनर

भाग में 1, कंस्ट्रेनर एक गेटकीपर था

भाग 2, में समन्वय कंस्ट्रेनर एक है वाद्यकार0 यह

क्रॉसक्या विभिन्न विशेषज्ञों से संकेत तथ्यों पर सहमत हैं
विवादों को हल करता है: जब विशेषज्ञ आपस में मतभेद करते हैं
बजट का प्रबंधन करता हैकितनी विशेषज्ञों को इस इनपुट के लिए पुकारा जाना है
सहमति सीमाओं को लागू करता है: कार्रवाई से पहले कितनी सहमति है

कंस्ट्रेनर डेमोनिस्टिक है इसमें कोई LLM नहीं है।

तीन चरण सत्यापन

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

प्रमुख अंतर्दृष्टि embeddings प्रस्ताव. सम्मिलित समानता से यह संकेत मिलता है कि "ये संकेत संबद्ध हो सकते हैं

निर्णय फ़ंक्शन

कंसट्रेनर का निर्णय निर्णायक है।

समूह उम्मीदवार समानता सम्मिलित करके (चाप क्लस्टरिंग
फ़िल्टरComment स्कीमा वैधता और साक्ष्य सत्यापन द्वारा
तथ्यों को हल करना हलकर्ता रजिस्ट्री के माध्यम से मानक तुलना स्थान में
करार स्कोर गणना करें प्रति क्लस्टर: आवश्यक तथ्यों की भिन्नता है, जो हल करने के लिए हैं
नीति लागू करें: न्यूनतम समझौता थ्रेसहोल्ड
क्रिया चुनेंयदि सहमत हो तो : विलीन करें

प्रत्येक चरण एक निर्णायक कार्य है

उद्देश्यात्मक प्रतिक्रिया के साथ मॉडलों का मिश्रण

सर्वसम्मति अंतरिक्ष कुछ शक्तिशाली करता है साझा वस्तुनिष्ठ सत्य से स्वतंत्र सीखना.

सीखने का लूप

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

यह क्यों काम करता है

निर्णय दिए जाते हैं: RAG स्टोर्स जो मॉडल प्रस्तावित क्या
परिणाम निष्पक्ष हैं: निर्णायक घटक क्या वास्तव में हुआ मापते हैं
फीडबैक साझा किया जाता है लेकिन वज़न स्वतंत्र है: प्रत्येक एलएलएम एक ही परिणाम डेटा देखता है लेकिन कैसे समायोजन करने का निर्णय करता है

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

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

स्वतंत्र शिक्षण

प्रत्येक LLM RAG को अलग से क्वेरी कर सकता है

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

वह अवरोध जो सीखने को सक्षम बनाता है

यह सिर्फ काम करता है क्योंकि फीडबैक है उद्देश्यपूर्ण.

निर्णायक पृष्ठपोषण के बिना | |-------------------------------|----------------------------| मॉडल ए ने सोचा कि यह अच्छा करता है मॉडल बी परिणाम से असहमत था मॉडल गुणवत्ता के बारे में बहस करते हैं

निर्णायात्मक परत वास्तविकता को मापती है

आपात विशेषज्ञता

समय के साथ-साथ मॉडल स्वाभाविक रूप से विशिष्ट होते हैं

मॉडल ए सीखता है कि यह सावधानीपूर्ण निर्णयों में श्रेष्ठ है
मॉडल बी सीखता है कि यह किनारे के मामलों में श्रेष्ठ है
मॉडल सी अपने डोमेन को गहराई से सीखता है-, उस संकेत प्रकार के लिए विशेषज्ञ बन जाता है

कोई केंद्रीय वादक भूमिकाओं को निर्दिष्ट नहीं करता

why Frontier models make this more important

प्रतिintuitive अंतर्दृष्टि बेहतर मॉडल साझा सतहों को अधिक महत्वपूर्ण बनाते हैं.

| जैसे कि मॉडलों में सुधार होता है |---------------------|------------------------------| अधिक परिष्कृत आउटपुट अधिक विश्वसनीय संकेत तेजी से प्रसारित होते हैं व्यापक क्षमताएं | टाइप प्रतिबंधों को छोड़ने के लिए अधिक आवेग सुसंगत दिखने में बेहतर

विच्छेदन बिना एवोल्यूशन

क्योंकि संचार टाइपेड रिकार्ड और साझा एम्बेडिंग के माध्यम से होता है

अन्य घटकों को छूते बिना GPT-4 से Claude में पाठ विशेषज्ञ बदलें
नए विशेषज्ञ जोड़ें (audio analyzer) मौजूदा को परिवर्धित किए बिना
सभी घटकों पर एटमोनिक रूप से एम्बेडिंग मॉडल अद्यतन करें

सम्मिलन मॉडल को संस्करणित करना

आप से अद्यतन करना चाहते हैं all-MiniLM-L6-v2 के लिए nomic-embed-text-v1.5लेकिन आपके सभी भंडारित संकेतों में पुराने मॉडल से एम्बेडिंग है

समाधान: dual-write with multiple embeddings

क्योंकि Embeddings एक सूची है EmbeddingRefमाइग्रेशन सीधा है

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

प्रमुख बिंदुएं

प्रत्येक एम्बेडिंग अपने मॉडल आईडी लेता है कोई अनुमान नहीं
सिर्फ एक सूची में जोड़ रहा है पुराने पाठक अभी भी काम कर रहे हैं
समूह करार की तुलना करें, नकली कोसाइन समानता नहीं है
थ्रेसहोल्ड के बाद फ्लिप करें (,e,.,g, .,,95%,सही,M SK4,कुलर समझौता
तथ्य स्थिर हैं अगर एम्बेडिंग बदलता है तो भी टाइप किए गए तथ्य आधार सत्य बने रहते हैं

असफल मोड और फेलबैक

जब कुछ गलत हो जाता है तो यह पैटर्न चमकता है

परस्पर विरोधी तथ्य

दो विशेषज्ञ एक ही तथ्य के लिए भिन्न मूल्यों की रिपोर्ट करते हैं

प्रतिक्रिया: पूरी संदर्भ के साथ द्वंद्व को लॉग करें।

अनुपस्थित या अवैध साक्ष्य

एक संकेत प्रमाण सूचकों के साथ आ जाता है जो मौजूद नहीं हैं

प्रतिक्रिया: इंजेक्शन पर संकेत को अस्वीकार करें. यह कभी भी substrate में प्रवेश नहीं करता हैM SK2 प्रस्तावित घटक अधिसूचित किया जाता है और वैध प्रमाणों के साथ पुनः प्रयास कर सकता है

कोई सहमति नहीं

बहुत कम संकेत या नीति थ्रेसहोल्ड को पूरा करने के लिए अधिक असहमति

प्रतिक्रिया: एक निर्णायक आधाररेखा पर वापस आ जाएँ।

स्थिर साक्ष्य

खुराक पर प्रमाण वैध था लेकिन बाद से समाप्त हो गया है।

प्रतिक्रियाकंसट्रेनरIsStillAuthorisedAndAvailableयह पकड़ता है।

सत्य का एकमात्र स्रोत असफलता

सतह स्वयं उपलब्ध नहीं है

प्रतिक्रियासर्किट ब्रेकर

पैटर्न असफलताओं को रोक नहीं करता है ध्वनियुक्त, localised, और वसूली योग्य.

क्रियान्वयन जांच सूची

टीम निर्माण के लिए बहुल

एक सम्मिलित मॉडल चुनें सभी अवयवों के लिए (eM SK1g.,allMSC3MiniLM
संकेत संविदा परिभाषित करें (ConstrainedSignal + EvidenceRefकिसी विशेषज्ञ के निर्माण से पहले )
मानक इकाइयां और सामान्यीकरण परिभाषित करें सभी तथ्यों के लिए (ISO | 8601 | समयtamps
सर्वसम्मति को सबसे पहले बनाना (सिग्नल समुच्चयन,असङ्क मूल्यांकनM SK2
प्रत्येक विशेषज्ञ संकेत उत्पन्न करता हैअन्य विशेषज्ञों के लिए कभी भी प्राकृतिक भाषा नहीं
समन्वय कंस्ट्रेनर तथ्यों पर समझौता को प्रमाणित करता है, समानता सम्मिलित नहीं कर रहा है
रजिस्टर हलकर्ता क्रॉस के लिए-मोडल तथ्य तुलना (color names vs hex
सभी संकेतों को लॉग करें त्रुटिमोचन और विकास के लिए आबंटन सहित
परिणामों को वस्तुनिष्ठ रूप से मापें (परिवर्तन
भंडारण निर्णय + परिणाम जोड़े लंबे समय तक चलाने वाले RAG में
मॉडलों को अपने इतिहास की क्वेरी दें स्वतंत्र शिक्षण के लिए
अवयवों को एक बार में बदलें, सत्यापित संकेत अभी भी स्कीमा से मिलते हैं

सबस्ट्रैट सिस्टम है

भाग 1: अवरोध व्यक्तिगत घटकों में उपयोगी व्यवहार बनाता है

भाग 2: साझा अवरोध घटकों के बीच सुसंगत व्यवहार बनाता है

सर्वसम्मति अंतरिक्ष मध्यप्रणाली नहीं है।

अनेक प्रस्तावक

मॉडल एक-दूसरे से बात नहीं करते।

भाग 1 एक मॉडल को प्रतिबंधित करता है

यह नियंत्रित धुंधला MoM है

नोटेशन

"मोडलों में नहीं है मुक्त नहीं है।
साक्ष्य पुनः---निश्चय पर सत्यापन---समय अनुमोदन के लिए है
करार अंक अपेक्षित तथ्यों का fraction, जो हल करने योग्य हैं

द सर्जरी

भाग | पैटर्न |------|---------|------| | 1 | अवरोधित अस्पष्टता एकल घटक à¤à¥à¤°à¥à¤ | 3 | प्रतिबंधित अस्पष्ट संदर्भ खींचना समय | 4 | छवि सारणी व्यावहारिक कार्यान्वयन

भाग 1 एक एकल संभाव्यात्मक घटक को निर्णायक सीमाओं के साथ प्रतिबंधित करता है

भाग 3 समय अक्ष के साथ इस वास्तुकला को विस्तारित करता है

भाग 4 सभी तीन पैटर्नों में लागू दिखाता है ImageSummarizerCommentआधारित छवि विश्लेषण पाइपलाइन जहां कई तरंग एक साझा सतह पर संकेत प्रकाशित करते हैं और निर्धारणात्मक चयन आउटपुट को प्रतिबंधित करता है