Le modèle qui reste à émerger

Il a commencé avec mon blog's Outil de traduction. Le cache ne tient que les tâches suivantes par utilisateur: 5 des heures absolues et des heures d’expiration progressive de la durée de l’utilisation;

La plupart des développeurs les considéreraient comme des contraintes pour travailler autour de. Mais le cache est devenu auto- nettoyant et auto-specialisation. Il a conservé ce dont les utilisateurs avaient besoin et oublié ce qu’ils n’avaient pas fait. a été le système.

J’ai extrait ce primitive dans La plupart du temps, il est clair.Éphemaire: concurrence restreinte , expiration en glissement M SK2 signal - coordination entre les opérations fondée sur la même idée généralisée

Le modèle a continué à apparaître. Dans DiSE, Les LLM élaborent un code , mais les essais d'unité et les contrôles de qualité déterminent ce qui surviendra M SK2 Le LLM propose ; des contraintes aux essais Détection des bottes, les détecteurs héuristiques font des demandes de cotes d’échantillonnage , mais les seuils de politique exécutent le verdict final

Quatre systèmes. La même formeM SK1 La contrainte est toujours l’enseignant.

Une contrainte fait de l’ambiguïté un choix forcé. Ressources (size,timeM SK2coût ).Sousfois ilMSC4s épistemiques (éléments de preuveM SK1invariantes). Rôle identique : exécuter la sélection et prévenir la certitude non acquise

flowchart LR
    subgraph Constraint["The Constraint (Primitive)"]
        C1[Constrained Size]
        C2[Sliding Expiration]
    end

    subgraph Emergence["Emergent Behavior"]
        E1[Selective Forgetting]
        E2[Focus on Relevance]
        E3[Self-Optimization]
    end

    C1 --> E1
    C2 --> E1
    E1 --> E2
    E2 --> E3

    style Constraint stroke:#ef4444,stroke-width:2px
    style Emergence stroke:#22c55e,stroke-width:2px

Il s’agit là de l’influence fondamentale Système d'intelligence sémantique et DiSE (Evolution synthétique dirigée):

Les contraintes ne limitent pas l’intelligence. créer un comportement utile dans les systèmes qui autrement se déplacent

Le cache des LRU sous pression. La LLM restreinte par les faits computés. Le modèle héuriste restreint par les seuils de politiqueM SK2 Chaque contrainte oblige le système à prendre des décisions . Ces décisions créent la pression de sélectionMSC4

Le même modèle. Domaines différents . La contrainte est l’enseignant.

TL;DR: Laissez les modèles probabilistes proposer; laisser les systèmes déterministes Décision. Computez les faits que vous pouvez vérifier , laissez-lui interpréter par l'AI M SK2 puis validez toutes les allégations contre ces faits . Travaux pour les LLMs

Carte du modèle

Ce que vous obtiendrez:

