What's New in Laravel — May 2026: Autoscaling Queues, AI Agents Without Python & Laravel Moat

The April roundup ended with a tease: May was already shipping queue improvements, and we'd cover them properly once the month was done. It turned out to be a bigger month than expected — not because of one headline feature, but because a story that had been building since Laravel 13 finally connected end to end.

The framework spent May hardening queue workers: inspection methods, lifecycle events, timeout controls, a dedicated Cloud queue connection. Then, on May 26, Laravel Cloud shipped Managed Queues — autoscaling workers built directly on those new primitives. The framework exposed the hooks; the platform built the product. That's the shape of mature ecosystem work, and it's worth understanding in detail.

Here's everything that moved in May 2026 across laravel/framework, laravel/ai, and the wider Laravel ecosystem.

In This Article

Queue Workers Grew Up and Cloud Made Them Autoscale

This is the story of the month. Across six framework releases — v13.8.0 (May 5) through v13.12.0 (May 26) — Laravel methodically built out the queue worker control surface.

Why it matters: For years, running Laravel queues at scale meant operating blind. You could see jobs go in and results come out, but the worker layer in between was a black box. May changed that.

What landed, version by version:

• Queue-wide inspection methods (v13.8.0) — allReservedJobs(), allDelayedJobs(), and allPendingJobs() retrieve jobs across every queue in a single call. Before this, inspecting the full queue state meant iterating connections manually.
• Worker lifecycle events — WorkerPausing and WorkerResuming (v13.8.0) dispatch when a worker receives SIGUSR2 or SIGCONT. WorkerIdle (v13.10.0) fires when a worker has nothing to do. Combined, these give you full visibility into worker state transitions.
• PreparesForDispatch interface (v13.9.0) — a clean hook for jobs to prepare themselves before dispatch.
• Worker timeout exit code override (v13.9.0) — control the exit code a worker returns on timeout, which matters for process supervisors and orchestrators deciding how to react.
• Dedicated Cloud Queue (v13.11.0) — a first-class queue connection designed for Laravel Cloud.
• Opt out of worker restart on lost connection (v13.12.0) — finer control over how workers behave when a database or Redis connection drops.

In practice, what changes for your team:

• Monday-morning queue audits stop being painful. Before May, checking total queue state meant SSHing in and iterating connections by hand. After May, a single allReservedJobs() call returns the full picture — easy to wire into a Slack notifier or a small dashboard widget.
• Zero-downtime deploys for queue workers become straightforward. Listen for WorkerIdle, swap binaries when no job is mid-flight, resume. No more guessing at sleep timings or losing in-flight work to deploy timing.
• Debugging runaway workers gets faster. Subscribe to WorkerPausing, WorkerResuming, and WorkerIdle, and you get a full lifecycle timeline instead of inferring state from job throughput graphs.
• Process supervisors can react smarter. With overrideable worker timeout exit codes, supervisord or systemd can now distinguish "timeout, restart and move on" from "fatal error, page someone" without parsing logs.

Concretely, wiring the worker lifecycle into your own tooling is a few lines. Each event exposes connectionName, queue, and workerOptions as public properties:

1use Illuminate\Queue\Events\WorkerIdle;
2use Illuminate\Queue\Events\WorkerPausing;
3use Illuminate\Queue\Events\WorkerResuming;
4use Illuminate\Support\Facades\Event;
5
6// Build a deploy-safe timeline of worker states.
7Event::listen(WorkerPausing::class, fn ($e) => DeployTimeline::pausing($e->connectionName));
8Event::listen(WorkerIdle::class,    fn ($e) => DeployTimeline::idle($e->connectionName, $e->queue)); // safe to swap binaries
9Event::listen(WorkerResuming::class, fn ($e) => DeployTimeline::resuming($e->connectionName));

And automate scaling is precisely what happened next. On May 26, Laravel Cloud announced Managed Queues — autoscaling queue workers that scale up on queue pressure, scale to zero when idle, and surface failed jobs in a built-in dashboard.

This is the payoff. The framework spent the month exposing worker state through events and inspection methods. Laravel Cloud consumed those primitives to build a product that watches queue pressure and adjusts worker count automatically. You stop paying for idle workers, and you stop manually guessing how many workers a workload needs.

We run a queue-heavy voice-AI platform — thousands of concurrent calls, Laravel orchestrating the work while compute-heavy processing runs in separate services. Fixed worker pools are a constant tuning headache there: provision for peak and you waste money off-peak; provision for average and you fall behind during spikes. Autoscaling on actual queue pressure is the thing we've been hand-rolling with custom metrics and supervisor scripts. Having it as a platform feature, built on framework-native worker events, removes an entire category of operational work.

