Neuron AI - PHP Agentic Framework

Neuron AI - PHP Agentic Framework Neuron AI is the First Agentic Framework of the PHP Ecosystem

His agents never call each other. The workflow decides what runs next. 🧩Jules Langlois runs a small holding and wanted h...
19/10/2026

His agents never call each other. The workflow decides what runs next. 🧩

Jules Langlois runs a small holding and wanted his own Jarvis: a morning briefing, operations in check, a warning when something stops working. When he proposed the example to the Neuron repo, we asked him if he wanted to write about it. He did.

His design call, in his words:
"Instead of one giant agent with a giant prompt, I tried a mesh: small, role-specific agents coordinated by a Neuron AI workflow."

Three agents, one role each:
🔎 Research: daily highlights, with sources
⚙️ Operations: status and risks, read against the research
📝 Briefing: composes the final briefing

The part we like most is who owns the sequence. Not the agents. The workflow routes typed events, BriefingStarted → ResearchCompleted → OperationsCompleted → BriefingComposed, and each node takes one event and returns the next. You can read the whole process from the type signatures.

He keeps one rule throughout: "transport and scheduling outside workflow nodes; business sequencing and state inside the graph."
The signal bus, the shared knowledge store, the heartbeat store and the agent factory are adapters from his application, passed in as resources. Even the watchdog follows the rule: a separate one-step workflow, started by an external scheduler.

For whoever signs off on a system like this, two things matter. Agent calls are memoized, so after a failure the work already done (and already paid for in model calls) doesn't run again. And with transport kept out of the nodes, the flow stays readable for the next person who opens it.

He's just as clear about the limits: "memoization cannot make an external side effect exactly-once." And: "this prototype was built with AI coding assistance, and it is meant as a starting point, not production code."

He tested it on Neuron 4.1 with simulated agents and in-memory adapters: the briefing runs end to end, a failed agent resumes without repeating work, and the watchdog flagged the stale and the missing agent, ignored the healthy one, and didn't duplicate alerts on the second pass.

Thanks for sharing it, Jules. His article and the code are in the first comment 👇
Would you split the roles differently? Tell us below.

Valerio Barbera, Neuron's CTO, moved an agent into a queue worker. It read files from a repository and streamed its outp...
19/10/2026

Valerio Barbera, Neuron's CTO, moved an agent into a queue worker. It read files from a repository and streamed its output to the browser through Pusher. Then one tool result, the content of a single file, went over 10 KB. 📡

Pusher rejected the message. No exception in the agent, no error in the console. The chat in the browser just waited.

That's question 3 from last week's carousel, "how does the stream reach the UI?", answered the hard way. Real-time servers have three limits an agent hits fast:

📦 Size: Pusher takes 10 KB per event, Laravel Reverb has the same default, Soketi 100 KB
⏱️ Frequency: managed Mercure allows 1 to 20 publishes per second, depending on the plan
🔀 Order: not every server delivers messages in the order they were sent, and a reconnect can bring duplicates

The Neuron UI Streaming Protocol wraps every event in an envelope (streamId, sequence, type, data). Events too big for the server are split into fragments before it can reject them. In the browser, -core/streaming reorders them, rebuilds the fragments, drops duplicates, and calls onGap when an event is really missing. Every run ends with one of three terminal events: completed, interrupted or failed, so the UI knows when to stop waiting.

A bug that leaves no log is the expensive kind: there's nothing to search for, you can only reproduce it. Here the size limit stops being a silent failure.

You don't wire it by hand: ask your coding agent to use the /neuron-streaming skill.

"The chat history stays the source of truth, and the live stream is a layer of convenience on top of it."

Valerio's full article and the docs are in the first comment.

Your coding agent can write the memory, the approval step and the stream to the UI. It can't decide where they should li...
16/10/2026

Your coding agent can write the memory, the approval step and the stream to the UI. It can't decide where they should live. 🧭

