Neuron AI: a PHP agent framework for production agentic applications

The gap Neuron AI fills in a PHP codebase

Most agent tooling assumes Python or TypeScript. A PHP shop that wants an agent usually ends up running a second service, exposing it over HTTP, and keeping two deployment pipelines in sync. Neuron AI takes the other route: the agent is a PHP class in your application, the LLM provider is a constructor dependency, and the vector store is a service you already run. The stated requirement is PHP ^8.1, and the package installs through Composer like any other library.

The README frames the audience in terms of application shape rather than language features. It argues that new software is increasingly born agentic, with the agent driving how the system reasons, acts and talks to its interface, and that in PHP this set of foundations (event-driven workflows with checkpointing, human-in-the-loop interruption, multi-agent orchestration, streaming through AG-UI and the Vercel AI SDK protocol, MCP, and asynchronous execution) exists in one place. That is a positioning claim, not a benchmark, so treat it as a statement of intent. What is verifiable from the repository is narrower and more useful: there is a src/ tree, an examples/ directory with agent, stream-adapters and workflow folders, and a docker-compose.yml that starts ten different storage and search services for the test suite.

How an agent, its provider and its memory fit together

The central abstraction is the Agent class. You extend it and override two methods. provider() returns an implementation of AIProviderInterface, which is where the model vendor is chosen. instructions() returns the system prompt as a plain string. Everything else, including conversation memory and tool dispatch, is handled by the base class according to the README.

The README's own example wires an Anthropic provider:

<?php

namespace App\Neuron;

use NeuronAI\Agent\Agent;
use NeuronAI\Agent\SystemPrompt;
use NeuronAI\Providers\AIProviderInterface;
use NeuronAI\Providers\Anthropic\Anthropic;

class DataAnalystAgent extends Agent
{
    protected function provider(): AIProviderInterface
    {
        return new Anthropic(
            key: 'ANTHROPIC_API_KEY',
            model: 'ANTHROPIC_MODEL',
        );
    }

    protected function instructions(): string
    {
        return "You are a data analyst expert in creating reports from SQL databases.";
    }
}

The two string arguments are passed through as written in the README, so whether they are read from the environment or used literally is up to the surrounding application. The README does not spell out the resolution order, which is the kind of detail you want to confirm against your own configuration before assuming a key is picked up from .env.

Conversation state lives in the agent. The README shows two consecutive chat() calls, the second asking whether the agent remembers the first speaker's name, and the documented output is that it does. That is the memory mechanism in its simplest form. The documentation page on chat history and memory is where the retention and storage details live; the README only demonstrates the behaviour.

Installing Neuron AI and sending your first message

Installation is a single Composer command. The package name is neuron-core/neuron-ai.

composer require neuron-core/neuron-ai

The repository also ships a console entry point under bin/, and the README uses it to scaffold an agent class rather than asking you to write the file by hand.

vendor/bin/neuron make:agent DataAnalystAgent

The generated class lands in the App\Neuron namespace according to the README example. Fill in provider() and instructions(), then instantiate the agent with the static make() factory and send a UserMessage. The README's exchange looks like this:

$agent = DataAnalystAgent::make();

$response = $agent->chat(
    new UserMessage("Hi, I'm Valerio. Who are you?")
)->getMessage();
echo $response->getContent();

What you should see is the model's reply printed to standard output, and in the README's transcript that reply is a short self-description as a data analyst. The second call in the same process asks whether the agent remembers the name, and the documented answer confirms it does. If the second call behaves as a fresh conversation, the memory layer is not active in your setup.

Monitoring is a separate step and a separate product. The README says to set INSPECTOR_INGESTION_KEY in the application environment file:

INSPECTOR_INGESTION_KEY=fwe45gtxxxxxxxxxxxxxxxxxxxxxxxxxxxx

After that variable is set, the README states you will see the agent execution timeline in the Inspector dashboard. The key shown is a placeholder, not a working credential.

The vector store matrix is the real integration surface

RAG is where a framework meets infrastructure, and the repository's docker-compose.yml is the clearest signal of what has been exercised. It declares services for Qdrant, Chroma, Meilisearch, MySQL, MariaDB, OpenSearch, Weaviate, Neo4j, Elasticsearch and TypeSense, each pinned to a version in .env.example. The PHP container depends on all of them, with health checks on MySQL, MariaDB, OpenSearch, Elasticsearch and TypeSense, and plain service_started conditions on the rest.

The compose file carries an explicit warning at the top: local development and testing only, do not use in production. That is worth repeating because the temptation with a file like this is to treat it as a deployment recipe. It is not one. The PHP service runs with network_mode: host, which is a testing convenience and not a topology you would ship.