Laravel AI Goes Full Agent: No Python Required

The AI SDK crossed from v0.6.6 into v0.7.1 over the month, and the messaging around it sharpened considerably.

Why it matters: Laravel is now explicitly positioning laravel/ai as the PHP-native alternative to building agents in Python — and backing it with content showing how.

On the package side, v0.7.0 was a hardening release:

• PHPStan added, then bumped to level 1 — static analysis across the codebase, a real signal of production intent.
• OpenAI strict mode opt-in via a Strict attribute — you control when strict structured output is enforced rather than it being all-or-nothing.
• Input validation across generation entry points — blank inputs, empty reranking document lists, and blank embedding inputs are now rejected rather than silently producing garbage.
• Conversation store improvements — retrieve conversation lists from the store, respect the configured database connection, rehydrate attachments when loading history.

Then v0.7.1 moved the provider story forward:

• gemini-3.5-flash set as Gemini's default smart text model, with deprecated Gemini models updated to successors.
• Bedrock cache usage — AWS Bedrock gateway now reports cache usage, important for cost tracking.
• Failover list improvements — model attributes and explicit models now apply consistently across all providers in a failover chain.

In practice, what changes for your team:

• Strict mode opt-in is the right default. Use it on outputs that must match a database schema exactly (billing line items, addresses, structured records). Skip it on freeform reasoning where strict mode silently fails on minor format drift.
• Input validation kills a real category of bugs. A blank input passed through used to silently bill you for an LLM call that returned nothing useful. Now it fails fast at the boundary — cheaper, and easier to find in logs.
• Failover chains stop being silent quality regressions. Before, if Anthropic had a regional outage and your chain fell back to GPT-5.4, the model attribute didn't always propagate. Now the failover honors your model spec end-to-end — outage resilience without quietly switching to a different tier.
• Bedrock cache visibility unlocks a finance conversation. Cost reporting can now attribute savings to caching, which matters if your finance team wants line-item proof of AI cost optimization beyond "trust me, it's cheaper."

A structured-output agent looks like this in practice — with strict mode (opt-in via the new attribute in v0.7.0) keeping the model from drifting on the schema:

1use Illuminate\Contracts\JsonSchema\JsonSchema;
2use Laravel\Ai\Contracts\Agent;
3use Laravel\Ai\Contracts\HasStructuredOutput;
4use Laravel\Ai\Promptable;
5
6class InvoiceLineItem implements Agent, HasStructuredOutput
7{
8    use Promptable;
9
10    public function schema(JsonSchema $schema): array
11    {
12        return [
13            'description'  => $schema->string()->required(),
14            'amount_cents' => $schema->integer()->required(),
15            'currency'     => $schema->string()->required(), // ISO 4217
16        ];
17    }
18}

Alongside the package work, the official blog ran a clear campaign: "Building AI Agents with Laravel: No Python Required" (May 15), "Laravel PAO: Cleaner Output for AI Agents" (May 14), and a document-search-agent tutorial (May 8). The pitch is direct — agents, tools, memory, streaming, and multi-agent workflows, all in PHP, with no need to stand up a Python service alongside your Laravel app.

Laravel Moat: First-Party Security Review

On May 25, Laravel introduced Moat — a security review for your GitHub account.

Why it matters: Most Laravel security tooling has historically lived in the community (Enlightn, various static analyzers). Moat is first-party, which means it's likely to stay current with framework conventions and ship as a default consideration rather than an afterthought.

Moat reviews your repositories for security issues at the GitHub-account level. It pairs naturally with the broader security push Laravel News ran in May, including a widely-shared "12 Security Practices Every Laravel Developer Must Follow" piece. The direction is clear: security review as a routine, tooled step rather than an annual scramble before an audit.

In practice, where this helps: when you take on a new client engagement that includes their existing Laravel repos, Moat lets you run a security audit across every repo in their GitHub org in one pass — before you've even cloned anything locally. Same for an internal team consolidating multiple legacy repos: one scan, ranked findings, a starting list for the quarterly security backlog. Routine instead of reactive.

Laravel Cloud Momentum

Beyond Managed Queues, May made it obvious that Laravel Cloud is the company's center of gravity:

