# Neuron Geheugen- en beoordelingstoestandsmachine

Dit patroon is handig wanneer een agent context uit eerdere gesprekken moet behouden tijdens herhaalde beoordelingsrondes met mensen, terwijl Queuety de volledige levenscyclus blijft orkestreren.

Queuety beheert de beoordelingstoestandsmachine, terwijl Neuron het agentgeheugen voor de schrijfdraad beheert.

## Waarom geheugen van Neuron hier helpt

Als een beoordelaar een concept afwijst en om aanpassingen vraagt, hoeft de volgende agentaanroep niet de volledige context opnieuw op te bouwen.

De `SQLChatHistory` van Neuron is hiervoor geschikt, omdat de agent binnen dezelfde gespreksthread kan blijven werken terwijl Queuety beslissingen van reviewers en revisierondes afhandelt.

## De agent van Neuron met geschiedenis op basis van SQL

```php
namespace App\Neuron;

use NeuronAI\Agent\Agent;
use NeuronAI\Chat\History\ChatHistoryInterface;
use NeuronAI\Chat\History\SQLChatHistory;
use NeuronAI\Providers\AIProviderInterface;
use NeuronAI\Providers\Anthropic\Anthropic;
use NeuronAI\SystemPrompt;

final class EditorAgent extends Agent
{
    public function __construct(
        private readonly string $threadId,
        private readonly \PDO $pdo,
    ) {}

    protected function provider(): AIProviderInterface
    {
        return new Anthropic(
            key: $_ENV['ANTHROPIC_API_KEY'],
            model: $_ENV['ANTHROPIC_MODEL'],
        );
    }

    protected function chatHistory(): ChatHistoryInterface
    {
        return new SQLChatHistory(
            thread_id: $this->threadId,
            pdo: $this->pdo,
            table: 'neuron_chat_history',
            contextWindow: 50000,
        );
    }

    public function instructions(): string
    {
        return (string) new SystemPrompt(
            background: [
                'You are an editorial agent for long-form product briefs.',
                'Apply reviewer notes without losing the original intent.',
            ],
        );
    }
}
```

## Schrijf een eerste versie en herzie die met dezelfde geheugendraad

```php
namespace App\StateMachines\Actions;

use App\Neuron\EditorAgent;
use NeuronAI\Chat\Messages\UserMessage;
use Queuety\Contracts\StateAction;

final class DraftBriefAction implements StateAction
{
    public function handle(array $state, ?string $event = null, array $event_payload = [], array $payload = []): array|string
    {
        // Queuety creates actions with `new DraftBriefAction()`, so build dependencies here.
        $pdo = new \PDO($_ENV['NEURON_DB_DSN'], $_ENV['NEURON_DB_USER'], $_ENV['NEURON_DB_PASSWORD']);

        $threadId = $state['neuron_thread_id'] ?? sprintf(
            'brief:%d:editor',
            $state['brief_id'],
        );

        $prompt = "Write the first draft for brief {$state['brief_id']}.";

        if ('reject' === $event) {
            $prompt = sprintf(
                'Revise the draft using these review notes: %s',
                $event_payload['reason'] ?? 'Tighten the draft and address reviewer concerns.',
            );
        }

        $agent = new EditorAgent($threadId, $pdo);
        $message = $agent->chat(
            new UserMessage($prompt)
        )->getMessage();

        return [
            'neuron_thread_id' => $threadId,
            'draft_markdown' => $message->getContent(),
            'review_round' => (int) ($state['review_round'] ?? 0) + 1,
            '_event' => 'draft_ready',
        ];
    }
}
```

## De toestandsmachine van Queuety

```php
use Queuety\Enums\StateMachineStatus;
use Queuety\Queuety;

$machine_id = Queuety::machine('brief_review_session')
    ->version('brief-review-session.v1')
    ->state('drafting')
    ->action(DraftBriefAction::class)
    ->on('draft_ready', 'awaiting_review')
    ->state('awaiting_review')
    ->on('approve', 'completed')
    ->on('reject', 'drafting')
    ->state('completed', StateMachineStatus::Completed)
    ->dispatch([
        'brief_id' => 42,
    ]);

// Later, once the draft action has finished and the machine waits in `awaiting_review`:
Queuety::machine_event(
    $machine_id,
    'reject',
    [ 'reason' => 'Tighten the introduction and add pricing context.' ]
);

Queuety::machine_event(
    $machine_id,
    'approve',
    [ 'reviewer' => 'editor@example.com' ]
);
```

De eerste doorgang begint in `drafting`, voert de actie in de wachtrij uit en gaat over naar `awaiting_review`.

Als de beoordelaar het concept afwijst, gaat de machine terug naar `drafting`. Omdat de gebeurtenispayload `reject` wordt doorgegeven aan `DraftBriefAction`, kan het volgende concept de opmerkingen van de beoordelaar gebruiken zonder de oorspronkelijke geschiedenis van de Neuron-draad kwijt te raken.

## Waarom dit overzichtelijker is dan een workflow herhalen

Dit probleem draait om de levenscyclus. Een concept wacht op beoordeling door een mens, de beoordelaar kan het goedkeuren of afwijzen, een afwijzing brengt de sessie terug naar het opstellen en goedkeuring beëindigt de sessie. Dat past beter bij een toestandsmachine dan bij een lineaire workflow met een terugkoppeling.

Workflowstatus is nog steeds uitstekend voor orkestratiegegevens zoals het aantal beoordelingsrondes, artefact-ID's, workflow-ID's en routeringsbeslissingen. Het geheugen van Neuron is beter geschikt voor gesprekscontext zoals eerdere prompts, iteratieve herzieningen en modelreacties die deel moeten blijven uitmaken van de schrijfdraad.

Door beide te gebruiken, krijgt elk systeem de taak waar het het best voor geschikt is.

## Wanneer u dit beter als workflow houdt

Kies voor een workflow wanneer het beoordelingstraject duidelijk is afgebakend en op uitvoering is gericht, bijvoorbeeld:

Eén concept genereren, op één goedkeuring wachten en publiceren.

Kies voor een toestandsmachine wanneer de sessie dezelfde statussen meerdere keren kan doorlopen en externe gebeurtenissen de levenscyclus bepalen.

## Gerelateerde documentatie

- [Toestandsmachines](https://queuety.inline0.dev/nl/docs/state-machines)
- [Workflowsignalen](https://queuety.inline0.dev/nl/docs/workflows/signals)
- [Agentorkestratie](https://queuety.inline0.dev/nl/docs/workflows/agent-orchestration)