# Neuron Planificator / Executor

Acest exemplu folosește Queuety pentru orchestrare și Neuron pentru execuția propriu-zisă a agentului.

Modelul este simplu. Un pas de planificare Queuety decide ce activități sunt necesare, `start_agents()` le transformă în fluxuri de lucru independente de nivel superior, fiecare flux de lucru copil rulează un agent Neuron, iar `wait_for_agents()` agregă rezultatele înapoi în fluxul de lucru părinte.

## De ce funcționează bine această împărțire

Neuron permite schimbarea furnizorilor cu modificări minime ale codului și încapsulează promptul, instrumentele și memoria unui agent specializat. Queuety gestionează bine procesarea durabilă for-each și modurile de finalizare, reîncercările, reluarea execuției și interfețele de inspectare sau revizuire umană din jurul execuției.

## Pasul 1: creați un agent Neuron cu furnizor interschimbabil

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

Partea utilă aici este că fluxul de lucru poate alege furnizorul în timpul execuției, transmițând `provider` în starea fluxului de lucru.

## Pasul 2: rulați agentul Neuron într-un pas Queuety

```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 [];
    }
}
```

Acesta este punctul-cheie al integrării: Neuron gestionează apelul LLM, însă Queuety păstrează controlul asupra limitei pasului și a stării persistente a fluxului de lucru.

## Pasul 3: permiteți planificatorului să pornească execuțiile agenților

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

Dacă `PlanResearchTasksStep` returnează:

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

Queuety va crea un flux de lucru de nivel superior pentru fiecare activitate, va aștepta finalizarea tuturor, apoi va transmite starea finalizată a fluxurilor de lucru copil sub `$state['agent_results']`.

## De ce să nu apelați pur și simplu Neuron într-o buclă?

Ați putea face asta, dar ați pierde avantajele orchestrării:

Fiecare execuție a agentului nu ar mai putea fi inspectată individual, o cădere parțială ar reporni probabil întregul lot, iar etapele ulterioare nu ar avea un punct clar de finalizare.

Acest model păstrează simplitatea codului agentului, lăsând Queuety să gestioneze orchestrarea durabilă.

Dacă planificatorul face parte dintr-o sesiune de agent de durată mai lungă, păstrați acest model de flux de lucru pentru nivelul de execuție și lăsați o [mașină de stări](https://queuety.inline0.dev/ro/docs/state-machines) să gestioneze ciclul de viață exterior.

## Documentație asociată

- [Transferuri asincrone](https://queuety.inline0.dev/ro/docs/workflows/async-handoffs)
- [Orchestrarea agenților](https://queuety.inline0.dev/ro/docs/workflows/agent-orchestration)
- [Mașini de stări](https://queuety.inline0.dev/ro/docs/state-machines)