# StyloFlow-:, eingeschränktes Fuzzy-Signal, angetriebene Workflows

<!--category-- Architecture, AI, Workflows, C#, Signals, RAG -->
<datetime class="hidden">2026-01-11T14:00</datetime>

Ich baute StyloFlow, weil ich weiter schrieb [das gleiche Muster immer und immer wieder](https://www.mostlylucid.net/blog/reduced-rag)Komponenten, die auf das reagieren, was passiert ist, bevor es zu einem Vertrauensscores kommt und manchmal zu einer teureren Analyse eskalieren muss. Bestehende Workflow-Engines wollten, dass ich in Bezug auf DAGs oder Staatsmaschinen denke.

> HINWEIS:-StyloFlow ist nicht YET ein fertiges Produkt, wie ich lucidRAG und StyloBot I'-m Hinzufügen fehlenden Funktionen und Polieren der API auf BOTH Sty LoFllow und Ephemeral bauen ?. - es ist immer noch in der aktiven Entwicklung ., - aber Sie können versuchen, es auszuprobieren und bieten Feedback ? . - Ich werde hier später aktualisieren . ( - das SignalSink Zeug zum Beispiel wird sich ändern für ephemere v...

**StyloFlow ist eine signal- ,- driven orchestrierungsbibliothek, die passt [wie ich denke](https://www.mostlylucid.net/blog/thinking-in-systems) über[ KI-Pipelines](https://www.mostlylucid.net/blog/tencommandments):** Komponenten erklären, was sie produzieren und was sie brauchen.,-Konfidenzwerte Führung Ausführung.,- und billige Operationen laufen zuerst mit Eskalation zu teuren nur bei Bedarf.

Das ist die Infrastruktur, die **[*klar*RAG](https://www.mostlylucid.net/blog/lucidrag-multi-document-rag-web-app)** Das RAG-Tool für den cross- und kreuzförmigen Graphen [DocSummarizer](/blog/building-a-document-summarizer-with-rag) ](-Dokumente ·),-Dokument [DatenZusammenfassung](/blog/datasummarizer-how-it-works) Strukturierte Daten), und [ImageSummarizer](/blog/constrained-fuzzy-image-intelligence) (-Bilder in eine einheitliche Frage --Antwortsystem mit Wissensgraphenvisualisierung .-Es macht auch [Stylobot](https://www.stylobot.net) Ein fortschrittliches Bot-Schutzsystem und implementiert die [Reduzierte RAG](/blog/reduced-rag) Muster, Muster und Modelle

![lucidRAG Schnittstelle](lucidrag_proto.png?width=500)

**Quelle: Eurostat.** [GitHub - MSK - StyloFlow](https://github.com/scottgal/styloflow)

[TOC]

---


## Was ist das?

**StyloFlow ist ein funktionierender Prototyp eines Signals, das signalisiert wird** Die API und die Form werden sich entwickeln, wenn ich lucidRAG und Stylobot zusammenbaue.,, aber die Ausführung Semantik und Muster hier beschrieben sind die point- und eskalation als strukturelles Muster

Dies ist eine neue DSL- oder Workflow-Sprache. **Ausführung Semantik** gebaut rund um Signale, ,-Konfidenz-,- und begrenzte Eskalation-MSC2-Heute läuft es im --Prozess mit begrenzter Koncurrency-.-Morgen wird es die Fahrspuren über Maschinen verteilen, während die Signale als stabile Grenze beibehalten werden.

---


## Das Problem mit traditionellen Workflows

Hier ist, wie die meisten Workflow-Engines aussehen

```csharp
// ❌ Traditional: Hardcoded dependencies
public async Task ProcessDocumentAsync(string path)
{
    var text = await ExtractTextAsync(path);
    var chunks = await ChunkTextAsync(text);
    var embeddings = await GenerateEmbeddingsAsync(chunks);
    var entities = await ExtractEntitiesAsync(chunks);
    await StoreEverythingAsync(embeddings, entities);
}
```

Dies funktioniert bis zum

- Sie möchten Entity-Extraktion für einfache Abfragen überspringen
- Sie müssen Extraktion und Einbettung parallel ausführen
- Sie wollen zu einem besseren Modell auf der Grundlage des Vertrauens eskalieren
- Sie müssen eine neue Verarbeitungsstufe hinzufügen, ohne den vorhandenen Code zu berühren

Du endest mit entweder

1. **Starre Rohrleitungen** die sich anpassen können
2. **Massive, wenn, /** Bäume für Routing
3. **Gott Klassen** die alles wissen

## Die ephemere Ausführung der Stiftung

StyloFlow baut auf [meistlucid-.-ephemer](/blog/ephemeral-execution-library) Eine Bibliothek für gebundene trackable async Ausführung

Schnelle Zusammenfassung dessen, was ephemeral zur Verfügung stellt

```csharp
// Bounded concurrent processing with full visibility
var coordinator = new EphemeralWorkCoordinator<DocumentJob>(
    async (job, operation, ct) => {
        await ProcessAsync(job, ct);
        operation.Signal("document.processed");
    },
    new EphemeralOptions { MaxConcurrency = 4 });

// Enqueue work
await coordinator.EnqueueAsync(new DocumentJob(filePath));

// Full observability
Console.WriteLine($"Active: {coordinator.ActiveCount}");
Console.WriteLine($"Completed: {coordinator.TotalCompleted}");
```

**Die wichtigsten Vorteile von Ephemeral-:**

- Gebundene Koncurrency Keine entlaufenen Speicher
- [LRU Räumung](/blog/learning-lrus-when-capacity-makes-systems-better) von alten Operationen
- Signal-Publishing für die cross®--Komponentenkoordination
- Operation Pinning, um eine vorzeitige Räumung zu verhindern

Für Details siehe [Feuer und Don.'. nicht ganz vergessen](/blog/fire-and-dont-quite-forget-ephemeral-execution).

---


## Was dieses Modell ermöglicht

Diese Orchestrierung Modell erweitert ephemere mit

1. **YAML---getriebene Komponente manifestiert** Beschreibungskonfiguration
2. **Signal---basierte Trigger** Komponenten laufen, wenn Signale erscheinen
3. **Wellenkoordination** Vorrangige Ausführung auf Basis von - mit Konkurrenzspuren
4. **Eskalationsmuster** Verteidigen Sie teure Analysen, bis sie benötigt werden
5. **Verträge mit Rechtsträgern** Technische Daten für die Ausgabe von -
6. **Haushaltsführung** Zeitlimite für das Zeichen „MSK"

Hier ist die architektonische Schlüsselverschiebung.

```mermaid
graph TD
    subgraph Traditional["❌ Traditional: Hardcoded"]
        T1[Component A] -->|calls| T2[Component B]
        T2 -->|calls| T3[Component C]
        T3 -->|calls| T4[Component D]
    end

    subgraph StyloFlow["✅ StyloFlow: Signal-Driven"]
        S1[Component A]
        S2[Component B]
        S3[Component C]
        S4[Component D]
        SS[Signal Sink]

        S1 -.emits.-> SS
        S2 -.emits.-> SS
        S3 -.emits.-> SS
        SS -.triggers.-> S2
        SS -.triggers.-> S3
        SS -.triggers.-> S4
    end

    style T1 stroke:#ff6b6b
    style T2 stroke:#ff6b6b
    style T3 stroke:#ff6b6b
    style T4 stroke:#ff6b6b
    style S1 stroke:#51cf66
    style S2 stroke:#51cf66
    style S3 stroke:#51cf66
    style S4 stroke:#51cf66
    style SS stroke:#339af0
```

Komponenten rufen sich nie gegenseitig aus. Sie senden Signale aus und reagieren auf Signale.

---


## Kernkonzept – Signale und Eigentum

**Signale sind Fakten über das, was passiert ist**Nicht Befehle oder Ereignisse, sondern sie sind unveränderlich., timestamped... und tragen Vertrauensnoten... Jedes Atom besitzt seine Signale... sie sind extern unwandelbar.

```csharp
public record Signal
{
    public required string Key { get; init; }           // "document.chunked"
    public object? Value { get; init; }                 // Optional payload
    public double Confidence { get; init; } = 1.0;      // 0.0 to 1.0
    public required string Source { get; init; }        // Which component
    public DateTime Timestamp { get; init; }
    public Dictionary<string, object>? Metadata { get; init; }
}
```

**Critical architectural point-:-SignalSink ist eine persistente historische Ansicht**

**SignalSink** bietet eine abfragebare Ansicht über alle Operationen auf allen Koordinatoren, die es teilen .. .Signale bestehen über den gesamten Lebenszyklus des Koordinators ?- . wenn ein Betrieb von seinem Koordinator ausscheidet . , . die Signale bleiben im Waschbecken bis manuell gelöscht .

```csharp
// Create a shared signal sink (no parameters, signals persist)
var sink = new SignalSink();

// Coordinators manage operation lifetime, NOT signal lifetime
var coordinator = new EphemeralWorkCoordinator<string>(
    ProcessAsync,
    new EphemeralOptions
    {
        MaxConcurrency = 8,
        MaxTrackedOperations = 100,         // Operations evict after this
        MaxOperationLifetime = TimeSpan.FromMinutes(5),  // Or after this time
        Signals = sink                      // Share the persistent view
    });

// Operations emit via their emitter
public async Task ProcessAsync(string docId, SignalEmitter emitter, CancellationToken ct)
{
    // Store actual data externally (cache, database, blob storage)
    await cache.SetAsync($"doc-{docId}", documentData);

    // Signal carries a REFERENCE, not the data
    emitter.Emit("document.chunked", key: docId); // Key references external data
}

// SignalSink is readonly - it cannot alter signals
// Signals persist until their operation evicts from the coordinator
```

**SignalSink bietet ZWEI Koordinationsmuster**

**1.-Push---basiertes (-Subscribe-):-Subsumer**

```csharp
// Subscribe to the sink for push notifications
sink.Subscribe(signal => {
    if (signal.Is("document.chunked"))
    {
        // React immediately - signal includes OperationId
        Console.WriteLine($"Op {signal.OperationId} chunked doc at {signal.Timestamp}");
    }
});

// Returns IDisposable for cleanup
using var subscription = sink.Subscribe(HandleSignal);
```

**2.-Pull---based Qery-):-Pulli**

```csharp
// Get all signals for a specific operation
var opSignals = sink.GetOpSignals(operationId);

// Detect if any operation has emitted a signal
if (sink.Detect("embeddings.generated"))
{
    // At least one operation has generated embeddings
}

// Sense all signals matching a condition
var recentErrors = sink.Sense(s =>
    s.Signal.StartsWith("error.") &&
    s.Timestamp > DateTimeOffset.UtcNow.AddMinutes(-5)
);

// Get operation summary from its signal history
var summary = sink.GetOp(operationId);
Console.WriteLine($"Operation ran for {summary?.Duration}");
```

**Warum das so wichtig ist**

- **Nur-Leseansicht** SignalSink kann die Signale nicht verändern, es bietet nur Abfragezugriff
- **Signale bleiben bestehen** Die Signale bleiben in der Ansicht, bis ihre Operation vom Koordinator entfernt wird.
- **Signale sind Koordination, nicht Transport** Signale tragen Schlüssel , /Bezug auf externe Daten , nicht die Daten selbst
- **Unabhängigkeit des Koordinators** Mehrere Koordinatoren können eine Senke teilen, die alle über die Signalgeschichte hinausgeht.
- **Thread---sicher** Verriegelung von -®free liest für Abfrageoperationen
- **Drücken und ziehen** (), für reaktive ,, Sense, ()/, Detect,(), für Umfragen
- **Operationskorrelation** Jedes Signal enthält OperationId zur Nachverfolgung über Koordinatoren hinweg.
- **Musterabgleich** Abfrage durch exakte Übereinstimmung - Präfix , oder benutzerdefiniertes Prädikat

**Grundprinzip des Entwurfs** Speichern Sie große Daten Dokumente ,.Images,.Vektoren ). in Caches oder Datenbanken `"cache://doc-123"` oder Betriebstasten

Beispielkoordination

```csharp
// Operation emits signal via ISignalEmitter interface
public async Task ProcessAsync(Item item, ISignalEmitter emitter, CancellationToken ct)
{
    // Emit to the sink
    emitter.Emit("processing.started");

    await DoWorkAsync(item, ct);

    emitter.Emit("processing.completed");
}

// Wave checks if it should run by querying sink
public bool ShouldRun(string path, AnalysisContext ctx)
{
    // Pull pattern: query the sink via context
    return ctx.Detect("document.chunked");
}

// UI subscribes to sink for reactive updates
sink.Subscribe(signal => {
    if (signal.Signal.StartsWith("document."))
    {
        // Push pattern: react immediately
        UpdateProgressUI(signal);
    }
});
```

**Eskalation findet auf zwei Ebenen statt**

1. **Im Rahmen eines Koordinators** Die Wellen überprüfen das Signalvertrauen und führen eine bedingt teure Analyse durch.
2. **Zwischen den Koordinatoren** EskalatorAtm-Routen Signale von schnellen Koordinatoren. - teurer Koordinator basierend auf Signalkriterien

```csharp
// Pattern 1: Intra-coordinator escalation (wave checks signals)
public bool ShouldRun(string path, AnalysisContext ctx)
{
    var quality = ctx.GetSignal("quality.score");
    return quality?.Confidence < 0.7; // Only run if quality is low
}

// Pattern 2: Inter-coordinator escalation (atom routes to another coordinator)
// Option A: Explicit escalation signal
typed.Raise("escalate.to.expensive", payload, key: "doc-123");

// Option B: EscalatorAtom examines signals and decides
new EscalatorAtomOptions<T> {
    ShouldEscalate = evt => evt.Payload.Confidence < 0.7
}
```

Mehrere Koordinatoren laufen unabhängig .. .Eskalator Atom beobachtet Signale von einem Koordinator und leitet Arbeit an einen anderen weiter, wenn erforderlich .

Für die Theorie, die dahinter steht, siehe [Beschränkte Fuzzy Kontext Drackging](/blog/constrained-fuzzy-context-dragging).

### Signale tragen Referenzen ,, , keine Daten

**Kritisch , :** Signale sind Koordinationsereignisse,- nicht Datentransport.- große Daten Dokumente,-Bilder,-Embeddings)- sollten im externen Speicher leben

```csharp
// ❌ BAD: Carrying data in signals (memory pressure, boxing)
var imageBytes = await ProcessImageAsync(input);
emitter.Emit("image.processed", metadata: new { Data = imageBytes });

// ✅ GOOD: Store externally, signal the reference
var imageBytes = await ProcessImageAsync(input);
var cacheKey = $"processed/{docId}";
await cache.SetAsync(cacheKey, imageBytes);
emitter.Emit("image.processed", key: cacheKey);

// Later: Retrieve when needed
if (sink.Detect("image.processed"))
{
    var signals = sink.GetOpSignals(operationId);
    var imageKey = signals.FirstOrDefault(s => s.Signal == "image.processed")?.Key;
    if (imageKey != null)
    {
        var bytes = await cache.GetAsync<byte[]>(imageKey);
    }
}
```

**Bewährte Verfahren**

- Caches für ephemere Daten verwenden
- Datenbanken für dauerhafte Daten verwenden
- Blob-Speicher für große Dateien verwenden
- Signal-URIS-: `"cache://key"`, `"blob://container/file"`, `"db://table/id"`
- Bewahren Sie die Signale leicht und einfach auf den Schlüsseln.

---


## Kernkonzept:-Komponenten-Manifestierungen

**Manifeste erklären Verträge, die mich auslösen, was ich emittiere.** Diese Trennung existiert, so dass Sie den Workflow verstehen können, ohne Code zu lesen und die Ausführungsreihenfolge zu ändern, ohne erneut zu kompilieren.

```yaml
name: BotDetector
priority: 10              # Lower runs first
enabled: true

# What kind of component is this?
taxonomy:
  kind: analyzer          # sensor|analyzer|proposer|gatekeeper
  determinism: probabilistic
  persistence: ephemeral

# When should this run?
triggers:
  requires:
    - signal: http.request.received
      condition: exists

# What does it produce?
emits:
  on_complete:
    - key: bot.detected
      confidence_range: [0.0, 1.0]

  conditional:
    - key: bot.escalation.needed
      when: confidence < 0.7

# Resource limits
lane:
  name: fast              # fast|normal|slow|llm
  max_concurrency: 8

budget:
  max_duration: 100ms

# Configuration values
defaults:
  confidence:
    bot_detected: 0.6
  timing:
    timeout_ms: 100
```

**Vorteile**

1. **Laufzeitumstellung** Priorität ändern, ohne erneut zu kompilieren
2. **Umweltüberschreitungen** Überschreiben Sie über Appsettings.
3. **Klare Verträge** Sehen Sie, welche Signale auslösen, was
4. **Selbstbeherrschung** Das Manifest ist das Spezifik

### Visual Workflow Builder

Während Sie YAML Manifeste per Hand schreiben können, enthält StyloFlow einen visuellen Workflow-Builder, mit dem Sie signalisierte Workflows mithilfe modularer --Synth---Style-Patching erstellen können.

![StyloFlow Workflow Builder](styloflow_ui.png?width=800)

Die Benutzeroberfläche stellt zur Verfügung.

- **Drag--- und ---Drop Komponenten** aus der Taxonomie (-Sensoren ,-Analysatoren ,-Proposer , usw. .)-
- **Signaldraht-Patching** Verbinde Ausgänge visuell mit Eingängen
- **Live-Manifestvorschau** Sehen Sie die erzeugte YAML, wie Sie bauen
- **Visualisierung auslösen** Sehen Sie, welche Signale auslösen welche Komponenten
- **Streckenzuweisung** Komponenten in schnelle, normale und langsame Bahnen ziehen
- **Echtzeit-Validierung** Fangen Sie ungültige Signalreferenzen sofort

Dies macht es einfach, mit verschiedenen Workflow-Formen zu experimentieren, ohne YAML per Hand zu schreiben.

---


## Kernkonzept:-Wellen

Eine Welle ist ein komposables Analysestadium. **Diese Schnittstelle existiert, um zu machen, dass wir eine erste Entscheidung für die -**Nicht ein Implementierungs-Detail in bedingter Logik begraben

```csharp
public interface IContentAnalysisWave
{
    string Name { get; }
    int Priority { get; }               // Higher runs first
    bool Enabled { get; set; }

    // Quick filter - avoid expensive work
    bool ShouldRun(string contentPath, AnalysisContext context);

    // Do the analysis
    Task<IEnumerable<Signal>> AnalyzeAsync(
        string contentPath,
        AnalysisContext context,
        CancellationToken ct);
}
```

**Einfaches Wellenbeispiel**

```csharp
public class FileTypeWave : IContentAnalysisWave
{
    public string Name => "FileType";
    public int Priority => 100;
    public bool Enabled { get; set; } = true;

    public bool ShouldRun(string path, AnalysisContext ctx)
    {
        // Skip if we already know the type
        return ctx.GetSignal("file.type") == null;
    }

    public async Task<IEnumerable<Signal>> AnalyzeAsync(
        string path,
        AnalysisContext ctx,
        CancellationToken ct)
    {
        var extension = Path.GetExtension(path);
        var mimeType = GetMimeType(extension);

        return new[]
        {
            new Signal
            {
                Key = "file.type",
                Value = mimeType,
                Confidence = 1.0,
                Source = Name
            }
        };
    }
}
```

**Wellenkoordination**

Das `WaveCoordinator` läuft Wellen in Prioritätsreihenfolge

```csharp
var coordinator = new WaveCoordinator(waves, profile);
var context = new AnalysisContext();

var results = await coordinator.ExecuteAsync(filePath, context, ct);

// All signals from all waves
foreach (var signal in context.GetAllSignals())
{
    Console.WriteLine($"{signal.Key}: {signal.Value}");
}
```

**Fahrspuren für die Konkurrenz ,:**

Wellen laufen in Lanes mit unterschiedlichen Concurrency Limits

LÄNDERBEZOGENE ENTWICKLUNG
|------|---------|-------------|
| `fast` Kurze Überprüfungen der ('IP-Suchen der Datei Typ )|'16«
| `normal` Standard-Verarbeitungsschritte für (Parsing-Prozesse für,Prunking-Verfahren für )Prinking-Effekte
| `io` /O gebundene Datei liest die API-Aufrufe der ,, ), |,32 und |
| `llm` Teuere LLM-Aufrufe

Dies verhindert, dass teure Operationen billige blockieren

---


## Architektur, wie es zusammenpasst

Hier ist das komplette Bild.

```mermaid
graph TB
    subgraph Input["Input Layer"]
        REQ[HTTP Request]
        FILE[File Upload]
        JOB[Background Job]
    end

    subgraph Ephemeral["Ephemeral Layer"]
        COORD[Work Coordinator]
        OPS[Operations<br/>own signals]
        SINK[SignalSink<br/>read-only view]
    end

    subgraph StyloFlow["StyloFlow Layer"]
        MAN[Manifests]
        WAVE[Wave Coordinator]
        ATOMS[Atoms<br/>own signals]
    end

    subgraph Execution["Execution"]
        FAST[Fast Lane]
        NORM[Normal Lane]
        LLM[LLM Lane]
    end

    subgraph Output["Output"]
        RES[Results]
        ESCAL[Escalation]
        STORE[Persistence]
    end

    REQ --> COORD
    FILE --> COORD
    JOB --> COORD

    COORD --> OPS
    SINK -.queries.-> OPS

    WAVE -.reads.-> SINK
    MAN -.configures.-> WAVE
    WAVE --> ATOMS

    ATOMS --> FAST
    ATOMS --> NORM
    ATOMS --> LLM

    SINK -.queries.-> FAST
    SINK -.queries.-> NORM
    SINK -.queries.-> LLM

    SINK -.read for.-> RES
    SINK -.read for.-> ESCAL
    SINK -.read for.-> STORE

    style COORD stroke:#339af0
    style SINK stroke:#339af0
    style WAVE stroke:#51cf66
    style ATOMS stroke:#51cf66
```

**Durchfluss**

1. Eingabe kommt an (-HTTP Anfrage ,-Datei ,-Job
2. Ephemere Koordinator erstellt Operation .( , die eine leere Signalliste besitzt .
3. Betrieb fügt Signale zu seiner eigenen Liste hinzu
4. Wave-Koordinator READS Signale über SignalSink Ansicht, um Triggerbedingungen zu überprüfen
5. Wellen, deren Trigger übereinstimmen, laufen in Prioritätsreihenfolge innerhalb von Parallelspuren
6. Jede Welle fügt Signale zu seinem Betrieb bei.' s owned list extern unveränderlich
7. Wave-Koordinator liest Signale weiter, um neue zufriedene Auslöser zu finden
8. Endgültige Ausgabeabfragen SignalSink, um Signale zu lesen und Aktionen zu bestimmen

**Eigentümermodell - :** Jede Operation, die /-Atom besitzt seine Signale, .-SignalSink bietet eine Lese---Nur-Ansicht über alle Operationen,.-Signale können eskaliert werden, )- oder echoisierte (-Empfänger erhalten, wenn ausgelöscht wird, aber die eigene Liste ist extern unveränderlich..

**Aktueller Ausführungsmodell** Einmaliger --Prozess, gebundene Koncurrency-Operationen, beobachtbare Operationen mit LRU-Eviktion

**Künftiges Ausführungsmodell** Verteilte Fahrspuren auf Maschinen - SignalSink Abfragen Remote-Operationen - Atome führen auf verschiedenen Hosts aus **Signale bleiben die stabile Grenze** ' ist bereits serialisierbar, , timestamped, und selbst- integriert Das Eigentumsmodell ändert sich nicht.

Die Implementierung des in---Prozesses bestätigt die Semantik-Distribution bei der Skalierung des Ausführungssubstrates ,, , ohne das Orchestrierungsmodell zu verändern

---


## Case-Verarbeitung von Dokumenten verwenden

Mal sehen, wie [LucidRAG](/blog/lucidrag-multi-document-rag-web-app) verwendet StyloFlow-:

**Stadium der ersten Detektion**

```csharp
public class FileTypeDetectorWave : IContentAnalysisWave
{
    public int Priority => 100;  // Run first

    public async Task<IEnumerable<Signal>> AnalyzeAsync(...)
    {
        var extension = Path.GetExtension(path);

        return new[]
        {
            new Signal
            {
                Key = "file.extension",
                Value = extension,
                Source = "FileTypeDetector"
            }
        };
    }
}
```

**Stufe 2:-Cunking, ausgelöst durch Datei .-Extension)-**

```csharp
// In manifest:
// triggers:
//   requires:
//     - signal: file.extension
//       condition: in
//       value: [".pdf", ".docx", ".md"]

public class ChunkingWave : ConfiguredComponentBase, IContentAnalysisWave
{
    public int Priority => 80;

    public async Task<IEnumerable<Signal>> AnalyzeAsync(...)
    {
        var chunks = await ChunkDocumentAsync(path);

        ctx.SetCached("chunks", chunks);  // Share with other waves

        return new[]
        {
            new Signal
            {
                Key = "document.chunked",
                Value = chunks.Count,
                Source = Name
            }
        };
    }
}
```

**Stadium Einbetten von (ausgelöst durch Dokument Ausblenden von .Ausgedrückt aus )**

```csharp
public class EmbeddingWave : ConfiguredComponentBase, IContentAnalysisWave
{
    public int Priority => 60;

    public bool ShouldRun(string path, AnalysisContext ctx)
    {
        // Only run if chunking succeeded
        return ctx.GetSignal("document.chunked") != null;
    }

    public async Task<IEnumerable<Signal>> AnalyzeAsync(...)
    {
        var chunks = ctx.GetCached<List<Chunk>>("chunks");
        var embeddings = await GenerateEmbeddingsAsync(chunks);

        ctx.SetCached("embeddings", embeddings);

        return new[]
        {
            new Signal
            {
                Key = "embeddings.generated",
                Value = embeddings.Count,
                Source = Name
            }
        };
    }
}
```

**Stufe 4:-Entitätsextraktion mit Einbettung )-Parallel**

```csharp
public class EntityExtractionWave : ConfiguredComponentBase, IContentAnalysisWave
{
    public int Priority => 60;  // Same as embedding - runs in parallel

    public async Task<IEnumerable<Signal>> AnalyzeAsync(...)
    {
        var chunks = ctx.GetCached<List<Chunk>>("chunks");

        // Use deterministic IDF scoring, not LLM per chunk
        // (See Reduced RAG pattern)
        var entities = await ExtractEntitiesAsync(chunks);

        return new[]
        {
            new Signal
            {
                Key = "entities.extracted",
                Value = entities.Count,
                Confidence = CalculateConfidence(entities),
                Source = Name
            }
        };
    }
}
```

**Stufe Qualitätskontrolle**

```csharp
public class QualityCheckWave : ConfiguredComponentBase, IContentAnalysisWave
{
    public int Priority => 40;  // After embedding + entities

    public async Task<IEnumerable<Signal>> AnalyzeAsync(...)
    {
        var embeddingSignal = ctx.GetSignal("embeddings.generated");
        var entitySignal = ctx.GetSignal("entities.extracted");

        var embeddingCount = (int)embeddingSignal.Value;
        var entityConfidence = entitySignal.Confidence;

        var quality = CalculateQuality(embeddingCount, entityConfidence);

        var signals = new List<Signal>
        {
            new Signal
            {
                Key = "quality.score",
                Value = quality,
                Source = Name
            }
        };

        // Trigger escalation if quality is poor
        if (quality < GetParam<double>("quality_threshold", 0.7))
        {
            signals.Add(new Signal
            {
                Key = "escalation.needed",
                Value = "low_quality_document",
                Source = Name
            });
        }

        return signals;
    }
}
```

**Vorteile dieses Ansatzes**

1. **Parallele Ausführung** Gleichzeitige Einbettung und Entity-Extraktion
2. **Bedingte Verzweigung** Qualitätskontrolle entscheidet, ob eine Eskalation erforderlich ist
3. **Gemeinsamer Kontext** Wellen greifen auf Stücke zu, ohne sie explizit zu übergeben.
4. **Leicht zu erweitern** Eine neue Welle hinzufügen, ohne bestehende zu ändern
5. **Beobachtbar** Jede Stufe sendet Signale aus, die Sie überwachen können

Das ist die [Reduzierte RAG](/blog/reduced-rag) Muster in Aktion – Deterministische Extraktion vorn – ,, LLMs nur für die Synthese – MKK2

---


## Anwendungsfall-Stylobot Bot Detection

[Stylobot](https://www.stylobot.net) ist ein erweitertes Bot-Detektionssystem, das StyloFlow für mehrstufige Bedrohungsanalysen verwendet... Sehen Sie das komplette Eskalationsbeispiel im Abschnitt : von Fast bis Thorough".

---


## Signal---Driven Orchestration Patterns

**Muster-Fan--Aus**

Ein Signal löst mehrere Wellen aus

```mermaid
graph LR
    S1[document.uploaded] --> W1[ChunkingWave]
    S1 --> W2[MetadataWave]
    S1 --> W3[LanguageDetectionWave]

    W1 -.signal.-> S2[document.chunked]
    W2 -.signal.-> S3[metadata.extracted]
    W3 -.signal.-> S4[language.detected]

    style S1 stroke:#339af0
    style S2 stroke:#339af0
    style S3 stroke:#339af0
    style S4 stroke:#339af0
    style W1 stroke:#51cf66
    style W2 stroke:#51cf66
    style W3 stroke:#51cf66
```

**Muster-Abhängigkeit**

Wellen warten auf frühere Signale

```mermaid
graph LR
    W1[ExtractWave] -.signal.-> S1[text.extracted]
    S1 --> W2[ChunkWave]
    W2 -.signal.-> S2[text.chunked]
    S2 --> W3[EmbedWave]
    W3 -.signal.-> S3[embeddings.generated]

    style S1 stroke:#339af0
    style S2 stroke:#339af0
    style S3 stroke:#339af0
    style W1 stroke:#51cf66
    style W2 stroke:#51cf66
    style W3 stroke:#51cf66
```

**Muster - Bedingte Verzweigung**

Unterschiedliche Wellen laufen basierend auf Signalen

```mermaid
graph TD
    W1[DetectorWave] -.signal.-> S1{confidence}

    S1 -->|< 0.4| W2[RejectWave]
    S1 -->|0.4-0.7| W3[EscalateWave]
    S1 -->|> 0.7| W4[AcceptWave]

    W2 -.signal.-> S2[rejected]
    W3 -.signal.-> S3[escalated]
    W4 -.signal.-> S4[accepted]

    style S1 stroke:#ffd43b
    style S2 stroke:#ff6b6b
    style S3 stroke:#ff922b
    style S4 stroke:#51cf66
    style W1 stroke:#339af0
    style W2 stroke:#ff6b6b
    style W3 stroke:#ff922b
    style W4 stroke:#51cf66
```

**Muster der Aggregation**

Mehrere Signale lösen eine Welle aus

```mermaid
graph LR
    W1[Wave A] -.signal.-> S1[a.complete]
    W2[Wave B] -.signal.-> S2[b.complete]
    W3[Wave C] -.signal.-> S3[c.complete]

    S1 --> T{All Ready?}
    S2 --> T
    S3 --> T

    T -->|Yes| W4[AggregatorWave]
    W4 -.signal.-> S4[aggregation.complete]

    style S1 stroke:#339af0
    style S2 stroke:#339af0
    style S3 stroke:#339af0
    style S4 stroke:#51cf66
    style T stroke:#ffd43b
    style W4 stroke:#51cf66
```

---


## Eskalationsmuster

StyloFlow unterstützt Eskalation auf zwei Ebenen

1. **Innergemeinschaftlicher Koordinator**Die Wellen überprüfen das Signalvertrauen und führen bedingt teure Schritte durch.
2. **Koordinator**EskalatorAtm-Routen Signale von schnellen Koordinatoren

Beispiel aus lucidRAG-:-Schnelle Entitätsextraktion läuft zuerst..-Wenn die Qualität... <--- Eskalator... Atom leitet das Dokument zu einem teuren LLM-Verfeinerungskoordinator....-- Das spart Kosten, indem teure LLM fordert hohe --Qualitätsextraktionen vermieden wird.

---


## Minimale Form

> Dies ist nicht ein schnelles --Start-Anleitung, es ' ist das kleinste Beispiel, das zeigt, wie das Modell zusammenpasst

**Installation**

```bash
dotnet add package StyloFlow.Complete
```

**Konzeptioneller Einstiegspunkt (MSK)**

```csharp
// 1. Define a wave
public class MyAnalysisWave : IContentAnalysisWave
{
    public string Name => "MyAnalysis";
    public int Priority => 50;
    public bool Enabled { get; set; } = true;

    public bool ShouldRun(string path, AnalysisContext ctx) => true;

    public async Task<IEnumerable<Signal>> AnalyzeAsync(
        string path,
        AnalysisContext ctx,
        CancellationToken ct)
    {
        // Your analysis logic here
        var result = await AnalyzeAsync(path);

        return new[]
        {
            new Signal
            {
                Key = "my.signal",
                Value = result,
                Confidence = 1.0,
                Source = Name
            }
        };
    }
}

// 2. Register waves
var waves = new List<IContentAnalysisWave>
{
    new MyAnalysisWave(),
    new AnotherWave(),
};

// 3. Create coordinator
var coordinator = new WaveCoordinator(
    waves,
    CoordinatorProfile.Default);

// 4. Execute
var context = new AnalysisContext();
var results = await coordinator.ExecuteAsync(filePath, context);

// 5. Read signals
foreach (var signal in context.GetAllSignals())
{
    Console.WriteLine($"{signal.Key}: {signal.Value} ({signal.Confidence})");
}
```

**Mit Manifesten**

```csharp
// Load manifests from directory
var loader = new FileSystemManifestLoader("./manifests");
var manifests = await loader.LoadAllAsync();

// Build waves from manifests
var waves = manifests
    .Where(m => m.Enabled)
    .OrderBy(m => m.Priority)
    .Select(m => WaveFactory.Create(m))
    .ToList();

var coordinator = new WaveCoordinator(waves, profile);
```

Für vollständige Beispiele siehe: [StyloFlow GitHub-Repository](https://github.com/scottgal/styloflow).

---


## Workflow-Auffindbarkeit:-YAML-Manifestierungen

Eines der wichtigsten Merkmale von StyloFlow-' ist **Workflow-Auffindbarkeit** Sie können die gesamte Pipeline nur durch das Lesen der Manifeste verstehen.

### Vollständige lucidRAG-Dokumentpipeline

Hier ist die tatsächliche manifestierte Verzeichnisstruktur für lucidRAG-:

```
manifests/
├── 01-file-type-detector.yaml
├── 02-chunking.yaml
├── 03-embedding.yaml
├── 04-entity-extraction.yaml
├── 05-quality-check.yaml
└── 06-escalation.yaml
```

**01--File, Typ -, Detektor .,yaml, :,**

```yaml
name: FileTypeDetector
priority: 100
enabled: true
description: Detects file type from extension

taxonomy:
  kind: sensor
  determinism: deterministic
  persistence: ephemeral

triggers:
  requires:
    - signal: document.uploaded
      condition: exists

emits:
  on_start:
    - file.detection.started
  on_complete:
    - key: file.extension
      type: string
      confidence_range: [1.0, 1.0]
    - key: file.mime_type
      type: string
      confidence_range: [1.0, 1.0]

lane:
  name: fast
  max_concurrency: 16

budget:
  max_duration: 10ms
```

**]02--Cunking, .-yaml, :-cunking**

```yaml
name: ChunkingWave
priority: 80
enabled: true
description: Splits documents into semantic chunks

taxonomy:
  kind: extractor
  determinism: deterministic
  persistence: ephemeral

input:
  accepts:
    - document.pdf
    - document.docx
    - document.markdown
  required_signals:
    - file.extension

triggers:
  requires:
    - signal: file.extension
      condition: in
      value: [".pdf", ".docx", ".md", ".txt"]

emits:
  on_complete:
    - key: document.chunked
      type: integer
      confidence_range: [1.0, 1.0]
    - key: chunks.cached
      type: boolean

lane:
  name: normal
  max_concurrency: 8

budget:
  max_duration: 30s

defaults:
  chunking:
    max_chunk_size: 512
    overlap: 50
    respect_boundaries: true
```

**03--Einbettung .-Yaml-:-**

```yaml
name: EmbeddingWave
priority: 60
ires:
    - signal: file.extension
      condition: in
      value: [".pdf", ".docx", ".md", ".txt"]

emits:
  on_complete:
    - key: document.chunked
      type: integer
      confidence_range: [1.0, 1.0]
    - key: chunks.cached
      type: boolean

lane:
  name: normal
  max_concurrency: 8

budget:
  max_duration: 30s

defaults:
  chunking:
    max_chunk_size: 512
    overlap: 50
    respect_boundaries: true
```

**03--Einbettung .-Yaml-:-**

```yaml
name: EmbeddingWave
priority: 60
enabled: true
description: Generates ONNX embeddings for chunks

taxonomy:
  kind: embedder
  determinism: deterministic
  persistence: cached

input:
  required_signals:
    - document.chunked
    - chunks.cached

triggers:
  requires:
    - signal: document.chunked
      condition: ">"
      value: 0

emits:
  on_complete:
    - key: embeddings.generated
      type: integer
      confidence_range: [1.0, 1.0]

lane:
  name: normal
  max_concurrency: 4

budget:
  max_duration: 2m
  max_cost: 0.0  # Local ONNX model

defaults:
  embedding:
    model: all-MiniLM-L6-v2
    batch_size: 32
```

**,04--Entität , --Extraktion , .-Yaml , :-Extrakt**

```yaml
name: EntityExtractionWave
priority: 60  # Same as embedding - runs in parallel
enabled: true
description: Extracts entities using IDF scoring

taxonomy:
  kind: extractor
  determinism: deterministic
  persistence: persisted

input:
  required_signals:
    - document.chunked

triggers:
  requires:
    - signal: document.chunked
      condition: ">"
      value: 0

emits:
  on_complete:
    - key: entities.extracted
      type: integer
      confidence_range: [0.0, 1.0]  # Confidence varies

lane:
  name: normal
  max_concurrency: 8

budget:
  max_duration: 1m

defaults:
  entity:
    min_idf_score: 2.5
    min_frequency: 2
    max_entities: 100
```

**05--Qualität--Prüfung.-yaml-:-**

```yaml
name: QualityCheckWave
priority: 40
enabled: true
description: Validates extraction quality

taxonomy:
  kind: gatekeeper
  determinism: deterministic
  persistence: ephemeral

input:
  required_signals:
    - embeddings.generated
    - entities.extracted

triggers:
  requires:
    - signal: embeddings.generated
      condition: ">"
      value: 0
    - signal: entities.extracted
      condition: exists

emits:
  on_complete:
    - key: quality.score
      type: double
      confidence_range: [0.0, 1.0]

  conditional:
    - key: escalation.needed
      when: quality.score < 0.7

lane:
  name: fast
  max_concurrency: 16

defaults:
  quality:
    min_embeddings: 5
    min_entity_confidence: 0.5
    threshold: 0.7
```

**06--Eskalation.-yaml-:-**

```yaml
name: EscalationWave
priority: 20
enabled: true
description: Improves low-quality extractions using LLM

taxonomy:
  kind: proposer
  determinism: probabilistic
  persistence: persisted

input:
  required_signals:
    - escalation.needed

triggers:
  requires:
    - signal: escalation.needed
      condition: exists
  skip_when:
    - signal: budget.exhausted

emits:
  on_complete:
    - key: escalation.complete
      type: boolean
    - key: entities.improved
      type: integer
      confidence_range: [0.7, 1.0]

lane:
  name: llm
  max_concurrency: 2  # Expensive

budget:
  max_duration: 30s
  max_tokens: 4000
  max_cost: 0.05

defaults:
  llm:
    model: gpt-4o-mini
    temperature: 0.1
    prompt_template: entity_extraction
```

### Vorteile von deklarativen Manifesten

Betrachten Sie diese Dateien Sie wissen sofort

1. **Ausführungsauftrag** Prioritätszahlen der (100, → und 80, →, MSC5, MCSK6 und 40, → und MSC9
2. **Abhängigkeiten** Welche Signale jede Welle benötigt, um zu laufen
3. **Parallelität** Einbetten von (60) und EntityExtraction laufen zusammen
4. **Ressourcengrenzen** Verschiedene Fahrspuren und Konkurrenz pro Welle
5. **Bedingte Logik** Die Eskalation läuft nur dann, wenn die Qualität
6. **Kostengrenzen** Eskalation hat Token und Kostengrenzen

**Keine Code-Lesung erforderlich** Der Workflow ist selbst, -, documenting,.,

### Code: --basierte Atome, die in Manifesten aufgeführt sind

Während die obigen Beispiele zeigen voll deklarative YAML-,-Wellen können auch **auf der Grundlage von --Atomen** referenziert in Manifesten

```yaml
name: CustomAnalyzer
priority: 50
enabled: true
description: Custom analysis logic

# Reference a code-based atom implementation
implementation:
  assembly: MyProject.Analyzers
  type: MyProject.Analyzers.CustomAnalyzerWave
  method: AnalyzeAsync

# The manifest still declares the contract
taxonomy:
  kind: analyzer
  determinism: probabilistic

triggers:
  requires:
    - signal: data.ready

emits:
  on_complete:
    - key: analysis.complete
      confidence_range: [0.0, 1.0]

lane:
  name: normal
  max_concurrency: 4

# Configuration values passed to the atom
defaults:
  threshold: 0.75
  max_iterations: 10
```

Die Implementierung von C.M.S.K.

```csharp
public class CustomAnalyzerWave : ConfiguredComponentBase, IContentAnalysisWave
{
    public async Task<IEnumerable<Signal>> AnalyzeAsync(
        string path,
        AnalysisContext ctx,
        CancellationToken ct)
    {
        // Access manifest config
        var threshold = GetParam<double>("threshold", 0.75);
        var maxIterations = GetParam<int>("max_iterations", 10);

        // Custom logic here
        var result = await PerformComplexAnalysis(path, threshold, maxIterations);

        return new[]
        {
            new Signal
            {
                Key = "analysis.complete",
                Value = result.Score,
                Confidence = result.Confidence,
                Source = Name
            }
        };
    }
}
```

**Vorteile**

- **Manifest erklärt den Vertrag** --Triggersignale ,-Budgetspuren
- **Code bietet Implementierung** - Komplexe Logik - Externe Abhängigkeiten
- **Konfiguration fließt durch** Manifest Standardeinstellungen überschreiben Code-Standards
- **Prüfung der Unabhängigkeit** Testcode ohne Manifeste, validieren Manifeste ohne laufenden Code

Dieser hybride Ansatz gibt Ihnen deklarative Workflow-Entdeckung, während Sie komplexe Logik in wartungsfähig C.#....

### Pipeline-Visualisierung aus Manifesten

Die manifestierte Struktur macht es trivial, um Visualisierungen zu generieren

```mermaid
graph TD
    DOC[document.uploaded] --> FT[FileTypeDetector<br/>Priority: 100<br/>Lane: fast]
    FT --> EXT[file.extension]

    EXT --> CH[ChunkingWave<br/>Priority: 80<br/>Lane: normal]
    CH --> CHUNKED[document.chunked]

    CHUNKED --> EMB[EmbeddingWave<br/>Priority: 60<br/>Lane: normal]
    CHUNKED --> ENT[EntityExtractionWave<br/>Priority: 60<br/>Lane: normal]

    EMB --> EMBGEN[embeddings.generated]
    ENT --> ENTEX[entities.extracted]

    EMBGEN --> QC[QualityCheckWave<br/>Priority: 40<br/>Lane: fast]
    ENTEX --> QC

    QC --> QSCORE[quality.score]
    QC -.conditional.-> ESC_NEED[escalation.needed]

    ESC_NEED -.-> ESC[EscalationWave<br/>Priority: 20<br/>Lane: llm]
    ESC --> ESC_DONE[escalation.complete]

    style DOC stroke:#339af0
    style FT stroke:#51cf66
    style CH stroke:#51cf66
    style EMB stroke:#51cf66
    style ENT stroke:#51cf66
    style QC stroke:#ffd43b
    style ESC stroke:#ff922b
```

Dieses Diagramm wurde programmatisch aus dem YAML manifestiert erzeugt.

---


## Neben der Verwendung von Code-LLMs für den StyloFlow-Weg

Eine unerwartete Eigenschaft von StyloFlow ist, dass es ein System erstellt **LLMs können sicher denken**.

Die meisten Versuche, LLMs für Debugging oder Orchestrierung zu verwenden scheitern, weil das System sie fallen gelassen ist undurchsichtig.

* Staat ist implizit
* Kontrollfluss ist im Code vergraben
* Entscheidungen werden als Nebenwirkungen kodiert
* Logs sind narrativ, nicht kausal

StyloFloFlow tut das Gegenteil... es entlarvt **explizite, unveränderliche Fakten** über das, was geschah, wenn und mit welchem Vertrauen

Das macht Code LLMs nicht als Schauspieler wirklich nützlich, sondern als **Analysten**.

### LLMs Grund *über* nicht das System-, *innen* es

In StyloFlow, einem LLM, nie

* Auslösung
* Ergibt Signale
* Zustand der Mutationen
* Eigene Entscheidungen

Stattdessen wird ein **SignalSink Ansicht** und stellte Fragen wie:

* Warum eskalierte diese Welle?
* Dieses Signal bewirkte, dass dieser Pfad lief.
* Wo ist das Vertrauen am niedrigsten?
* Das vorgelagerte Signal widerspricht diesem Ergebnis.
* Was würde passieren, wenn diese Schwelle erhöht würde?

Beispieleingabe zu einem Code LLM-:

```json
{
  "operation": "doc-123",
  "signals": [
    { "key": "document.chunked", "value": 12, "confidence": 1.0, "source": "ChunkingWave" },
    { "key": "entities.extracted", "value": 4, "confidence": 0.42, "source": "EntityWave" },
    { "key": "quality.score", "value": 0.39, "source": "QualityCheckWave" },
    { "key": "escalation.needed", "source": "QualityCheckWave" }
  ]
}
```

Dass ,''s nicht ein Protokollstrom ,. ,das ,mesK2's a **Schlussfolgerungsstoff**.

Ein Code LLM kann jetzt

* Erklären Sie die Kausalität, da die Eskalation ausgelöst wurde, weil die Qualität
* Identifizieren Sie schwache Verbindungen - (" ,entity Extraktion Vertrauen dominiert Ausfall-") .
* Schlagen Sie Abschwächungen vor, einen anderen Extraktor vor dem Eskalieren zu laufen.
* Vorgeschlagene Konfigurationsänderungen Unteres Entity Min.-.IDF für PDFs

Alle ohne vertraut zu werden *tun* alles, was Sie brauchen

### Debugging wird inspection.,-nicht reenactment

Traditionelles Debuggen von "-LLM - versucht, die Welt wiederzuspielen

> Hier ist der Code und einige Protokolle, was schief gegangen ist.

StyloFlow-Debugging ist einfacher

> Hier ist der genaue Zustand, den das System beobachtet hat.

Weil Signale unveränderlich sind und im Besitz von , sind, müssen Sie nicht re-- run alles, was Sie tun müssen, um intent rekonstruieren. . Sie brauchen die LLM zu erraten.

Die LLM Gründe über Fakten, denen Sie bereits vertrauen

### Warum dies nicht in Agent Theater verwandelt

Dies funktioniert nur wegen der strengen Grenzen.

* LLMs können **Analyse** Signale
* Deterministischer Code **Rechtsakte** auf Signalen
* Nur Manifeste und Code-Änderungsverhalten

Es gibt keine Rückkopplungsschleife, in der die LLM "-Dezides... den nächsten Schritt... .... höchstens Erklärungen oder Konfigurationsvorschläge vorschlägt, dass eine menschliche Deterministenpolitik... )... später gelten kann.

Dass Asymmetrie absichtlich ist

### Eine Seite ,--Effekt , : , zukünftige Selbsteinstimmung , ohne Autonomie

Sobald signals-,-Konfidenz, , und Ergebnisse sind explizit *kann* Spätere Pressemitteilungen

* Mine historische Signalspuren
* Bewertung, welche Eskalationen geholfen haben
* Abschaltschwellen offline
* Wellen zwischen den Bahnen fördern oder degradieren

Nichts davon erfordert es, dass ein LLM das System ausführen lässt.

Die LLM wird ein **Diagnoselinse**Nicht eine Kontrollfläche

### Warum das so wichtig ist

StyloFlow doesn's'-t nur probabilistische Systeme sicher machen

Es macht sie **lesbar** Zu den Menschen zu den Tests und zu den LLMs, ohne die Kontrolle aufzugeben

Das ist der Unterschied zwischen

* LLMs, die Ihr System ausführen
* und verstehen Sie Ihr System.

Nur eine dieser Skalen

---


## Emergente Eigenschaften

**Erklärungszusammensetzung**

Komponenten deklarieren ihre Kontrakte (-Trigger,-Signale,-Budget),-Nicht ihre Abhängigkeiten.-Das System stellt Ausführungsauftrag vor.-Dies ist ein Feature '-Dies passiert, wenn Sie Signale zuerst--Klasse machen..-

**Standardmäßig beobachtbar**

Jede Aktion ist ein Signal ,. , Sie tun ,' , nicht hinzufügen Beobachtbarkeit , - , es inhärent ' , Volle Ausführung trace , , , Konfidenz-Tracking ., , Eskalationspfade , und Budgetverbrauch fallen natürlich heraus , . ,

**Anpassende Ausführung**

Vertrauen Punkte Antrieb Verzweigung ohne explizite Routing-Logik überspringen teure Stufen, wenn unnötig Eskalation ,, wenn unsicher,, vorzeitig abbrechen hoch-,Vertrauensausfälle ., Der Steuerungsfluss entsteht aus Signalmustern

**Testbarkeit ohne spöttische Rahmen**

Mock-Signale, nicht Komponenten, nicht Bestandteile, nicht :

```csharp
var context = new AnalysisContext();
context.AddSignal(new Signal
{
    Key = "document.chunked",
    Value = 10,
    Confidence = 1.0,
    Source = "Test"
});

var wave = new EmbeddingWave();
var results = await wave.AnalyzeAsync(path, context, ct);

Assert.Single(results);
Assert.Equal("embeddings.generated", results.First().Key);
```

**Inkrementale Komplexität**

Einfach starten

```csharp
var coordinator = new EphemeralWorkCoordinator<Job>(ProcessAsync);
```

Bei Bedarf Signale hinzufügen

```csharp
new EphemeralOptions { Signals = signalSink }
```

Wellen für Multi---Stadium hinzufügen

```csharp
var waveCoordinator = new WaveCoordinator(waves, profile);
```

Manifeste für deklarative Konfiguration hinzufügen

```yaml
name: MyWave
triggers: [...]
emits: [...]
```

---


## Vollständige Pipeline, MSK, lucidRAG-Dokumentaufnahme

Hier ist das komplette [LucidRAG](/blog/lucidrag-multi-document-rag-web-app) Pipeline auf einen Blick sehen Sie die detaillierten Code-Beispiele im Abschnitt "

1. **Hochladen** → `document.uploaded` Signal
2. **DateitypWave** erkennt PDF./.DOCX./.Markdown. `file.extension` Signal
3. **GewinnungWave** zieht Text und Struktur `text.extracted` Signal
4. **VerdunklungWave** zerteilt sich semantisch `document.chunked` Signal
5. **EinbettenWave** erzeugt Vektoren `embeddings.generated` Signal
6. **UnternehmenWave** extrahiert Entitäten (-parallel-)-→- `entities.extracted` Signal
7. **QualitätWave** prüft die Vollständigkeit `quality.score` Signal
8. **EskalationWave** Bedingt, wenn die Qualität `escalation.complete` Signal
9. **SpeicherWave** fortbesteht bei Qdrant -+-PostgreSQL- -→- `storage.complete` Signal

Die Benutzeroberfläche abonniert die SignalSink für echte .- ?time Fortschrittsaktualisierungen ?( ?push pattern ? ): ?

```csharp
// Subscribe to sink for push notifications
signalSink.Subscribe(signal => {
    if (signal.Key.StartsWith("document."))
    {
        await _hub.Clients.User(userId)
            .SendAsync("DocumentProgress", new
            {
                stage = signal.Key,
                progress = CalculateProgress(signal),
                operationId = signal.OperationId
            });
    }
});
```

Oder verwenden Sie das Pull-Muster, wenn Sie es bevorzugen

```csharp
// Query SignalSink for document progress (pull pattern)
var documentSignals = signalSink.GetSignals()
    .Where(s => s.Key.StartsWith("document.") &&
                s.Timestamp > lastCheck);

foreach (var signal in documentSignals)
{
    UpdateProgressUI(signal);
}
```

**Wesentlicher Punkt** Sie abonnieren die SINK ( , die alle Atome betrachtet , nicht zu einzelnen Operationen , . , Atoms eigene Signale , das Waschbecken bietet Push- , ( , Subscribe , und ziehen Sie ( query ,) , Zugang zu ihnen .

Dies ist, wie [LucidRAG](/blog/lucidrag-multi-document-rag-web-app) Verarbeitung von Dokumenten, Daten und Bildern durch ein einheitliches Signal, - driven Pipeline [DocSummarizer](/blog/building-a-document-summarizer-with-rag), [DatenZusammenfassung](/blog/datasummarizer-how-it-works)L 347 vom 20.12.2013, S. 671. [ImageSummarizer](/blog/constrained-fuzzy-image-intelligence) unter einer Orchestrierungsschicht

---


## Vollständige Pipeline-Erkennung für Stylobot Bot

Hier ist das komplette [Stylobot](https://www.stylobot.net) Pipeline auf einen Blick sehen Sie ausführlichen Code in ".Eskalation:. Von schnell bis tiefgründig"):.

1. **IpReputationWave** überprüft IP gegen bekannte Bot-Listen `bot.detected` Signal mit Vertrauen
2. **VerhaltenAnalyseWave** Vorbehaltlich, wenn 0.4... das Vertrauen von <... das Nutzer-Agenten- und Klickmuster analysiert. `bot.detected` Signal
3. **LlmBotAnalyseWave** Bedingt, wenn immer noch mehrdeutig, verwendet )-LLM für die Konversationsanalyse. `bot.detected` Signal

Der entscheidende Vorteil der Eskalation auf Basis des Vertrauens

```csharp
// ❌ Traditional: Every request gets expensive analysis
var reputation = await CheckIpAsync(ip);
var behavior = await AnalyzeBehaviorAsync(session);  // Even if IP is known bad
var llmScore = await LlmAnalysisAsync(conversation);  // Always expensive

// ✅ StyloFlow: Waves run based on confidence signals
// BehaviorAnalysis only runs if confidence is ambiguous (0.4-0.7)
// LLM analysis only runs if still unsure after behavior check
```

**Kostenaufschlüsselung** IP-Kontrollkosten und Laufzeiten von 100% der Zeit.] Behaviorale Analyseläufe von 30%] ( ambiguous cases – LLM-Analyseläufe von5%( immer noch mehrdeutig). Gesamtkosten pro Anfrage:" **$0.0001** vs naive "-LLM alles, bei **$0.002** Einsparungen bei (20x

---


## Vergleich mit anderen Workflow-Engines

Funktion |, StyloFlow, Temporaler Luftstrom Schrittfunktionen |,
|---------|-----------|----------|---------|----------------|
| **Koordinierung** Signal-, Signal- und Datenübertragungsgeräte auf der Basis von |, RPC, -, DAG, MSC5, State Machine
| **Erklärung** ✅YAML manifestiert |YAml-Code, zuerst |YALM-DAGs, dann ✅JSON-/YAMT-MSC10
| **Bedingung** Signalauslöser |Auszugsbedingungen MSSK4Ausgangszustand MSKK5Ausstiegszustand |Austrittsstatus MSKS7Auswahlzustand
| **Eskalation** ✅Ausgebautes -Ausgestelltes Handbuch |Ausgeführtes Manual |Ausgebrachtes Manuelles |Ausgewähltes Handbuch
| **Beobachtungsfähigkeit** ✅, Signalspuren |, ✅, Workflow-Geschichte |, ✅, Auftragsprotokolle |, MSC7, Ausführungshistorie |,
| **Haushaltskontrolle** |-M✅-Token-/-Kostenlimite Manual-|-MNSK6-MUSK7-MKSK8-Handbuch
| **Lokale Ausführung** Benötigt Cluster Benötigte Cluster Befordert Cluster Befragte Cluster Bezeichnet |Benötigt nur AWS Berechnet |
| **Fahrspuren für die Übereinstimmung** Weitere Informationen: http://europa.eu.int/comm/index_de.htm

**Wo dieses Modell natürlich passt**

- AII-/-ML-Pipelines mit Eskalation (-Scheap-Verteuerung )-
- Dokumentenverarbeitung mit bedingten Stufen
- Bot-Detektion mit mehrstufiger Analyse
- RAG-Systeme mit hybrider Suche
- Jeder Workflow, bei dem Komponenten auf Vertrauenswerte reagieren

**Wo es nicht mehr ', nicht weniger ( und nicht weniger ', nicht mehr ):**

- Einfache sequentielle Jobs -(-ephemere Koordinator ist genug - )-
- Reif verteilte Workflows über Rechenzentren
- Lange, laufende Arbeitsabläufe mit menschlichen Zulassungen (Temporal/ Airflow)
- Workflow-Versionierung mit Schema-Migration

---


## Wo dieses Modell hinführt

> Dies sind natürliche Erweiterungen des Modells... nicht Verpflichtungen zu einer spezifischen Implementierung...

Da sich die Semantik durch lucidRAG und Stylobot-Entwicklung stabilisiert, werden diese Muster praktikabel.

**Aus Signalen lernen**

Verfolgen Sie, welche Eskalationswege am besten funktionieren.

```csharp
// Did the LLM escalation improve accuracy?
// Learn to skip it if behavioral analysis is sufficient
```

**Kostenoptimierung**

Automatische Fahrspurzuweisung basierend auf historischer Leistung

```csharp
// If a "slow" wave completes quickly, promote to "normal"
```

**Signalwiedergabe**

Debuggen durch Wiedergabe von Signalsequenzen

```csharp
var replay = SignalReplay.FromFile("trace.jsonl");
await coordinator.ReplayAsync(replay);
```

**Maschinenkoordination**

Verteilen Sie Fahrspuren über Maschinen, während die Signale zentralisiert bleiben

---


## Warum Signale wichtig sind

Der Kern der Erkenntnis ist: **in KI-Systemen – jede Komponente hat Vertrauen**.

Traditionelle Workflows gehen davon aus, dass die KI-Workflows Erfolg haben müssen

- **Vertrauensnoten** Wie sicher sind wir?
- **Bedingte Ausführung** Überspringen Sie teure Stufen, wenn selbstbewusst
- **Eskalation** Versuchen Sie mehr, wenn unsicher
- **Zusammenrechnung** Kombination mehrerer Signale

Signale stellen diese natürlich zur Verfügung

```csharp
// Multiple detectors vote
var signals = context.GetSignals("bot.detected");

// Aggregate by confidence
var verdict = signals
    .OrderByDescending(s => s.Confidence)
    .First();

// Or majority vote
var isBot = signals
    .Count(s => (bool)s.Value) > signals.Count() / 2;

// Or weighted average
var score = signals
    .Sum(s => (bool)s.Value ? s.Confidence : -s.Confidence)
    / signals.Count();
```

Deshalb funktioniert StyloFlow gut für [Reduzierte RAG](/blog/reduced-rag) Jede Extraktionsstufe erzeugt einen Konfidenzwert und Synthese geschieht nur dann, wenn das Vertrauen hoch genug ist.

---


## Zusammenfassung

**Das Ausführungsmodell**

- Signale als erste Fakten der --Klasse nicht Ereignisse oder Nachrichten
- Vertrauen Punkte Antriebssteuerung Fluss
- Wellen koordinieren über Trigger keine direkten Anrufe
- Lanes erzwingen Ressourcengrenzen
- Aufbauend auf [meistlucid-.-ephemer](/blog/ephemeral-execution-library)

**Warum Signale von Bedeutung sind**

1. **Stabile Verteilungsgrenze** ,- , Serialisierbar , , , timestamped , , , integriert
2. **Angabe der Zusammensetzung** Die Manifeste definieren Kontrakte, Laufzeiten und Ausführung
3. **Adaptives Routing** Vertrauen ermöglicht Eskalation ohne hardcodierte Verzweigung
4. **Inhärente Beobachtungsfähigkeit** Jede Aktion ist bereits ein Signal
5. **Freier Besitz** Externe Immutierbarkeit verhindert Wirkung , - ,at ,- ,a ,- Entfernung

**Arbeitsumsetzungen**

- [LucidRAG](/blog/lucidrag-multi-document-rag-web-app) Beschreibung des Dokuments Q.M.S.K.A mit bedingter Entitätsextraktion
- [Stylobot](https://www.stylobot.net) Bot-Detektion mit Konfidenzmittel- driven Eskalation . .( .IP Verhalten . → . LLM .
- [Reduzierte RAG](/blog/reduced-rag) Deterministische Extraktion der gebundenen LLM

**Verwandte Artikel**

- [Ephemere Ausführung Bibliothek](/blog/ephemeral-execution-library) Die Stiftung
- [Reduzierte RAG](/blog/reduced-rag) Warum es auf deterministische Extraktion ankommt
- [LRU und Kapazität](/blog/learning-lrus-when-capacity-makes-systems-better) Speicherfenster von -
- [Beschränkte Fuzzy Kontext Drackging](/blog/constrained-fuzzy-context-dragging) Die Theorie

**Quelle: :** [GitHub - MSK - StyloFlow](https://github.com/scottgal/styloflow)

---


## Der Kern der Erkenntnis

Traditionelle Workflow-Engines bitten Sie zu deklarieren **was als nächstes passiert**Dieses Modell bittet Komponenten zu deklarieren **was sie produzieren** und **was sie brauchen**Die Signale können dann die Ausführung koordinieren.

Die Schlüsselverschiebung **Signale Entkoppelung ,-Vertrauensführer,-Schiene schützen**.

Hier geht es um die Auswahl von StyloFlow über Temporale oder Airflow.Diese lösen verschiedene Probleme.(Belastbare Ausführung.,Bedingte Workflow-Versionierung.MSC4Beseitigte Koordination über Rechenzentren.MSSK5Berühren Sie ein anderes Orchestrierungsmodell, bei dem der Steuerungsfluss aus Signalmustern entsteht, anstatt explizit programmiert zu werden.

Wenn du die AI-/ ML Pipelines baust, bei denen die :

- Vertrauen zählt nicht nur Erfolg
- Eskalation ist strukturell nicht ein spezieller Fall.
- Komponenten sollten sich kennen
- Die Beobachtbarkeit sollte inhärent sein.

Diese Ausführung Semantik könnte dann passen, wie Sie denken

Das [ephemere Bibliothek](/blog/ephemeral-execution-library) ist die stabile foundation?.-StyloFlow fügt das Signal hinzu.--gesteuerte Orchestrierungsschicht oben.MSC2-T Beide entwickeln sich durch den realen Einsatz in lucidRAG und Stylobot...

Für Fragen oder Rückmeldungen siehe das [GitHub-Repository](https://github.com/scottgal/styloflow).