A couple of hours with Neuron v4: the docs make sense, the demo runs, the generated code works. And three questions are still fuzzy:

🧠 Where does the memory live, and what changes when you swap the storage?
✋ When a tool needs a human approval, where does the run wait, and who resumes it?
📡 When the agent runs in a background worker, how does the stream reach the browser?

None of them is a syntax problem. They're architecture, and with a coding agent writing the code, architecture is your part of the job: it's what goes into the specs, and it's how you judge what the agent built.

Settling them before the first spec costs a conversation. Settling them after the agent has built on top of them costs a refactor.

That's what the Kickstart is for: a live session with the people who built Neuron, with your PHP project on the table. If you have a real project, the link is in the first comment.

Building an AI agent is paid in tokens long before it has a single user. 🧪Regolo.ai, one of our partners, is opening app...
15/10/2026

Building an AI agent is paid in tokens long before it has a single user. 🧪

Regolo.ai, one of our partners, is opening applications for its Builder Program: 60 days of unlimited tokens on 100+ open-source models (Mistral, Llama, Qwen, Gemma), with EU-only data residency and no training on your data.

For two months, the token cost of building and testing your agent goes to zero.

It's a selection: you apply, they reply within 48 hours, cohorts are limited. Made for early-stage startups shipping AI products, especially with EU customers or in regulated sectors.

Link in the first comment 👇

14/10/2026

Your coding agent can write most of your next PHP application. The question is whether you can guide it.

Without the architecture in your head, you can't give the agent good specs, and you can't tell a structure your team can build on from something that just works but is a mess.

One session on the architecture now beats refactoring an agent-written codebase later.

Neuron Kickstart: a free live session with the people who built Neuron, on your real project. Architecture, memory, streaming, tools and workflows, with live coding and Q&A.

Got a real project? Book your intro call 👉 https://neuron-ai.dev/kickstart

13/10/2026

"Is this a hobby project? Who runs it in production?"

Fair questions before you standardize on a framework. Here's the honest answer, with exactly what each company does with Neuron. 🔍

🔹 Inspector: Neuron was born inside Inspector and runs in production in its AI Bug Fix agent.
🔹 Spryker: their AI Foundation module is built on Neuron, as their own docs state.
🔹 Capri.com: Alessandro Astarita presented their agentic search case study, built on Neuron, in Nola.
🔹 Knotic (by Artiforge): Turn your Neuron PHP workflows into interactive graphs, directly inside Knotic. Explore nodes, follow event connections, and jump to the source code behind each step.

Behind the framework: Inspector, an observability product in profit since 2019, funds the development. Neuron is MIT, so every version you adopt stays yours. Even in the worst case: no forced rewrite, no lock-in.

Welcome to the PHP Agentic Era. Your next application will be agentic. Build it in PHP.

If your PHP application already runs Mercure, your AI agent can now stream through it. 📡Mercure is an open protocol for ...
13/10/2026

If your PHP application already runs Mercure, your AI agent can now stream through it. 📡

Mercure is an open protocol for real-time updates over Server-Sent Events, created by Les-Tilleuls.coop, the same team behind API Platform and FrankenPHP. It's Symfony's official real-time component, it comes bundled with FrankenPHP, and it's MIT and self-hostable.

Neuron now has a first-party channel to stream agent output through a Mercure hub.

Agents are hard on real-time servers. A tool result with the content of a file easily goes over 10 KB. Servers limit message size and how often you can publish, and not all of them guarantee the order of delivery.

Neuron splits messages that are too big and paces how often it publishes, so the stream always respects the server's limits. In the browser, -core/streaming puts the pieces back together in the right order, and your UI components get a steady stream. The same protocol works with Pusher, Reverb, Soketi, Redis or your own transport.

For the team: if Mercure is already in your stack, there's no new service to pay for, run or secure. For the developer: no fragmentation and reordering code to write and maintain by hand.

