Neuron AI - PHP Agentic Framework

Home
Italia
Napoli, Campania
Neuron AI - PHP Agentic Framework

Neuron AI is the First Agentic Framework of the PHP Ecosystem

04/11/2026

This workflow lists 5 nodes. The list doesn't show how they connect.

It's WarehouseManagementWorkflow, from the demo of our partner Knotic, the VS Code based IDE by Riccardo Tartaglia and Lorenzo Ravano. One PHP file. Let's read it together.

nodes() returns ReceiveShipmentNode, QualityCheckNode, AllocateBinNode, RecordInventoryNode and EscalateOverflowNode. Now you know what exists. The sequence comes from the events, because in Neuron every node declares what it accepts and what it returns:

ReceiveShipmentNode: StartEvent → ShipmentReceivedEvent
QualityCheckNode: ShipmentReceivedEvent → GoodsInspectedEvent
AllocateBinNode: GoodsInspectedEvent → BinAllocatedEvent, OverflowEvent

That third line is the fork. In the file it arrives at line 94. In the Neuron Workflows graph, built into Knotic, you see it without scrolling: two paths, one stop.

Click QualityCheckNode in the graph and the editor jumps to line 78. Line 80 is __invoke(ShipmentReceivedEvent $event, WorkflowState $state): GoodsInspectedEvent. The same two events you just read in the graph.

RecordInventoryNode and EscalateOverflowNode read the same way: each one declares what it accepts and returns. All of this is PHP classes and events. In Neuron everything is a workflow, agents included.

🔐 If you lead a team: whoever reviews a workflow they didn't write can check each arrow against its signature, one click away.

Neuron Workflows works with Neuron v4. Knotic has a free plan to get started, and it's compatible with the setup skills that ship with neuron-ai, so the one-prompt setup through your coding agent works there too.

Save this for the next time you open a workflow you didn't write. Landing in the first comment 👇

04/11/2026

Unlock magic in your UI by simply binding classes to the neuron AI container. By using attributes and Symfony Messenger, you can build modular agentic systems that run seamlessly in the background. Ever wondered how to stream agent responses directly to your interface?
Full video: https://www.youtube.com/watch?v=57L07JpF6p4&list=PLbsPodEd58lA&index=11

03/11/2026

Modern agentic protocols are evolving, and UI libraries are the bridge between back-end processes and what you see on screen. They handle the rendering of real-time tool calls, giving developers a way to visualize exactly what is happening under the hood. Does this change how you build?

03/11/2026

The prompt of this Drupal agent tells the model not to ask for confirmation before saving an article. The approval is in the code instead. 🔐

In the demo Valerio ran live at Drupal Camp Italy, asking for approval isn't the model's job. Valerio has now published the repo, so here's how it works.

The setup: a Drupal 11 site with the Umami demo content (a food magazine) and two agents in the admin panel, built with Neuron AI and connected to Drupal by ai_neuron, the module by Antonio De Marco of Nuvole.

The Concierge is an editorial assistant. It finds articles, summarizes and reviews them, improves them and writes drafts. It has four tools: two read, two write.

The two that write, update_article and create_article, are the only ones that call requireApproval() on the Neuron tool. When the agent wants to save, the run stops and the editor gets approve or reject in the chat. That's why the prompt tells the model to call them directly: "The editor approves both in the interface".

A rule written in a prompt depends on the model remembering it. A requireApproval() call doesn't. For any agent that writes to a CMS, this is the choice we'd copy.

When the editor answers, the suspended run resumes, and what lands in Drupal is plain Drupal. An approved edit becomes a new revision of the article, logged as "Edited by the Drupal Concierge." A new article is saved as an unpublished draft.

Under the hood, runs stay out of the web request: Drupal queues the turn with Symfony Messenger, a worker runs the agent, and the output streams to the browser as AG-UI events over Mercure. A second agent, Intelligence, answers questions about how the site is used (popular content, active users, failed logins, 404s) with metric cards, charts and tables.

🔐 If you decide what an agent may touch on your Drupal sites: the gate doesn't depend on the model, every change is a revision you can roll back like any other, and no draft goes online on its own.

You can run it on your machine. Docker and an Anthropic key, then ./scripts/setup.sh (a few minutes the first time), and open /admin/concierge on localhost:8080. It's a local demo with default passwords and no HTTPS, so keep it off the internet. The agents and tools are plugins in the neuron_demo module, worth a read.