• Managed Queues (autoscaling, covered above)
• Vapor to Cloud migration guidance — a May 21 Q&A addressed the most common questions from teams moving off Laravel Vapor onto Cloud, signaling Cloud as the successor platform.
• Customer stories — including Webkul's Bagisto, an open-source ecommerce platform serving 200,000+ users, built entirely on Laravel.

In practice, what we'd do this quarter on a Vapor-hosted app: budget a discovery week to map every piece of Vapor-specific behavior in use (cold-start patterns, queue config, scheduled tasks, file storage). Stand up a parallel Cloud environment with the same Laravel app and run integration tests in shadow mode. By the time the migration becomes urgent — and on a trajectory like this, it will — the answer is already a known quantity, not a six-month panic project.

Developer Experience Wins

The quieter quality-of-life improvements that shipped across May's releases:

• schedule:list filters (v13.8.0) — once your scheduled task list crosses 50 jobs, filtering down to "show me only the nightly exports that have been failing" is the difference between five minutes and twenty in an incident.
• New test assertions — assertSessionMissingInput(), assertPushedOnce(), assertJsonPathsCanonicalizing(). The assertPushedOnce() one is the quiet hero: catches the bug where a refactor silently turned two dispatches into one (or one into two), which previously slipped past loose assertPushed() checks.
• SortDirection enum support in the query builder (v13.8.0) — typo-safe ordering with the native PHP 8.6 enum. SortDirection::Descending instead of stringly-typed 'desc'.
• Custom onDelete() / onUpdate() foreign key actions — define cascade or restrict directly in migrations instead of dropping to raw SQL. Cleaner migrations, more reviewable in PRs.
• SQLite URI connections (v13.12.0) — useful when testing a multi-tenant feature where each tenant gets a separate SQLite DB; point at temp files via the file: prefix instead of fighting Eloquent's connection config.
• Str::studly() and Str::pascal() normalize parameter (v13.12.0) — handles unicode quirks (like the Turkish dotted/dotless i) without manual pre-processing.
• Generic return types on Builder paginate methods — better static analysis and IDE autocompletion; fewer "object is unknown" errors in PHPStan.
• MigrationStarted / MigrationEnded events now carry the migration name — custom migration tooling (Slack notifications for prod migrations, audit logs) now gets the name directly instead of parsing log lines.

The SortDirection shift looks like this in practice:

1use SortDirection;
2
3// Before — stringly-typed, easy to typo, no IDE help
4$users = User::orderBy('created_at', 'desc')->get();
5
6// After (v13.8.0) — enum-safe, IDE-completed
7$users = User::orderBy('created_at', SortDirection::Descending)->get();

None are headline features, but together they're the steady accretion of polish that keeps Laravel pleasant to work in day to day.

What This Means for Teams Shipping Laravel

Step back and three directions are visible from May:

The queue story is now end-to-end. From debounceable jobs and Redis Cluster in April to worker lifecycle events, inspection methods, and autoscaling Managed Queues in May, Laravel has built a complete, observable, automatable queue stack. If you run background-heavy workloads — and most production apps do — this is the area that improved most this year. It's worth auditing your current queue setup against what's now available natively.

AI is becoming core, not experimental. The SDK is hardening (PHPStan level 1, validation, strict mode), the provider list is growing (Gemini 3.5 Flash, Bedrock caching), and the official messaging treats PHP-native agents as a real architecture choice. For teams choosing a stack for AI features, staying on Laravel is now a more defensible choice than it was even three months ago.

Cloud is the platform bet. Managed Queues, Vapor migration guidance, and the dedicated Cloud queue connection in the framework all point the same way. If you're making infrastructure decisions for the next few years, factor that trajectory in.

The pace isn't slowing. Laravel has already teased a "What's New in Laravel Cloud" event for June 10, the AI SDK keeps inching toward the 1.0 it clearly has in its sights, and the framework's queue worker primitives still have more to give. We'll cover it all in the next roundup.

Related reading:

• What's New in Laravel — April 2026: Debounceable Jobs, Native AI Gateways & Passkeys
• Legacy PHP to Modern Stack: A Practical Migration Playbook
• Laravel API Development: Best Practices for 2026
• What's New in Laravel 13: AI SDK, Vector Search & Beautiful UI

About the Author

Ritesh Patel

Co-Founder & CTO, Treesha Infotech

Co-founded Treesha Infotech and leads all technology decisions across the company. Full-stack architect with deep expertise in Laravel, Next.js, AI integrations, cloud infrastructure, and SaaS platform development. Ritesh drives engineering standards, code quality, and product innovation across every project the team delivers.

LinkedInUpwork