Laravel PAO: Strukturierte AI-Agent-Outputs für Self-Hosted LLMs — Token sparen, Fehler vermeiden.

Dein AI-Agent führt php artisan test aus, bekommt 2.000 Zeichen ANSI-dekorierten Terminal-Output zurück — und verbrennt Token damit, Fortschrittsbalken und Punkt-Separatoren zu parsen. Bei Cloud-APIs ist das ärgerlich. Bei Self-Hosted LLMs mit begrenztem Context-Window ist es ein echtes Problem.

#Das Problem: Chaotische AI-Agent-Outputs kosten Token und verursachen Fehler

PHP-Entwickler kennen den täglichen Feedback-Loop: testen, fixen, analysieren, refactoren, wieder testen. Die Tools in diesem Loop — PHPUnit, Pest, PHPStan, Rector, Artisan — produzieren Output, der für menschliche Terminals optimiert ist: ANSI-Farben, Box-Drawing-Zeichen, Punkt-Separatoren, dekorierte Tabellen.

Für dich als Entwickler ist das angenehm zu lesen. Für einen AI-Agent ist es Rauschen. Der Agent muss aus dem dekorierten Output die relevanten Informationen extrahieren: welche Assertion fehlgeschlagen ist, in welcher Datei, auf welcher Zeile. Das kostet Token — und bei jedem Test-Run akkumuliert sich dieser Overhead.

In längeren Agent-Sessions wird das kritisch: Test-Output, der sich über Dutzende Runs ansammelt, konkurriert mit Code und Konversationshistorie um das Context-Window. Bei Self-Hosted LLMs wie Llama oder Mistral via Ollama, die typischerweise kleinere Context-Windows haben als GPT-4 oder Claude, kann das den Unterschied zwischen einem funktionierenden und einem halluzinierenden Agent ausmachen.

#Was ist Laravel PAO und warum es für Agenturen relevant ist

Laravel PAO (PHP Agent-Optimized Output) löst genau dieses Problem. Das Paket erkennt automatisch, wann PHP-Tools innerhalb einer AI-Agent-Umgebung laufen — Claude Code, Cursor, Devin, Gemini CLI oder andere — und ersetzt den menschenlesbaren Output durch kompaktes, strukturiertes JSON.

Entscheidend: PAO verändert nichts an deinem normalen Terminal-Workflow. Wenn du phpunit oder pest direkt im Terminal ausführst, bleibt alles beim Alten. PAO aktiviert sich nur, wenn ein Agent erkannt wird.

Seit Mai 2026 ist PAO als Dev-Dependency standardmäßig in neuen Laravel-Anwendungen enthalten. Es funktioniert aber nicht nur mit Laravel — jedes PHP-Projekt, das PHPUnit, Pest, Paratest, PHPStan, Rector oder Laravel Artisan nutzt, profitiert davon. Voraussetzung ist PHP 8.3+ und Laravel 12+.

Für Agenturen, die AI-gestützte Entwicklungsworkflows mit Self-Hosted LLMs aufbauen, ist PAO ein Produktivitäts-Multiplikator: weniger Token-Verbrauch, determinierbarere Outputs und ein Agent, der schneller versteht, was passiert ist.

#Die Architektur: Wie PAO strukturierte Outputs erzeugt

PAO arbeitet über Composers file-Autoload und injiziert sich früh in den PHP-Prozess. Der Ablauf:

1. Agent-Erkennung: PAO nutzt das laravel/agent-detector-Paket, um zu prüfen, ob der Prozess in einer Agent-Umgebung läuft (via Umgebungsvariablen wie AI_AGENT)
2. Driver-Auswahl: Je nach ausgeführtem Befehl wählt PAO den passenden Driver — PHPUnit, Pest, Paratest, PHPStan, Rector oder Artisan
3. Native APIs statt Scraping: PAO scrapt keinen Terminal-Output. Für Test-Runner nutzt es die internen Result-APIs von PHPUnit direkt
4. JSON-Output: Am Ende des Prozesses wird ein kompaktes JSON-Objekt ausgegeben

