# Neuron Planerare/exekverare

Det här exemplet använder Queuety för orkestrering och Neuron för själva agentkörningen.

Mönstret är enkelt. Ett planeringssteg i Queuety avgör vilket arbete som behövs, `start_agents()` omvandlar uppgifterna till fristående arbetsflöden på toppnivå, varje underordnat arbetsflöde kör en Neuron-agent och `wait_for_agents()` samlar resultaten i det överordnade arbetsflödet.

## Därför fungerar den här uppdelningen bra

Neuron är bra på att byta leverantör med minimala kodändringar och samla instruktioner, verktyg och minne för en specialistagent. Queuety är bra på beständiga for-each- och slutförandelägen, omförsök, återupptagning samt gränssnitt för inspektion eller mänsklig granskning av körningen.

## Steg 1: skapa en Neuron-agent vars leverantör kan bytas

```php
namespace App\Neuron;

use NeuronAI\Agent\Agent;
use NeuronAI\Providers\AIProviderInterface;
use NeuronAI\Providers\Anthropic\Anthropic;
use NeuronAI\Providers\Gemini\Gemini;
use NeuronAI\Providers\OpenAI\Responses\OpenAIResponses;
use NeuronAI\SystemPrompt;

final class ResearchAgent extends Agent
{
    public function __construct(
        private readonly string $providerName = 'openai',
    ) {}

    protected function provider(): AIProviderInterface
    {
        return match ($this->providerName) {
            'anthropic' => new Anthropic(
                key: $_ENV['ANTHROPIC_API_KEY'],
                model: $_ENV['ANTHROPIC_MODEL'],
            ),
            'gemini' => new Gemini(
                key: $_ENV['GEMINI_API_KEY'],
                model: $_ENV['GEMINI_MODEL'],
            ),
            default => new OpenAIResponses(
                key: $_ENV['OPENAI_API_KEY'],
                model: $_ENV['OPENAI_MODEL'],
            ),
        };
    }

    public function instructions(): string
    {
        return (string) new SystemPrompt(
            background: [
                'You are a research agent.',
                'Return concise, source-aware summaries for the assigned topic.',
            ],
        );
    }
}
```

Det praktiska här är att arbetsflödet kan välja leverantör vid körning genom att skicka `provider` i arbetsflödestillståndet.

## Steg 2: kör Neuron-agenten i ett Queuety-steg

```php
namespace App\Workflow\Steps;

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

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

        $message = $agent->chat(
            new UserMessage(sprintf(
                "Research the topic '%s' for brief %d. Return a compact bullet summary.",
                $state['topic'],
                $state['brief_id'],
            ))
        )->getMessage();

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

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

Det här är den centrala integrationspunkten: Neuron hanterar LLM-anropet, men Queuety ansvarar fortfarande för stegets gräns och det sparade arbetsflödestillståndet.

## Steg 3: låt planeraren starta agentkörningar

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

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

Queuety::workflow('brief_research')
    ->version('brief-research.v1')
    ->then(PlanResearchTasksStep::class) // writes $state['agent_tasks']
    ->start_agents('agent_tasks', $agent_workflow)
    ->wait_for_agents(mode: WaitMode::All, result_key: 'agent_results')
    ->then(SynthesizeBriefStep::class)
    ->dispatch([
        'brief_id' => 42,
        'provider' => 'anthropic',
    ]);
```

Om `PlanResearchTasksStep` returnerar:

```php
[
    'agent_tasks' => [
        ['topic' => 'pricing'],
        ['topic' => 'customer reviews'],
        ['topic' => 'recent launches'],
    ],
]
```

Queuety skapar ett arbetsflöde på toppnivå per uppgift, väntar tills alla är klara och skickar sedan det färdiga underordnade arbetsflödestillståndet under `$state['agent_results']`.

## Varför inte bara anropa Neuron i en loop?

Det går, men då förlorar du fördelarna med orkestreringen:

Varje agentkörning skulle inte längre kunna granskas separat, en delvis krasch skulle troligen starta om hela körningen och det skulle saknas en tydlig slutpunkt för senare steg.

Med det här mönstret hålls agentkoden enkel, samtidigt som Queuety sköter den beständiga orkestreringen.

Om planeraren ingår i en längre agentsession kan du behålla det här arbetsflödesmönstret för körningslagret och låta en [tillståndsmaskin](https://queuety.inline0.dev/sv/docs/state-machines) hantera den övergripande livscykeln.

## Relaterad dokumentation

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