Why PHP Can Outperform Python for AI Agents: Introducing Neuron AI with Webman

Neuron AI for PHP

Neuron AI is an agentic framework for PHP that provides a lifecycle for creating, orchestrating, and debugging AI agents. It supports multiple LLM providers (Anthropic, OpenAI, Gemini, XAI, Bedrock, Azure) and built‑in toolkits (calculator, SQL, API integration). It is compatible with Laravel, Symfony, WordPress and other PHP frameworks.

Key advantages

All code stays in PHP, sharing repository, deployment, database, cache and middleware.

Low learning and maintenance cost for PHP teams.

The same stack eliminates cross‑language latency.

Webman + Neuron

Webman overview

Webman is a high‑performance PHP web framework built on Workerman. It runs in resident memory, uses coroutines and connection pools, and supports HTTP, WebSocket, TCP, UDP. Typical single‑node throughput reaches tens of thousands to hundreds of thousands of QPS even with database queries.

Resident memory removes PHP‑FPM request restart overhead.

Custom processes enable long‑running tasks such as queues or scheduled agent jobs.

Binary packaging (phar) allows deployment without a full PHP source.

Agents can share the same process with HTTP APIs, WebSocket, and business logic.

Direct access to local ORM/Redis eliminates cross‑service latency for tool calls.

Scaling is identical to ordinary web services.

Project skeleton

php-neuron-agent/
├── app/
│   ├── controller/
│   │   └── AgentController.php   # HTTP entry point
│   ├── agent/
│   │   ├── Orchestrator.php      # Multi‑agent orchestration
│   │   └── agents/
│   │       ├── CustomerServiceAgent.php
│   │       ├── DataAnalysisAgent.php
│   │       └── ToolsAgent.php
│   └── middleware/
├── config/
│   ├── neuron.php
│   ├── database.php
│   └── redis.php
├── public/
│   └── index.php
├── process/
│   └── AgentMonitor.php          # Optional custom process for monitoring/queues
├── composer.json
├── Dockerfile
└── docker-compose.yml

Step 1 – Install Neuron

composer require neuron-core/neuron-ai

Neuron provides a base Agent class. Sub‑class it and implement three methods: provider() – return an AIProviderInterface instance that selects the LLM provider and model. instructions() – return a system prompt string that defines role, background and rules. tools() – return an array of tool instances (e.g., CalculatorToolkit::make()).

Step 2 – Example Customer‑Service Agent

// app/agent/agents/CustomerServiceAgent.php
namespace app\agent\agents;

use NeuronAI\Agent;
use NeuronAI\Chat\Messages\UserMessage;
use NeuronAI\SystemPrompt;
use NeuronAI\Providers\Anthropic\Anthropic;
use NeuronAI\Providers\AIProviderInterface;
use NeuronAI\Tools\Toolkits\CalculatorToolkit;

class CustomerServiceAgent extends Agent
{
    protected function provider(): AIProviderInterface
    {
        // Switch between Anthropic, OpenAI, Gemini, etc.
        return new Anthropic(env('ANTHROPIC_API_KEY'), 'claude-4-5-sonnet');
    }

    public function instructions(): string
    {
        return (string) new SystemPrompt(
            background: [
                'You are a friendly customer‑service assistant.',
                'Answer using company knowledge base and order data; keep tone professional and concise.'
            ]
        );
    }

    public function tools(): array
    {
        return [
            CalculatorToolkit::make(),
            // OrderToolkit::make(),
            // KnowledgeBaseToolkit::make(),
        ];
    }
}

Step 3 – Call the agent from a Webman controller

// app/controller/AgentController.php
namespace app\controller;

use support\Request;
use app\agent\agents\CustomerServiceAgent;
use NeuronAI\Chat\Messages\UserMessage;

class AgentController
{
    public function chat(Request $request)
    {
        $q = $request->input('question', '');
        $agent = CustomerServiceAgent::make();
        $response = $agent->chat(new UserMessage($q));

        return json([
            'answer' => $response->getMessage()->getContent(),
        ]);
    }
}

The agent can also be run as a long‑living background service via Webman custom processes, sharing the same infrastructure as HTTP endpoints.

Multi‑Agent orchestration (Orchestrator)

Complex business logic often requires a primary orchestrator that delegates tasks to specialized sub‑agents.

// app/agent/Orchestrator.php
namespace app\agent;

use app\agent\agents\DataAnalysisAgent;
use app\agent\agents\CustomerServiceAgent;
use NeuronAI\Chat\Messages\UserMessage;

class Orchestrator
{
    public function run(string $userRequest): array
    {
        // 1) Main agent decomposes the request.
        // 2) Dispatch to sub‑agents.
        // 3) Execute in parallel or sequentially.
        // 4) Aggregate results and let the main agent produce final output.

        $serviceAgent = CustomerServiceAgent::make();
        $analysisAgent = DataAnalysisAgent::make();

        $serviceRes = $serviceAgent->chat(new UserMessage($userRequest));
        $analysisRes = $analysisAgent->chat(new UserMessage($userRequest));

        return [
            'customer_service' => $serviceRes->getMessage()->getContent(),
            'data_analysis'    => $analysisRes->getMessage()->getContent(),
        ];
    }
}

In production you can use Webman’s asynchronous or queue capabilities to run sub‑tasks in parallel, increasing throughput.

Real‑world scenarios

Scenario 1 – Data Q&A & automatic reporting

User input: “Generate a daily sales report for the last 30 days and list the top‑3 selling products.”

Main agent (e.g., Claude) splits the request into query, calculation, sorting, and summarization.

DataAnalysis agent executes an SQL query against the order database.

Tools agent performs aggregation, top‑3 calculation, and formatting.

Main agent composes a natural‑language report. All agents share the same ORM/Redis, avoiding cross‑language latency.

Scenario 2 – Customer service & ticket workflow

User input: “Has order #12345 shipped? If not, remind the logistics team.”

CustomerService agent checks order and logistics status via internal APIs.

Tools agent creates a reminder ticket if needed.

Main agent generates a friendly reply. Because the whole stack runs in the same PHP project, existing event and message‑queue systems can be reused without additional services.

Performance comparison

Why PHP can be competitive

Webman benchmarks with database queries report up to 390 000 QPS, roughly 80× faster than traditional PHP‑FPM.

In some cases Webman outperforms Go frameworks such as gin/echo by about 1×.

PHP 8.x JIT provides noticeable gains for CPU‑intensive calculations.

Combined with Neuron’s multi‑agent orchestration, the stack can handle medium‑scale production traffic.

Feature comparison (PHP vs Python)

Startup time: PHP runs in resident memory with near‑zero cold start; Python typically incurs hundreds of milliseconds due to dependency loading.

Memory usage: PHP processes use a few dozen MB; Python processes often exceed hundreds of MB and suffer GIL/GC pauses.

Concurrency: PHP leverages event‑driven architecture and custom processes; Python uses asyncio/Uvicorn. Both are capable.

Deployment complexity: PHP can reuse existing ops (single‑process or multi‑process); Python requires virtual environments and dependency management.

Business integration: PHP agents run in the same codebase as existing business logic; Python agents usually require cross‑language service calls.

Hot reload: Python offers instant code reload; PHP hot reload is less convenient.

For teams with substantial PHP assets, the PHP + Webman + Neuron combination offers lower onboarding cost, tighter integration, and comparable performance to Python‑based solutions.