Für Artisan-Commands ist der Ansatz anders: Hier wird kein JSON erzeugt, sondern der dekorierte Output bereinigt — ANSI-Codes, Box-Drawing-Zeichen und überflüssige Whitespaces werden entfernt. Die Information bleibt gleich, die Token-Last sinkt.

Die Steuerung erfolgt über Umgebungsvariablen:

• PAO_DISABLE=1 — deaktiviert PAO komplett
• PAO_FORCE=1 — erzwingt PAO auch ohne erkannten Agent
• AI_AGENT=copilot — manuelles Setzen des Agent-Typs

#Praktisches Setup: PAO mit Ollama und Self-Hosted-LLMs integrieren

#Schritt 1: Ollama installieren und Modell laden

# Ollama installieren (Linux)
curl -fsSL https://ollama.com/install.sh | sh

# Modell laden — z.B. Llama 3.2 für Code-Tasks
ollama pull llama3.2:3b

# Prüfen, ob Ollama läuft
curl http://localhost:11434
# → "Ollama is running"

#Schritt 2: PAO in dein Projekt einbinden

# Für bestehende Projekte
composer require --dev laravel/pao

# Neue Laravel-Projekte haben PAO bereits als Dev-Dependency

Das war’s. Kein Config-File, kein Service-Provider, kein zusätzliches Setup. PAO hookt sich automatisch über Composers Autoloader ein.

#Schritt 3: PAO testen

Um PAO manuell zu testen, ohne einen echten AI-Agent zu nutzen:

# PAO erzwingen
PAO_FORCE=1 php artisan test

# Oder Agent simulieren
AI_AGENT=codex php artisan test

Du solltest jetzt kompaktes JSON statt dekoriertem Terminal-Output sehen.

#Schritt 4: Laravel AI SDK mit Ollama verbinden

Wenn du das offizielle Laravel AI SDK nutzt, konfigurierst du Ollama als Provider in config/ai.php:

// config/ai.php
'providers' => [
    'ollama' => [
        'driver' => 'ollama',
        'key' => env('OLLAMA_API_KEY', ''),
        'url' => env('OLLAMA_BASE_URL', 'http://localhost:11434'),
    ],
],

In deiner .env:

OLLAMA_API_KEY=
OLLAMA_BASE_URL=http://localhost:11434

#Token-Einsparungen und Performance: Die Zahlen

Die Zahlen sprechen für sich:

Der Output bei bestandenen Tests ist konstant — unabhängig davon, ob du 10 oder 10.000 Tests hast. Bei fehlgeschlagenen Tests enthält das JSON Dateipfade, Zeilennummern und Fehlermeldungen — genau die Informationen, die der Agent braucht.

Der größere Gewinn zeigt sich in längeren Agent-Sessions: Test-Output, der sich über Dutzende Runs akkumuliert, konkurriert nicht mehr mit Code und Konversationshistorie um das Context-Window. Für Self-Hosted LLMs mit typischerweise 4K–32K Context-Window ist das der Unterschied zwischen einem produktiven und einem nutzlosen Agent.

#Code-Beispiel: Ein Code-Review-Agent mit PAO und dem Laravel AI SDK

Hier ein vollständiges Beispiel eines Agents, der Code-Reviews durchführt und dabei von PAOs strukturierten Test-Outputs profitiert:

<?php

namespace App\Ai\Agents;

use Illuminate\Contracts\JsonSchema\JsonSchema;
use Laravel\Ai\Contracts\Agent;
use Laravel\Ai\Contracts\HasStructuredOutput;
use Laravel\Ai\Contracts\HasTools;
use Laravel\Ai\Promptable;
use Laravel\Ai\Attributes\Provider;
use Laravel\Ai\Attributes\Model;
use Laravel\Ai\Attributes\Temperature;

#[Provider('ollama')]
#[Model('llama3.2:3b')]
#[Temperature(0.2)]
class CodeReviewAgent implements Agent, HasStructuredOutput, HasTools
{
    use Promptable;

    public function instructions(): string
    {
        return <<<'PROMPT'
        Du bist ein Senior PHP-Entwickler. Analysiere den gegebenen
        Code und die Test-Ergebnisse. Gib strukturiertes Feedback
        mit konkreten Verbesserungsvorschlägen.
        PROMPT;
    }