Clone it and try the approval step yourself, links in the first comment 👇

02/11/2026

The provider keeps no session for you. Every call to the model starts from zero. 📨

That's the first fact in a new video by Arias, where he opens the envelope of a single agent call in PHP with Neuron: what goes to the model, and what comes back.

His words: "The provider keeps no session for us. There's no memory on the other side."

So every request carries everything again: the model, the system instructions, the whole message history (tool calls and tool results included), the tools with their name, description and JSON schema, and the generation parameters.

This is where the cost comes from. Each tool call adds a round, and each round sends the whole conversation back. More tool calls, more tokens, more time.

None of this is hidden. Every response comes back with a stop reason (tool_use, then end_turn) and the usage: input and output tokens. Hidran's advice: "That usage is our cost meter. So, it's worth logging from the very first prototype."

For whoever approves the budget of an AI feature, that's the useful part: the cost of an agent is written in every response, and you can log it before a single user arrives.

Two more things from the video:
🔀 Anthropic sends the tool result inside a user message, OpenAI uses a separate tool role. "Neuron AI handles that difference for us", so you don't write that mapping yourself.
🧾 The system prompt is "the specification of the whole agent": identity, procedure, constraints, output contract. Picture a fast, skilled contractor who knows nothing about your company, asks no questions and forgets everything between one task and the next. That's who you're writing it for.

Save this for the day someone asks what your agent costs. Hidran's video (10:06) and the code are in the first comment 👇

30/10/2026

You don't learn Neuron. Your coding agent does.
But someone on your team still needs the map. 🗺️

Not every method. The shape of the application: a workflow at the center, and four pieces attached to it.

🔌 Messaging layer: one interface across providers
📡 Streaming: from the agent to the UI
🧠 Memory: context and semantic memory
🧰 Tools: tools and toolkits

Your coding agent will build each of them. Where they attach to the workflow, and what each one is allowed to do, comes from your specs. Without the map, those choices still get made, one prompt at a time, by whoever happens to write the prompt.

For a developer, the map is what makes a spec short and a review quick. For whoever runs the team, one map shared by everyone means one architecture to review, not one per developer.

That's the Kickstart. With the people who built Neuron and your PHP project on the table, we draw that picture with your team, component by component, then a live Q&A on your architecture.

It starts with a short intro call. If there's a fit, your team's first session is on us. Book your intro call: https://neuron-ai.dev/kickstart

29/10/2026

Can your coding agent write the agentic framework for you?

Someone asked exactly this on our Neuron v4 announcement thread on r/PHP. It's a fair question. If an agent can write a library in an afternoon, why take on a dependency?

Two answers came back on the thread.

💬 u/penguin_digital, from the community: "Strictly speaking the answer is no, practically speaking the answer is yes." His advice: build one without a framework to learn, it teaches you a lot. In a larger production app with multiple developers, he wouldn't.

💬 Valerio Barbera (u/valerione), CTO of Neuron AI, on the same thread: "The complexity and risks are too high, probably 10x more than devs can even imagine." His distinction is between micro-libraries and systemic frameworks: "Micro dependencies were always risky, but the cost of building even tiny libraries made the adoption of external dependencies convenient. [...] Systemic frameworks have a different role and meaning."

The line we draw from it:

A coding agent lowered the cost of writing code. It didn't lower the cost of owning it.

🧩 A micro-library: let the agent write it. A few lines your team can read and keep.
🏗️ A system framework: persistence, state, multi-agent coordination, every provider API that changes, every security fix. You can generate it in an afternoon. Your team then maintains it for as long as the app lives.

That's the layer Neuron takes off your plate. In Neuron everything is a workflow: state persists, runs pause and resume, a human can step in, agents coordinate. MIT licensed, built and maintained by the team behind Inspector.

When you don't need it, honestly:
📚 you're learning how LLMs work (build it by hand, you'll learn more that way)
💬 one prompt in, one answer out, no state, no tools
🧪 a prototype you'll throw away

If you sign off on the stack, ask one more question after "can we build it?": who maintains it when the dev who prompted it moves on?

Start with one prompt to your coding agent: https://docs.neuron-ai.dev
The full thread on r/PHP: https://www.reddit.com/r/PHP/comments/1wuv117/neuron_4_is_here_welcome_to_the_php_agentic_era/

29/10/2026

