# Neuron Beroende arbetsflöden

Det här exemplet besvarar en vanlig fråga om agentbaserade system:

> Kan ett arbetsflöde avgöra att ett annat arbetsflöde ska fortsätta först när ett tidigare arbetsflöde har slutförts?

Ja. Den viktiga detaljen är att Queuety redan har stöd för detta med `wait_for_workflow()` och `wait_for_workflows()`.

Det innebär att:

- arbetsflöde `X` kan skickas iväg nu
- `X` kan pausas i `waiting_for_workflows`
- `X` återupptas först när arbetsflöde `Y` har slutförts

## Exempel: först research, sedan textskrivning

Använd ett arbetsflöde på toppnivå för att sammanställa ett researchunderlag och ett andra arbetsflöde på toppnivå för att utforma den slutliga texten.

### Researcharbetsflöde

```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',
    ]);
```

### Skrivarbetsflöde

```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',
    ]);
```

När skrivarbetsflödet startar pausas det omedelbart i `waiting_for_workflows` tills researcharbetsflödet har slutförts utan fel.

## Neuron-skrivsteget

```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']` är tillgängligt eftersom `wait_for_workflow()` kopierade det färdiga offentliga tillståndet från det beroende arbetsflödet till det aktuella arbetsflödet under nyckeln `research`.

## När du bör använda detta i stället för ett enda stort arbetsflöde

Välj separata arbetsflöden på toppnivå när:

- stegen har olika ansvariga eller operativa livscykler
- du vill granska och försöka köra dem igen oberoende av varandra
- ett senare steg ska kunna skickas iväg även innan det tidigare steget är klart

Välj ett arbetsflöde när:

- stegen är tätt sammankopplade
- de delar en livscykel och en tillståndspåse

## Vilken roll en tillståndsmaskin spelar

Om det här skrivflödet ingår i en längre redaktionell session kan du låta en [tillståndsmaskin](https://queuety.inline0.dev/sv/docs/state-machines) hantera den övergripande livscykeln och använda de här arbetsflödena för de avgränsade körningsstegen. Då blir livscykeltillstånd som `awaiting_brief`, `researching`, `awaiting_review` och `completed` tydliga, samtidigt som arbetsflödets beständighet bevaras i varje fas.

## En viktig skillnad

Det här mönstret innebär att:

- `X` finns nu, men väntar på `Y`

Det innebär **inte** att:

- `X` skapas först när `Y` är klart

Om du vill ha det senare beteendet kan du låta ett överordnat arbetsflöde vänta på `Y` och först därefter anropa `start_workflows()` eller `start_agents()` för `X`.

## Relaterad dokumentation

- [Beroenden mellan arbetsflöden](https://queuety.inline0.dev/sv/docs/workflows/dependencies)
- [Asynkrona överlämningar](https://queuety.inline0.dev/sv/docs/workflows/async-handoffs)
- [Agentorkestrering](https://queuety.inline0.dev/sv/docs/workflows/agent-orchestration)
- [Tillståndsmaskiner](https://queuety.inline0.dev/sv/docs/state-machines)