    public function schema(JsonSchema $schema): array
    {
        return [
            'quality_score' => $schema->integer()
                ->description('Code-Qualität von 1-10')
                ->required(),
            'issues' => $schema->array()
                ->items($schema->object(fn ($s) => [
                    'file' => $s->string()->required(),
                    'line' => $s->integer()->required(),
                    'severity' => $s->string()->required(),
                    'suggestion' => $s->string()->required(),
                ]))
                ->required(),
            'summary' => $schema->string()
                ->description('Zusammenfassung in 2-3 Sätzen')
                ->required(),
        ];
    }

    public function tools(): iterable
    {
        return [];
    }
}

Verwendung in einem Artisan-Command:

use App\Ai\Agents\CodeReviewAgent;

$agent = new CodeReviewAgent();
$response = $agent->prompt(
    "Review diesen Controller und die zugehörigen Test-Ergebnisse:\n\n"
    . file_get_contents(app_path('Http/Controllers/OrderController.php'))
);

// Strukturierter Zugriff auf die Ergebnisse
$score = $response['quality_score'];    // z.B. 7
$issues = $response['issues'];          // Array mit konkreten Issues
$summary = $response['summary'];        // Zusammenfassung

Weil PAO die Test-Outputs bereits als kompaktes JSON liefert, muss der Agent kein Terminal-Parsing betreiben. Die Token, die er spart, kann er für die eigentliche Analyse nutzen.

#Grenzen und Fallstricke: Wann PAO nicht ausreicht

PAO ist kein Allheilmittel. Einige Einschränkungen solltest du kennen:

• Nur Tool-Output: PAO optimiert die Ausgabe von PHPUnit, Pest, PHPStan, Rector und Artisan. Es strukturiert nicht die Kommunikation zwischen Agents oder die Prompts selbst.
• Agent-Erkennung nicht immer zuverlässig: GitHub Copilot in VS Code wird nicht immer automatisch erkannt. Workaround: export AI_AGENT=copilot in deiner .bashrc.
• Edge Cases bei Zero-Tests: Wenn Pest keine Tests findet und mit Exit-Code 1 beendet, meldet PAO aktuell trotzdem "result": "passed" — ein bekannter Bug, der in Agent-Workflows zu falscher Zuversicht führen kann.
• Kein Ersatz für Structured Output im AI SDK: PAO optimiert Tool-Output für Agents. Für strukturierte Agent-Antworten brauchst du das HasStructuredOutput-Interface des Laravel AI SDK.
• Self-Hosted LLM-Qualität: PAO kann die Token-Effizienz verbessern, aber die Qualität der Agent-Antworten hängt weiterhin vom gewählten Modell ab. Kleinere Modelle wie llama3.2:3b sind für einfache Tasks geeignet, für komplexe Code-Reviews brauchst du leistungsfähigere Modelle.

#Fazit: Struktur statt Hype — PAO als Produktions-Tool

Laravel PAO ist kein revolutionäres Framework und will es auch nicht sein. Es löst ein konkretes, messbares Problem: AI-Agents verschwenden Token und Context-Window mit dekoriertem Terminal-Output, der für Menschen gemacht ist.

Die Lösung ist elegant: Zero-Config-Installation, automatische Agent-Erkennung, strukturiertes JSON für Testing-Tools und bereinigter Output für Artisan-Commands. Für Agenturen, die Self-Hosted LLMs mit Ollama einsetzen und jeden Token zählen müssen, ist PAO ein No-Brainer.

Zusammen mit dem Laravel AI SDK und dessen Ollama-Support ergibt sich ein vollständiger Stack für AI-gestützte Entwicklungsworkflows — komplett in PHP, ohne Python-Abhängigkeiten, mit determinierbaren Outputs.

Nächste Schritte:

• Laravel PAO auf GitHub installieren und mit PAO_FORCE=1 testen
• Laravel AI SDK Dokumentation für strukturierte Agent-Outputs lesen
• Ollama mit einem Code-Modell wie codellama oder llama3.2 aufsetzen und den ersten Agent bauen