Four messages, two calls to the model, one run of a tool. 🔁
That's a whole agent run, printed step by step in a new video by Arias.

It starts from a fact many of us skip: a model cannot run code. It only writes text. When it needs something from your application, it writes a structured request, "run this tool with these arguments", and your PHP code does the work.

Hidran builds a small tool to show it: PackageVersionTool, which reads the installed version of a Composer package. Then he asks the agent a question and prints the steps of the run:

1. user: the question
2. tool call: the model asks for the tool, with arguments
3. tool result: what the PHP code returned
4. assistant: the final answer

In his words: "Four messages, two calls to the model, one run of our tool. That's the agent loop."

Then he asks something generic, "What does composer install do?", and no tool runs. The model answers on its own. "Nobody wrote an if statement for this. The model made the choice."

In Neuron a tool is a class: a name and a description (the only part the model reads), a schema for the arguments, and an __invoke() method with your logic. You register it in the agent's tools() method. The loop that asks, executes and sends the result back is not something you write: "The good news is that Neuron AI runs this loop for us." It also counts how many times each tool runs and stops the run with an exception after 10 by default, because a loop has no natural end.

🔐 If you sign off on what an agent can touch, this line is for you: "That's also the security model. An agent can only do what we gave it a tool for."

Save this for the next time an agent does something you didn't expect. Hidran's video (10:48) and the code are in the first comment 👇

28/10/2026

Already on v4? 🔁

If you're still on v3, moving is a task for your coding agent, not your weekend.

The honest picture first: it's a real migration. The Workflow is the foundation of the framework and v4 reworked it, so it can touch your code, especially around tool approval, interruptions and streaming. But the mechanical part is exactly the kind of work a coding agent does well, as long as you give it the right instructions.

Those instructions ship with the package. Bump the dependency:

"neuron-core/neuron-ai": "^4.0"

Then give your coding agent this prompt, as is:

"I updated the `neuron-core/neuron-ai` dependency from version 3.x to 4.x. Please look at the upgrade guide at `vendor/neuron-core/neuron-ai/upgrade` and update my application code if necessary."

It reads the upgrade directory and does the mechanical work. You review the result, run your tests, merge.

If someone above you asks whether it's worth the risk: it's a migration your team reviews, not one they hand-write.

Full upgrade guide: https://docs.neuron-ai.dev/overview/upgrade

28/10/2026

Building an agent in Drupal often means gluing modules together, each one configured on its own settings screen. 🧩

Antonio De Marco of Nuvole names the cost in his new article. AI Agents, ECA and the Tool API each get you part of the way, but every piece "lives in its own module, configured on its own screen, in its own way". So iterating on the agent, and evaluating it, is slow.

His answer is ai_neuron, a Drupal 11 module built on Neuron v4. The design choice behind it is the part we want to point out.

Agents, tools and workflows are written in PHP as Drupal plugins. Each plugin is a factory: it reaches into Drupal (services, permissions, configuration) and builds a native Neuron object, with no translation layer in between. Providers are the one thing mapped one to one: the site's keys, default models and caching stay as they are.

Then there's what you don't write:
💬 every message saved as a neuron_message entity, per thread, with its token usage
⏸️ durable runs that suspend in one request and resume in another, for a human approval or a queue-driven agent
📋 every run tagged per agent and logged to the ai_neuron channel

When you need more, getNeuron() is the escape hatch: drop in a hand-written Neuron agent, or a ready-made one from NeuronHub.

In Antonio's words: "That's the original promise kept: iterate on the agent, while the storage, persistence, logging and provider connection around it stay fixed."

🔐 If you decide what runs next to your Drupal sites: no second stack, a history of every conversation with its token usage, runs that can be resumed, and logs. The module is in active development, and the European Commission is among its supporting organizations.

To try it, the ai_neuron_example submodule ships a Ghostwriter agent you talk to from the terminal, with ddev drush ghost.

Read Antonio's article, the link is in the first comment 👇

Indirizzo

Via Gabriele Jannelli 424
Naples
80131

Sito Web

https://www.neuron-ai.dev/

Notifiche

Lascia la tua email e sarai tra i primi a sapere quando Neuron AI - PHP Agentic Framework pubblica novità e promozioni. Il tuo indirizzo email non verrà utilizzato per nessun altro scopo e potrai annullare l'iscrizione in qualsiasi momento.