Over the last two years, an entire industry has emerged around AI development within the PHP ecosystem.
Where integrating an LLM once looked like a few lines of code calling the OpenAI API, developers today are building full-fledged agent systems: with memory, tools, workflows, observability, and even teams of specialized agents.
Usually, when people talk about AI development, they talk about Python first. And for good reason. The ecosystem is packed with interesting projects: LangChain, LangGraph, CrewAI, AutoGen - the bulk of the excitement has lived there for quite some time.
But in parallel, an interesting story has been unfolding in PHP as well.
And that makes me genuinely happy.
Just a couple of years ago, PHP developers had to assemble everything manually on top of provider SDKs. Today, however, there is already a complete ecosystem of tools at different abstraction levels - from model clients all the way to platforms for managing multi-agent systems.
Let's take a look at what this landscape looks like today.
From a Single Model Request to a Full-Fledged Agent
Historically, everything started the same way.
Almost every AI project looked something like this:
$response = $client->chat()->create([
'model' => 'gpt-5',
'messages' => [
[
'role' => 'user',
'content' => 'Analyze the customer request'
]
]
]);
For a prototype, this is more than enough.
But as soon as the system starts delivering real business value, additional requirements emerge:
- Support for multiple models
- Ability to switch providers quickly
- Structured output
- External tool calling
- Memory management
- Context management
- Request tracing
- Multi-step processing orchestration
At some point, you realize that the code surrounding the LLM is taking up more space than the business logic itself.
That is exactly why specialized AI libraries began to appear in PHP.
If we simplify things a bit, the modern ecosystem can be divided into three layers:
- AI SDKs
- Agent Frameworks
- Agent Platforms
Each successive layer takes responsibility for more infrastructure work.
The modern AI development ecosystem in PHP can roughly be divided into three levels. SDKs solve model interaction problems, frameworks help build agents, and platforms manage the entire agent infrastructure.
Level One: AI SDKs
This is the foundation.
AI SDKs solve one problem: making it convenient to interact with models.
They do not attempt to manage agents or orchestrate workflows. Their responsibility ends with sending a request and receiving a response.
OpenAI PHP
Repository: https://github.com/openai-php/client
Status: Active
The official OpenAI client for PHP.
In essence, it is the most direct way to work with the OpenAI platform without additional abstractions - a low-level SDK.
It provides access to:
- Responses API
- Chat Completions
- Embeddings
- Audio API
- Image Generation
- Fine-Tuning
- Files API
A typical example is as straightforward as it gets:
$response = $client->responses()->create([
'model' => 'gpt-5',
'input' => 'Create a short summary of the customer request'
]);
echo $response->outputText;
The advantage of this approach is obvious: complete control.
The downside is equally obvious.
As soon as you need to support multiple models or providers, you have to build all necessary abstractions yourself.
Prism
Repository: https://github.com/prism-php/prism
Status: Active
While OpenAI PHP focuses on accessing a single platform, Prism was created with a different goal in mind: providing a unified interface for multiple providers.
This is a multi-provider AI SDK.
The idea is simple: business logic should not depend on a specific model.
Today you use GPT, tomorrow Claude, next month Gemini - the application should not notice the difference.
Example:
Prism::text()
->using('openai', 'gpt-5')
->withPrompt('Hello')
->generate();
Switching models is literally a one-line change:
Prism::text()
->using('anthropic', 'claude')
->withPrompt('Hello')
->generate();
Prism becomes especially useful thanks to additional capabilities.
Structured Output
Instead of parsing free-form text, you can define the expected output structure in advance.
For example:
class SentimentResult
{
public string $sentiment;
public int $score;
}
The model will then return data in a strictly defined format.
For production systems, this is far more reliable than applying regular expressions to generated text.
Tools
Prism supports tool calling.
In other words, the model can decide for itself when it needs to query a CRM, database, or external API.
This is effectively where the transition from "chatbots" to "agents" begins.
Embeddings
Virtually every modern RAG project ends up using embeddings sooner or later.
Prism allows you to generate them through a unified interface regardless of the chosen provider.
Laravel AI
Repository: https://github.com/laravel/ai
Status: Active
Perhaps the most interesting player to emerge in recent months.
Laravel AI is trying to do for artificial intelligence what Laravel did for databases, queues, and infrastructure.
The main idea here is not model support.
The main idea is making AI a natural part of a Laravel application.
The code feels immediately familiar:
$response = AI::chat()
->model('gpt-5')
->prompt('Create a short summary of the customer request')
->send();
But the real value goes deeper.
AI integrates automatically with:
- Queues
- Events
- The service container
- Logging
- Configuration
- The scheduler
As a result, an LLM starts to feel like just another infrastructure dependency - roughly on the same level as Redis or PostgreSQL.
Level Two: Agent Frameworks
And this is where things start getting really interesting.
Because a model request is not yet an agent.
Imagine a customer support system.
A message arrives:
I've already contacted you three times about my refund. Nobody is responding.
What happens next?
In practice, the system usually needs to:
- Determine sentiment
- Assess urgency
- Retrieve customer information
- Check support history
- Prepare a response
- Save the result
- Log all actions
You can write dozens of services manually.
Or you can use an agent framework.
In real systems, agents rarely work alone. Usually, a coordinator emerges that distributes tasks among specialized agents and then combines their results into a single response.
Neuron AI
Repository: https://github.com/neuron-core/neuron-ai
Status: Active
Today, this is one of the most mature agent frameworks in PHP.
The approach is fundamentally different.
Instead of describing a request, the developer describes an agent:
$agent = Agent::make()
->name('SupportAgent')
->instructions('You are a customer support specialist');
The agent then receives a task:
$result = $agent->run(
'Analyze the customer email'
);
At first glance, it looks simple.
But under the hood, an entire infrastructure appears:
- Memory
- Workflows
- Tools
- RAG
- Multi-agent systems
- Observability
- and much more
Philosophically, the project is remarkably similar to LangGraph from the Python world.
Why Memory Became Critical
A traditional LLM operates like this:
Request → Response
An agent works differently:
Request
↓
Memory
↓
Tools
↓
LLM
↓
Result
Memory allows the agent to consider previous actions and accumulated context.
Without it, long-running business processes are impossible.
Multi-Agent Systems
Another trend of recent months is the move away from universal agents.
More and more teams are adopting specialized roles:
Coordinator
|
+-- CRM Agent
|
+-- Sentiment Agent
|
+-- Reply Agent
The approach closely resembles the structure of a real team.
Each agent is responsible for its own domain.
LarAgent
Repository: https://github.com/maestroerror/laragent
Status: Active
If Neuron AI aims to be a universal agent framework, LarAgent is focused primarily on Laravel developers.
You can immediately feel Laravel's familiar philosophy:
class SupportAgent extends Agent
{
protected string $instructions =
'You are a support specialist';
}
Minimal infrastructure code and maximum Laravel integration.
For many teams, this may be the fastest way to start working with agents.
PapiAI
Repository: https://github.com/papi-ai/papi-core
Status: Active
A relatively young project that emphasizes strong typing and provider independence.
Architecturally, PapiAI feels like an attempt to bring modern PHP development practices into the AI world.
Its primary focus areas include:
- Types
- Contracts
- Middleware
- Tools
- Structured responses
It's fascinating to watch AI tooling gradually inherit the architectural principles of traditional PHP frameworks.
Atlas
Repository: https://github.com/atlas-php/atlas
Status: Active
Another representative of the new generation of agent solutions.
The project is being built with modern requirements in mind:
- Voice interfaces
- Multimodality
- Agents
- Tools
- Tracing
- Monitoring
Atlas cannot yet be called a mature market player, but it clearly demonstrates the direction in which the ecosystem is moving.
Level Three: Agent Platforms
At a certain scale, a new problem emerges.
The challenge is no longer building an agent.
The challenge becomes managing dozens of agents.
Questions begin to arise:
- Who handles task routing?
- How do we track response quality?
- How do we test changes?
- How do we manage memory?
- How do we understand the root causes of failures?
This is where Agent Platforms come in.
PromptlyAgent
Repository: https://github.com/promptlyagentai/promptlyagent
Status: Active
This project focuses on building complex agent ecosystems.
Its primary emphasis is on:
- Visual orchestration
- Multi-agent workflows
- Tool integration
- Agent management
In essence, it represents a shift from programming individual components to managing an entire AI infrastructure.
Vizra ADK
Repository: https://github.com/vizra-ai/vizra-adk
Status: Active
Another interesting project from the Laravel ecosystem.
It covers nearly the entire agent lifecycle:
- Development
- Testing
- Memory
- Workflows
- Observability
- Sub-agent interaction
Looking at industry trends, solutions like this are gradually becoming the next level of abstraction.
Where the Market Is Heading
Interestingly, PHP is now following almost exactly the same path that Python followed a few years ago.
The evolution looks like this:
Virtually every AI project goes through a similar evolution. It starts with a simple model call, then adds tools and structured output, and eventually grows into a network of interacting agents.
Everyone starts with a simple model request.
Prism::text()
->using('anthropic', 'claude')
->withPrompt('Привет')
->generate();
Then come tools.
Then memory.
Then workflows.
After that, specialized agents become inevitable.
And eventually comes the realization that all of this infrastructure needs to be managed somehow.
That is why orchestration and agent management platforms are currently evolving faster than SDKs themselves.
Conclusion
A few years ago, conversations about AI in PHP typically ended with discussions about which HTTP client to use for calling OpenAI.
Today, the situation looks completely different.
The ecosystem already contains solutions for virtually every level of complexity:
- OpenAI PHP and Prism for model interaction
- Laravel AI for deep AI integration within Laravel applications
- Neuron AI, LarAgent, PapiAI, and Atlas for building agents
- PromptlyAgent and Vizra ADK for managing complex agent systems
And it seems this is only the beginning.
If developers once designed APIs, services, and queues, in the coming years they will increasingly be designing agents, their memory, their tools, and the ways they interact with one another.
It is already becoming clear that a single model call is gradually turning into the new function, while an agent is becoming the new service.
That is why understanding the capabilities of the PHP AI ecosystem is becoming an essential skill for any backend engineer planning to build the next generation of AI products.
Are you ready for these changes?
If you're interested in AI in PHP, you can dive deeper into the topic through my free book: "AI for PHP Developers: Intuitively and Practically."
Top comments (0)