The AI Agent Ecosystem in PHP - From Simple OpenAI Calls to Multi-Agent Platforms

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."

推荐订阅源

DEV Community