You don't wire it by hand, your coding agent does: install -core/streaming and ask it to use the /neuron-streaming skill.

Docs, Valerio's article and Mercure are in the first comment 👇

12/10/2026

The hardest part of an agentic workflow isn't writing it.
It's reading one someone else wrote. Or the one your coding agent wrote last night. 🧩

You open a node, find the event it returns, search for the node that accepts that event, open another file. Then again. On a real project it's file after file before the whole flow fits in your head and you can safely change a single step.

In Neuron, everything is a workflow: nodes connected by events, and every node declares what it accepts and what it returns. We designed it that way on purpose. One side effect I really like: the architecture is explicit enough that a third-party tool can read it and draw it.

That's what Riccardo Tartaglia and Lorenzo Ravano, the founders of Knotic, built. It's called Neuron Workflows, and it's built into Knotic, their VS Code based IDE for teams that build with AI (it runs inside Knotic, it's not a plugin for plain VS Code):

🔍 it scans your project and finds your Neuron workflows
🕸️ it draws each one as a graph, nodes linked by the events between them
🏷️ every node shows its signature, like QualityCheckNode: ShipmentReceivedEvent → GoodsInspectedEvent
↪️ click a node and you land on its code

In the video: WarehouseManagementWorkflow and ContentModerationWorkflow. It works with Neuron v4.

What it saves you is the tracing. You read the flow first, then open only the files you actually need to touch. Whoever inherits a workflow starts from the map instead of rebuilding it in their head, and reviewing what a coding agent produced becomes a check against a picture. For whoever leads the team, it means the logic of an agentic feature no longer lives only in the head of the person who wrote it.

Thank you Riccardo Tartaglia and Lorenzo Ravano: this is how an ecosystem grows, people building real tools on top of it.

The extension is linked in the first comment.

Your next application will be agentic. Good to know you'll be able to see how it's built. 🤝

Before a CTO lets a framework into the stack, there's a quieter question than the feature list: is this project run with...
09/10/2026

Before a CTO lets a framework into the stack, there's a quieter question than the feature list: is this project run with care? 🔍

PlumbPHP, an automated scoring service for PHP packages, checks exactly that. Neuron scores 100/100.

What it actually measures:

🔐 Security practices (55% of the score): all third-party GitHub Actions pinned to a commit, automated dependency updates, a published security policy, no open advisory affecting the package
🛠️ Maintenance (30%): actively developed, with recent commits and releases, and a lean package
🌐 Ecosystem (15%): supports the current PHP version, 8.5

To be precise: it isn't a code audit. It checks how the project is built, released and maintained, the supply-chain hygiene you would otherwise verify by hand before adopting a dependency.

Make your choice with confidence. The full report is in the first comment 👇

Your coding agent writes the code. Holding the architecture in your head is still on you.In the agentic era the bottlene...
09/10/2026

Your coding agent writes the code. Holding the architecture in your head is still on you.

In the agentic era the bottleneck moved. Writing the code is the fast part now. The hard part is having the architecture clear enough to specify what the agent should build, and to judge what it hands back. Ship an agent your team can't reason about and you don't have a product, you have something that happens to work until it doesn't.

With Neuron v4 that comes down to answering three questions with confidence:
→ where the agent's memory actually lives
→ how tool approval really works
→ how the stream reaches the UI

So we built a way to put those answers in your team's head, fast.

Kickstart: a live session with the people who built Neuron, walked through your real project, component by component. Your team leaves able to guide the coding agent instead of following it, and the architecture they learn travels with them, across projects and frameworks. You train once.

It's for teams and delivery companies with a real project on the table. Not a webinar for the curious, a working session for people about to build.

Guide your coding agent. Don't follow it.

Book your intro call → neuron-ai.dev/kickstart

Indirizzo

Via Gabriele Jannelli 424
Naples
80131

Sito Web

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.

Scelte rapide

Condividi

Categoria