# Neuron-abhängige Workflows

Dieses Beispiel beantwortet eine häufige Frage zur Arbeit mit Agenten:

> Kann ein Workflow festlegen, dass ein anderer erst fortfährt, nachdem ein früherer Workflow abgeschlossen ist?

Ja. Wichtig ist, dass Queuety dies bereits mit `wait_for_workflow()` und `wait_for_workflows()` unterstützt.

Das bedeutet:

- `X`-Workflow kann jetzt gestartet werden
- `X` kann in `waiting_for_workflows` warten
- `X` wird erst fortgesetzt, wenn `Y`-Workflow abgeschlossen ist

## Beispiel: zuerst recherchieren, dann schreiben

Verwende einen Workflow auf oberster Ebene, um ein Recherchepaket zu erstellen, und einen zweiten Workflow auf oberster Ebene, um den endgültigen Text zu verfassen.

### Recherche-Workflow

```php
use Queuety\Enums\WaitMode;
use Queuety\Queuety;

$research_agent = Queuety::workflow('research_agent')
    ->then(ResearchTopicStep::class);

$research_id = Queuety::workflow('research_packet')
    ->then(PlanResearchTasksStep::class)
    ->start_agents('agent_tasks', $research_agent)
    ->wait_for_agents(mode: WaitMode::All, result_key: 'agent_results')
    ->then(SynthesizeResearchPacketStep::class)
    ->dispatch([
        'brief_id' => 42,
        'provider' => 'anthropic',
    ]);
```

### Schreib-Workflow

```php
Queuety::workflow('write_brief')
    ->wait_for_workflow('research_workflow_id', 'research')
    ->then(WriteBriefWithNeuronStep::class)
    ->wait_for_decision(result_key: 'editor_review')
    ->then(PublishBriefStep::class)
    ->dispatch([
        'brief_id' => 42,
        'research_workflow_id' => $research_id,
        'provider' => 'openai',
    ]);
```

Wenn der Schreib-Workflow startet, pausiert er sofort in `waiting_for_workflows`, bis der Recherche-Workflow erfolgreich abgeschlossen ist.

## Der Neuron-Schreibschritt

```php
namespace App\Workflow\Steps;

use App\Neuron\WriterAgent;
use NeuronAI\Chat\Messages\UserMessage;
use Queuety\Step;

final class WriteBriefWithNeuronStep implements Step
{
    public function handle(array $state): array
    {
        $agent = new WriterAgent(
            providerName: $state['provider'] ?? 'openai',
        );

        $message = $agent->chat(
            new UserMessage(sprintf(
                "Write the final brief for brief %d using this research packet:\n\n%s",
                $state['brief_id'],
                json_encode($state['research'], JSON_PRETTY_PRINT),
            ))
        )->getMessage();

        return [
            'draft_markdown' => $message->getContent(),
        ];
    }

    public function config(): array
    {
        return [];
    }
}
```

`$state['research']` ist verfügbar, weil `wait_for_workflow()` den abgeschlossenen öffentlichen Zustand aus dem Abhängigkeits-Workflow unter dem Schlüssel `research` in den aktuellen Workflow kopiert hat.

## Wann du das statt eines einzigen großen Workflows verwenden solltest

Bevorzuge separate Workflows auf oberster Ebene, wenn:

- die Phasen unterschiedliche Verantwortliche oder Betriebszyklen haben
- du sie unabhängig prüfen und erneut ausführen möchtest
- eine spätere Phase gestartet werden können soll, bevor die frühere abgeschlossen ist

Bevorzuge einen einzelnen Workflow, wenn:

- die Phasen eng miteinander verbunden sind
- sie einen Betriebszyklus und einen gemeinsamen Zustandsdatensatz verwenden

## Wo eine Zustandsmaschine passt

Wenn dieser Schreibablauf zu einer länger laufenden Redaktionssitzung gehört, lass eine [Zustandsmaschine](https://queuety.inline0.dev/de/docs/state-machines) den äußeren Lebenszyklus steuern und verwende diese Workflows für klar abgegrenzte Ausführungsphasen. So bleiben Lebenszykluszustände wie `awaiting_brief`, `researching`, `awaiting_review` und `completed` explizit, während die Workflows in jeder Phase zuverlässig weiterlaufen.

## Ein wichtiger Unterschied

Dieses Muster bedeutet:

- `X` ist bereits vorhanden, wartet aber auf `Y`

Es bedeutet **nicht**:

- `X` wird erst erstellt, wenn `Y` abgeschlossen ist

Wenn du das zweite Verhalten möchtest, lass einen übergeordneten Workflow auf `Y` warten und rufe erst danach `start_workflows()` oder `start_agents()` für `X` auf.

## Verwandte Dokumentation

- [Workflow-Abhängigkeiten](https://queuety.inline0.dev/de/docs/workflows/dependencies)
- [Asynchrone Übergaben](https://queuety.inline0.dev/de/docs/workflows/async-handoffs)
- [Agenten-Orchestrierung](https://queuety.inline0.dev/de/docs/workflows/agent-orchestration)
- [Zustandsmaschinen](https://queuety.inline0.dev/de/docs/state-machines)