The breadth here is a genuine advantage for evaluation and a genuine cost for maintenance. Ten backends means ten sets of version pins to keep current, and the .env.example exposes each as an override (QDRANT_VERSION, CHROMA_VERSION, MEILISEARCH_VERSION, MYSQL_VERSION, MARIADB_VERSION, OPENSEARCH_VERSION, WEAVIATE_VERSION, NEO4J_VERSION, ELASTICSEARCH_VERSION, TYPESENSE_VERSION). Whether every backend has equal feature coverage in the RAG layer is not something the README states, and that is the first thing to check against your chosen store rather than assuming parity.

Where Neuron AI is the wrong tool

The framework's own framing is the honest limitation. The README states that in PHP this set of foundations exists in one place, and that there is no second framework waiting for you when the project grows. Read that as a statement about the ecosystem: if you leave Neuron AI, you are not moving to a comparable PHP alternative, you are moving to a different language and a different runtime.

That has consequences. A team that already runs Python services for data work will find more libraries, more community examples and more hiring overlap on that side. A team that needs a managed control plane with hosted tracing, evaluation dashboards and prompt versioning out of the box will find that Neuron AI's monitoring story routes through Inspector, a separate service with its own sign-up and ingestion key. The README does not describe a self-contained observability stack.

There is also the versioning problem the README names directly: same input does not equal same output, prompting is not programming in the usual sense, and long prompts cost latency. Nothing in the framework removes that. What it offers is the ability to inspect what the agent did, which is a debugging aid rather than a reproducibility guarantee. If your requirement is deterministic, auditable output, an agent framework is the wrong layer regardless of language.

The release cadence is dense. Three patch releases appear in the release list within a five-day window in September 2026 (3.16.10, 3.16.11, 3.16.12), and the default branch is 3.x. Frequent patch releases on a 3.x line are normal for a project whose last push was on 2026-09-09, but they also mean you should pin the version in composer.json and read the changelog before bumping, because the README does not document a deprecation or upgrade policy.

Neuron AI compared with LangChain-style Python tooling

The obvious comparison is with Python agent frameworks in the LangChain family. The difference is not feature count, it is where the agent runs. In a Python setup, the agent is a service your PHP application calls over HTTP or a queue. In Neuron AI, the agent is a class inside the PHP process, and the provider, the vector store and the memory are dependencies of that class.

That changes failure modes. A network hop between your application and the agent disappears, so latency and error handling get simpler. In exchange, agent execution now competes with your web request for the same PHP worker, and long tool chains or slow model calls hold that worker for their duration. The README points to asynchronous execution as a documented chapter, which is the escape hatch, but the default shape is synchronous and in-process.

The second difference is the extension model. The README describes Neuron as a vertical ecosystem with a registry of extensions, tools and technologies built specifically for agentic applications in PHP, and argues this matters for software houses that want to be recognized as specialists. That is a marketing argument, and it cuts both ways: a narrow ecosystem means less competition for attention and fewer third-party integrations to choose from. If your stack depends on a specific SaaS tool that has a Python SDK and no PHP one, the Python route is shorter.

Licence, upgrade cost and what to pin

The licence is MIT, stated in the repository metadata and present as a LICENSE file at the top level. MIT is permissive: it allows commercial use and modification with attribution, and it does not impose copyleft obligations on your application. That is the general shape of the licence and not legal advice; if your organisation has a policy on dependency licences, run it through that process.

The practical upgrade cost sits in two places. First, the package version, which you should pin in composer.json given the patch cadence visible in the release list. Second, the backend service versions in .env.example, which are overridable and therefore easy to drift. If you run Qdrant at v1.14.1 in development and something else in production, the compose file will not tell you whether the RAG layer behaves the same way.

There is also a tooling layer to account for. The repository carries PHPStan configuration (phpstan.neon), PHP CS Fixer (a .php-cs-fixer.dist.php), Rector (rector.php) and PHPUnit (phpunit.xml.dist). These are the project's own quality gates, not requirements imposed on your application, but they indicate the code is written to be analysed statically, which makes reading src/ a reasonable way to answer questions the documentation leaves open.

Editorial conclusion

Neuron AI fits PHP teams that already run Laravel or Symfony and want agents, tools and RAG inside the same process rather than in a separate Python service. It is the wrong choice if your team works in Python or TypeScript, or if you need a hosted control plane. Verify first that your PHP version meets the ^8.1 requirement, that an agent generated by vendor/bin/neuron make:agent runs against your chosen provider key, and that your vector store is one of the backends exercised by the repository's docker-compose.yml.

Frequently asked questions

Official sources

1. License: MIT
2. neuron-core/neuron-ai on GitHub
3. Project website
4. README
5. Releases