• Modes de défaillance plus clairs (extrants dégradés avec traces d'audit , non corrompus silencieux
• Évolution plus sûre (muter librement l’auteur de la proposition
• Modèle-Architecture agnotique M SK1swap 7B pour la frontière sans changement structurel)

Coût:

• Plus de plomberie à l’avant-plan: vous bâtissez une extraction des preuves et des mesures avant de voir le rendement

Fuzziness restreinte

Constréint ici signifie bounded: limites strictes imposées mécaniquement plutôt que négociées par le biais de mécanismes d’appels à propositionsM SK1 Budgets , invariantes M SK3 et constrainers

Après la mise en place de systèmes dans des domaines très différents ( résumé du document , analyse d'images M SK2 détection de bottes , recherche de données MSC4 cette architecture a continué à émerger

flowchart TB
    subgraph Input
        I[Input Data]
    end

    subgraph Truth["Deterministic Substrate (Truth Layer)"]
        T1[Compute Facts]
        T2[Extract Evidence]
        T3[Calculate Metrics]
    end

    subgraph Fuzzy["Fuzzy Proposer (Creativity Layer)"]
        F1[Generate Proposals]
        F2[Score/Rank]
        F3[Synthesize Output]
    end

    subgraph Constrain["Constrainer (Contract Layer)"]
        B1{Acceptable?}
        B2[Rewrite/Hedge]
        B3[Enforce Limits]
    end

    subgraph Output
        O[Constrained Result]
        D[Degraded Fallback]
    end

    I --> T1 --> T2 --> T3
    T3 --> F1 --> F2 --> F3
    F3 --> B1
    B1 -->|"Full"| B3 --> O
    B1 -->|"Partial"| B2 --> B3
    B1 -->|"None"| D

    T3 -.->|"Evidence"| B1

    style Truth stroke:#22c55e,stroke-width:3px
    style Fuzzy stroke:#f59e0b,stroke-width:3px
    style Constrain stroke:#ef4444,stroke-width:3px

L’incertitude fondamentale: laisser les composantes probabilistes proposer, mais ne les laisser jamais décider. Utilisez-les pour ce qu'elles font'ils sont bons à (interprétationM SK3 classementM Sk4 génération d'hypothèsesM sk5 tout en imposant des contraintes déterministes à chaque frontièreM KS7

Ce qui rend ce modèle puissant, c’est sa souplesse.

• Un LLM génère des résumés de langue naturelle
• Modèle héuristique avec pondérations apprises et probabilité de cotation du robot
• Modèle de vision proposant des captions d'image
• Un ensemble de classificateurs faibles votant sur une décision

L'architecture demeure la même. Seules les composants changent.

Le problème: Les systèmes non restreints échouent silencieusement

Sans contraintes, Les systèmes probabilistes échouent de façon difficile à détecter et impossible à empêcher

flowchart LR
    subgraph Unconstrained["❌ Unconstrained System"]
        U1[Input] --> U2[LLM/Model]
        U2 --> U3[Output]
    end

    subgraph Constrained["✓ Constrained System"]
        B1[Input] --> B2[Compute Facts]
        B2 --> B3[LLM/Model]
        B3 --> B4{Validate}
        B4 -->|Pass| B5[Output]
        B4 -->|Fail| B6[Fallback]
    end

    style Unconstrained stroke:#ef4444,stroke-width:2px
    style Constrained stroke:#22c55e,stroke-width:2px

Modes de défaillance non contraints:

• Le LLM décrit avec confiance les couleurs qui ne sont pas présentes dans l'image.
• Les résumés citent des faits qui ne figurent pas dans le matériel de source.
• Les scores de détection des bottes fluctuent sauvagement en fonction de signaux irrelevant
• Un heuriste étudié se déplace à mesure que les patrons de trafic changent et bloque silencieusement les utilisateurs légitimes
• Les demandes de SQL comprennent les déclarations UPDATE et DELETE lorsque vous ne voulez que lire.
• Les coûts s’écroulent à mesure que les cas-marchés consomment des ressources illimitées

L’instinct est d’ajouter des exemples plus incitants.

Les dix commandements de la loi

Le modèle a été cristallisé en Règles d'exploitation (selectedM SK1

La rémunération: vous n’avez pas besoin de modèles frontaliers. Un petit LLM local sur le matériel de marchandises devient un multiplicateur de force lorsqu’il effectue la classification et la production d’hypothèses , ne prétend pas être une base de données ou une machine d’État . La machine borne manipule les parties rigides MSC4 Le LLM manipule des parties floues M SK5

Pour un exemple de cette séparation, C# , voir Utilisation de Nimble du C#, de la partie du La série StyloMail. Le modèle de décision locale répond à des questions spécifiques concernant le courrierM SK1 le système entourant combine ces données avec les comportements et la politique explicite.

Connexion de la théorie du contrôle

Le modèle a des racines profondes dans La théorie du contrôle: le gouverneur qui limite un processus de variation élevé

Classical Control:       Steam Engine → Governor → Constrained Speed
Constrained Fuzziness:   LLM/Heuristic → Constrainer → Constrained Output

Vous ne faites pas le moteur " comprenez " il ne devrait pas exploder M SK3 vous l’empêchez physiquement . C’est la même chose avec les systèmes probabilistes

Travaux connexes pour les personnes académiques:

• Herbert Simon's Rationalité limitée - décisionM SK1 prise sous contrainte
• "Une étude approfondie du RAG" (2024) ≥- récupérationM SK3 patrons de génération améliorés
• Mitchell's M SK1La nécessité de préjugés dans l’apprentissage généralisations" (1980) | - pourquoi les contraintes aident à apprendre

Qu'en est-il des modèles Frontier?

L’objection évidente: M SK1Sure, mais le GPT -5 / Claude M SK5 |/ Gemini Ultra sera tellement bon que ces contraintes gagneront

Peut-être. Modèles Frontier utilisation de papier sur de nombreuses fissures que les systèmes plus petits exposent. Ils hallucinaient moins fréquemment. Ils suivent l’instruction avec plus de fiabilité . Ils manipulent les cases en bordure de façon plus gracieuseM SK3 Si vous construisez un prototype ou un outil où des défaillances occasionnelles sont acceptablesMSC5 un modèle frontalier comportant de bonnes indications pourrait suffireMST6

Mais " moins fréquemment" n’est pas "ne jamaisM SK3 Et MSC4 plus fiableMSC5 n'est pas

L'article 5 de la Loi sur l'immigration et le statut des réfugiés article sur les petits modèles Il s’agit d’une étude approfondie de cette question, mais le point central est : Les modèles frontaliers échouent différemment, pas moins. Les défaillances sont sémantiques plutôt que structurelles. plus difficile pour détecter, pas plus facileM SK1

Plus important encore: L'ingénierie rapide ne peut pas remplacer la discipline en génie.. Quelle que soit la qualité du modèle, les problèmes demeurent.

Même si un modèle de frontière pouvait produire avec fiabilité une sortie correcte 99.9% du temps , vous avez encore besoin:

• Validation pour capturer le 0.1%
• Retours lorsque la validation échoue
• Enregistrement pour comprendre ce qui s'est passé
• Metriques pour suivre la dérive au fil du temps

Il s’agit là de la couche de constérisseur.

La différence réside dans le fait que vous la bâtissez ou non. précédemment les échecs vous expliquent pourquoi cela est important après. Constrained Fuzziness dit : construisez-le d’abord. Ensuite, la taille du modèle devient une option de déploiementM SK3 pas un modèle architecturalMSC4 Un modèle B avec de bonnes contraintes outrepasse souvent un modèle frontalier avec de mauvaises.

Changements dans le choix du modèle • le nombre d’heures consacrées à l’éducation Il n’y a pas de contrainte à l’utiliser.

Mise en œuvre de l'incertitude restreinte

1. Définir vos invariantes

Qu'est-ce qui doit Aucune fois être violée?

public class SummaryInvariants
{
    public bool ValidateSummary(Summary summary, SourceDocument source)
    {
        // No claims without evidence pointers (e.g., "[chunk-3]" must exist in source)
        if (summary.Claims.Any(c => !source.ChunkIds.Contains(c.EvidenceChunkId)))
            return false;

        // No color assertions unless we computed a palette from the image
        if (summary.ColorClaims.Any() && !source.HasComputedPalette)
            return false;

        // No PII in output
        if (PiiDetector.ContainsPii(summary.Text))
            return false;

        return true;
    }
}

Les invariantes communes comprennent:

• Aucune réclamation sans indicateurs de preuve
• Aucune couleur à moins d'être dérivée des statistiques de la palette
• Aucune émission de PII
• Aucune écriture, seule lecture-seulement SQL
• Aucune attribution d'identité à moins qu'elle ne soit explicitement justifiée

2. Fixer des budgets rigoureux

Qu'est-ce qui doit toujours être restreint?

public record ProcessingBudget(
    int MaxContextTokens = 4000,
    int MaxModelCalls = 5,
    TimeSpan MaxLatency = default,  // e.g., 30 seconds
    int MaxVramMb = 2048,
    decimal MaxCostUsd = 0.10m
)
{
    public ProcessingBudget() : this(MaxLatency: TimeSpan.FromSeconds(30)) { }
}

Le budget n’est pas une suggestion, c’est un brise-circuit. Lorsque le budget est dépassé, le système se dégrade gracieusement plutôt que de continuer à brûler les ressources.

3. Construisez vos types de portes

Le constrainer ne rejette pas seulement le ', mais aussi celui du .. réécrire ("moyenne", "incerteM SK3MSC4 fondée sur les éléments de preuve disponiblesMNK5 ou retire entièrement des allégations non corroboréesMRK6 La réécriture préserve le signal tout en retirant la surconfidenceMMK7 permettant aux systèmes d’être utiles sous l’incertitude plutôt que dans une situation fragileMKK8 QueMEK9est la partie distinctiveMZK10 ilMGK11il ne s’agit pas de validation des intrantsMTK12 il'la gouvernance de la productionMKZ14

Constrainers communs que vous reutiliserez dans tous les systèmes

Porte SchemaValidation du type +

public class SchemaGate<T>
{
    public (bool Valid, T? Result, string? Error) Validate(string json)
    {
        try
        {
            var result = JsonSerializer.Deserialize<T>(json, _options);
            return (true, result, null);
        }
        catch (JsonException ex)
        {
            return (false, default, ex.Message);
        }
    }
}

Porte des preuves: Chaque revendication doit être liée aux tronçons de source

public class EvidenceGate
{
    public Summary EnforceEvidence(Summary proposed, IReadOnlySet<string> sourceChunkIds)
    {
        // Keep only claims that reference chunks we actually have
        var validClaims = proposed.Claims
            .Where(claim => sourceChunkIds.Contains(claim.EvidenceChunkId))
            .ToList();

        return proposed with { Claims = validClaims };
    }
}

Porte des politiques:Privacy/Règles de sécurité Porte budgétaire: TempsM SK1computation /caps de tocène Réécrire la porte: Transformer les affirmations en déclarations garanties

4. Définir le traitement des défauts

Lorsque la partie floue échoue, don 't crashM SK2 Degrade:

public async Task<SummaryResult> SummarizeWithFallback(Document doc)
{
    try
    {
        var proposed = await _llm.GenerateSummary(doc);
        var constrained = _constrainer.Enforce(proposed, doc);

        if (constrained.Claims.Count > 0)
            return SummaryResult.Success(constrained);

        // LLM output was entirely invalid. Fall back to extractive
        return SummaryResult.Degraded(
            _extractiveSummarizer.Summarize(doc),
            reason: "LLM claims failed validation");
    }
    catch (BudgetExceededException ex)
    {
        // Log for evolution, return deterministic-only
        _logger.LogWarning(ex, "Budget exceeded for {DocId}", doc.Id);
        return SummaryResult.Degraded(
            _extractiveSummarizer.Summarize(doc),
            reason: ex.Message);
    }
}

Principes clés:

• Dégrader gracieusement à un mode déterministe-seulement
• Retour de la sortie partielle avec des marqueurs d'incertitude explicites
• Inscrire des propositions invalides en tant que signaux de formation pour une évolution rapide

Exemples du monde réel-

LLM-Systèmes basés (BriefM SK2

Le modèle est toujours le même.

Détection des bottes: Exemple non -LLM

Cette section est intentionnellement détaillée parce qu’elle montre le modèle sans aucun LLM.

Mon système de détection des robots (Mostlylucid.BotDetection) démontre que la fuzziness restreinte n’est pas limitée à des systèmes basés sur le LLMM SK2 . C’est là qu’un ensemble de détecteurs héuristiques avec pondérations apprises est proposé par ,.

Les trois couches:

• Sous-strate (Layer de la véritéM SK1: Les détecteurs individuels calculent les signaux objectifs des demandes HTTP

  • Analyse de l'agent d'utilisateur: ua.is_bot, ua.contains_automation_keyword
  • Analyse des titres: hdr.accept_language_count, hdr.missing_standard_headers
  • Analyse IP: ip.is_datacenter, ip.reputation_score
  • Analyse comportementale: beh.requests_per_minute, beh.path_entropy

• Proposition (Layer de créativitéM SK1: Le modèle héuriste regroupe les signaux par sigmoïde pondéré

  // Each detector emits a contribution, not a verdict
  DetectionContribution.Bot(
      source: "UserAgent",
      category: "BotSignature",
      confidence: 0.85,
      reason: "Contains 'Googlebot' signature",
      weight: 1.0
  );
  
  // Aggregation via weighted sigmoid
  var weightedSum = contributions.Sum(c => c.ConfidenceDelta * c.Weight);
  var botProbability = 1.0 / (1.0 + Math.Exp(-weightedSum));
  

• Conducteur (Layer de contratM SK1: Le moteur de la politique impose des seuils et des mesures rigoureuses

  public record DetectionPolicy(
      double EarlyExitThreshold = 0.3,      // Exit if < 30% = confident human
      double ImmediateBlockThreshold = 0.95, // Block only if 95%+ certain
      double AiEscalationThreshold = 0.6     // Escalate if risk unclear
  );
  

Le point de vue clef: Les détecteurs fournissent des preuves, Aucun verdict

Chaque détecteur contribue à la décision finale sans prendre sa propre décision. DetectionContribution captures de dossiers:

• ConfidenceDelta: Combien cela pousse vers le robot (+) ou l’humain МSK2
• Weight: Combien d'influence a ce détecteur?
• Signals: Les faits calculés
• Reason: HommeM SK1explication lisible

Cette séparation signifie que vous pouvez

• Ajouter/d'enlever les détecteurs sans changer la logique d'agrégation
• Poids de tune indépendants de la logique de détection
• Apprenez les poids optimaux à partir de la rétroaction au fil du temps

É Escalation facultative du LLM

Voici' c'est là où il devient intéressant : le modèle supporte escalation facultative à LLM lorsque le modèle héuristique est incertain. Cette configuration se fait par l’entremise de la politique:

// Default policy: fast heuristics only
var defaultPolicy = new DetectionPolicy {
    FastPath = ["UserAgent", "Header", "Ip", "Behavioral"],
    EscalateToAi = false
};

// High-security policy: escalate uncertain cases to LLM
var strictPolicy = new DetectionPolicy {
    FastPath = ["UserAgent", "Header", "Ip"],
    SlowPath = ["Behavioral", "ClientSide"],
    AiPath = ["Onnx", "Llm"],  // Optional ML/LLM detectors
    EscalateToAi = true,
    AiEscalationThreshold = 0.4  // Escalate when 40-60% uncertain
};

Lorsque l’escalade déclenche le score, la LLM reçoit les signaux accumulés et fournit une analyse linguistique naturelle, mais le constrainer continue d’imposer des seuils.

Orchestre basé sur la vague-

Le système fait fonctionner des détecteurs dans les vagues, avec des vagues ultérieures déclenchées par des signaux antérieursM SK1

flowchart LR
    subgraph Wave0["Wave 0: Fast & Free"]
        W0A[UserAgent]
        W0B[Header]
        W0C[IP]
    end

    C1{Consensus?}

    subgraph Wave1["Wave 1: Expensive"]
        W1A[Behavioral]
        W1B[ClientSide]
    end

    C2{Still Uncertain?}

    subgraph Wave2["Wave 2: AI"]
        W2A[ONNX Model]
        W2B[LLM]
    end

    subgraph Policy["Policy Enforcement"]
        P1{Score > 0.95?}
        P2[Block]
        P3[Allow]
        P4[Log & Learn]
    end

    Wave0 --> C1
    C1 -->|"Yes: 3+ agree"| Policy
    C1 -->|"No"| Wave1
    Wave1 --> C2
    C2 -->|"No"| Policy
    C2 -->|"Yes + AI enabled"| Wave2
    Wave2 --> Policy

    P1 -->|Yes| P2
    P1 -->|No| P3
    P3 --> P4

    style Wave0 stroke:#22c55e,stroke-width:2px
    style Wave1 stroke:#f59e0b,stroke-width:2px
    style Wave2 stroke:#ef4444,stroke-width:2px
    style Policy stroke:#8b5cf6,stroke-width:2px

Il s'agit de confusion restreinte avec éclaration progressive: les héuristiques peu coûteuses traitent des cas clairs , l’AI coûteuse traite des cas étroits M SK2 et la politique impose des contraintes à chaque étape .

Apprentissage sans risque

Puisque le constrainer impose la sécurité indépendamment de ce que les détecteurs produisent, le système peut apprendre en toute sécurité.

// After each request, submit learning event (non-blocking)
LearningCoordinator.TrySubmit("ua.pattern", new LearningEvent {
    Features = extractedFeatures,
    Label = actualOutcome,  // Was it actually a bot?
    Confidence = detectionConfidence
});

// Background: EMA weight update
var alpha = 0.1;  // Learning rate
newWeight = existingWeight * (1 - alpha) + observedDelta * alpha;

Les pondérations convergent vers des tendances réelles au fil du temps. élevées- les observations de confiance ont plus d’incidence . Mais une mauvaise mise à jour du poids ne peut jamais causer un préjudice incontrôléM SK3 Les seuils de politique continuent d’être appliqués

Pourquoi cela importe?

BotDetection prouve que l’incertitude restreinte n’est pas 't liée aux LLMs spécifiquement . ElleM SK2 est liée à tout système où:

1. Il faut combiner plusieurs signaux incertains
2. Différents signaux ont une fiabilité différente
3. Les contraintes strictes doivent être imposées indépendamment des points obtenus
4. Le système devrait apprendre et s'améliorer au fil du temps.
5. L'analyse coûteuse ne devrait être effectuée que lorsque l'analyse peu coûteuse est insuffisante.

Le LLM n'est qu'un élément flou possible.

Quand ne pas utiliser la fuzziness restreinte

Le modèle comporte un coût.

Passer quand:

• La tâche est entièrement déterministe. Si vous pouvez écrire if X then Y, vous n’avez pas besoin d’un promoteur ' il n’y a pas lieu de proposer

• You're prototyping. Vous ne savez pas ce que les contraintes signifient.

• La sortie est disposable. Brainstorming, DraftsM SK1 creative exploration : if a human reviews everything anyway, the constrainer is redundantMSC4

• Les défaillances occasionnelles sont acceptables. Si 5% le taux d’allucination est bon pour votre cas d’utilisation , le coût de l’ingénierie des contraintes peut dépasser le coût des défaillances

• Vous n'avez pas de substrat. Si vous pouvez' ne pas calculer la vérité fondée , vous pouvez–' ne l’empêcherM SK3 Ne pas la fausser' ne rien faire de fauxMSC5 Vous devez soit trouver des faits computables, soit accepter le flou.

Le modèle est pour les systèmes où:

• Les résultats probabilistes atteignent les utilisateurs ou d'autres systèmes sans examen humain
• Les défaillances sont silencieuses, coûteuses , ou composées
• Vous devez apprendre à évoluer sans risquer la production

Si ce n’est pas votre situation, les approches plus simples gagnent.

Intégration avec les systèmes évolutifs

Constrained Fuzziness devient encore plus puissant lorsqu’il est combiné avec DiSE (Evolution synthétique dirigéeM SK1 Patterns . Parce que vous pouvez attribuer des points aux candidats de façon peu coûteuse et déterministe:

1. Générer plusieurs propositions non claires
2. Valider contre les invariantes
3. Sommaire basée sur les mesures de satisfaction des contraintes +
4. Maintenir la meilleure , jeter le reste
5. Accumuler Défaillances en tant que signaux de formation pour une évolution rapide

Le point de vue clé: vous pouvez élaborer la proposition sans risquer le système, parce que le constrainer assure la sécurité et l’exactitude, indépendamment de ce qu’il produit

public async Task<EvolvedPrompt> EvolvePromptAsync(
    Prompt current,
    IReadOnlyList<FailureCase> failures)
{
    // Failures are safe to collect because constrainers caught them
    var patterns = AnalyzeFailurePatterns(failures);

    // Generate candidate prompt mutations
    var candidates = await _llm.GeneratePromptVariants(current, patterns);

    // Test each against held-out validation set
    var scored = await Task.WhenAll(candidates.Select(async c =>
    {
        var results = await RunValidationSet(c);
        return (Prompt: c, Score: CalculateScore(results));
    }));

    return scored.OrderByDescending(x => x.Score).First().Prompt;
}

Définition de l’une-Sentence

"Constrained Fuzziness est la pratique consistant à laisser les composantes probabilistes proposer leur signification alors que les systèmes déterministes exécutent la vérité , la sûreté M SK2 et les budgets à chaque frontière ."

Conclusion : Le gouverneur, Non le moteur

Retour à ce cache LRU qui est devenu plus intelligent lorsqu’il a épuisé la mémoire.

La solution consistait à ', ce qui ne lui donnait pas plus de capacité. permettre à la contrainte de faire son travail. La taille restreinte a forcé la sélection . L’expiration slidante a forcié à perdre de vue M SK2 Ensemble , ils ont créé l’apprentissage MSC4

C’est là l’incertitude clé: Vous ne fixez pas les systèmes probabilistes en les faisant moins probabiliste. Vous les réglagez en ne permettant pas à la probabilité d’échapper aux garanties.

flowchart LR
    E[🔥 High-Variance<br/>Engine] --> G[⚙️ Governor] --> O[✓ Constrained<br/>Output]

    style E stroke:#ef4444,stroke-width:2px
    style G stroke:#22c55e,stroke-width:3px
    style O stroke:#3b82f6,stroke-width:2px

Le moteur à vapeur ne comprend pas 't " comprendre " il ne devrait pas exploder ' le gouverneur l’empêche physiquement

Le même modèle. Centenaire différentM SK1

La prochaine fois que vous 'êtes tentés d’ajouter un autre paragraphe à votre prompt de système, dans l’espoir que le modèle comprendra les contraintes "understand" a constraintMSC3 stopM SK4 Demandez plutôtMST5 Puis-je calculer cette contrainte?

Si oui, le calculer. alors le constrégner sur ce modèleM SK2

Les limites strictes battent les suggestions douces. Chaque foisM SK1

La série

Partie 2 Cette architecture s’étend à plusieurs systèmes d’agents. Les modèles ne parlent pas les uns avec les autres. Ils publient des signaux types sur un substrat partagé.

Partie 3 Les modèles peuvent remarquer ce qui persiste, mais l’ingénierie décide ce qui demeure.

Partie 4 montre les trois modèles mis en œuvre dans ImageSummarizer—une vagueM SK1basée sur un pipeline d'analyse de l'image où ColorWave calcule les faits , VisionLlmWave propose, et la sélection déterministe limite le résultatMSC4