TL;DR
action_scheduler_queue_runner_concurrent_batchesis a filter, not a constant — return an integer. The default is 1, in every Action Scheduler version up to and including 4.0.- It caps how many queue runs may hold a claim at the same time. It does not fire extra loopbacks per cron tick, and it does not multiply per-run throughput — one run already keeps claiming batches of 25 until the queue is empty or ~30 seconds pass.
- Raising it lets the async loopback runner work alongside the WP-Cron run. Each extra slot is another full WordPress process, so only raise it when you control the PHP-FPM pool and have a real backlog.
/ Definition
What does action_scheduler_queue_runner_concurrent_batches actually do?
It caps the number of queue runs that may be processing actions at once. Before a run claims anything, Action Scheduler compares the number of active claims with this value; if the count has reached the limit, the run does nothing and exits.
A "batch" is not a separate request. Inside one run, ActionScheduler_QueueRunner::run() loops: claim up to batch_size due actions (default 25), process them, release the claim, claim the next batch — until no actions are due, the run's time limit (30 seconds) is about to be exceeded, or 90% of the PHP memory limit is used. So a single run at default settings can process far more than 25 actions; on fast actions it processes hundreds.
The value is read by get_allowed_concurrent_batches(), which has_maximum_concurrent_batches() calls every time a run starts or the async runner decides whether to dispatch another request — see the source on GitHub. It is read live, so a change takes effect on the next run.
/ Filter vs Constant
Is it a filter or a constant?
It is a filter, applied via apply_filters( 'action_scheduler_queue_runner_concurrent_batches', 1 ). There is no PHP constant by that name and defining one in wp-config.php has no effect. Misreading the search query as a constant is the most common mistake on Stack Overflow.
The related action_scheduler_queue_runner_batch_size is also a filter, not a constant. Both must be hooked in PHP — typically from an mu-plugin so the values survive plugin deactivation and theme switches.
/ Tuning
How do I raise the concurrent-batch limit safely?
Start by confirming there is a real backlog. Open WooCommerce → Status → Scheduled Actions (the Action Scheduler admin docs describe the columns) or run wp action-scheduler status, and check the Pending count. If pending is consistently under 100 and the oldest pending action is under five minutes old, the queue is already draining — tuning will burn CPU for no throughput gain.
If pending is in the thousands and growing, first make sure runs start every minute (a real system cron, below). Then raise the limit to 2 or 3. A second slot lets the async runner keep working while the WP-Cron run holds the first claim, instead of exiting immediately. Raising batch_size on its own changes little: a run already loops batch after batch until its time limit.
Each concurrent run occupies one PHP-FPM worker for up to 30 seconds. With PHP-FPM pm.max_children = 10 and a limit of 5, half your worker pool can be tied up draining actions — leaving five workers for page loads. Below 10 workers, leave the default of 1. With 30 or more workers and a persistent backlog, 2–5 is reasonable.
mu-plugins/action-scheduler-tuning.php — for a host that can handle it
// wp-content/mu-plugins/action-scheduler-tuning.php // Raise Action Scheduler throughput on a host with spare PHP workers. add_filter( 'action_scheduler_queue_runner_concurrent_batches', function() { return 3; // default 1; keep 1 on shared hosting } ); add_filter( 'action_scheduler_queue_runner_batch_size', function() { return 50; // actions claimed per batch; default 25 } ); add_filter( 'action_scheduler_queue_runner_time_limit', function() { return 30; // seconds per run (default); stay well under PHP max_execution_time } );
Seeing it run beats reading about it. The live preview boots a throwaway WordPress with Webhook Actions already installed and demo deliveries sitting in the log — no signup, nothing left on your machine afterwards.
/ Companion Filter
What is the relationship with action_scheduler_queue_runner_batch_size?
Batch size is how many actions one claim covers; concurrent batches is how many runs may hold a claim at once. Throughput is not batch_size × concurrent_batches: each run keeps claiming batches until it runs out of due actions, time or memory, so per-run throughput is set mostly by the time limit and how long each action takes. Concurrency adds parallel runs; batch size only changes how often a run goes back to the database for the next claim.
Raise batch_size modestly when actions are very fast and claim queries show up in your database load. Raise concurrent_batches when actions are slow (long-running imports, remote HTTP calls) and one run at a time cannot keep up with the enqueue rate.
The hard ceiling is PHP max_execution_time. Keep action_scheduler_queue_runner_time_limit (30 seconds by default) well under it: a run that stops at its own time limit releases its claim cleanly, but a run killed by PHP leaves its current action in-progress until Action Scheduler marks it failed five minutes later — it is not re-run.
/ Inspection
How do I see the current values on a live site?
Run wp eval 'echo ActionScheduler::runner()->get_allowed_concurrent_batches();' from the site root. That calls the same method the runner uses, so it prints the effective value after all filters — including the default of 1 when nothing is hooked. For batch size, wp eval "echo apply_filters( 'action_scheduler_queue_runner_batch_size', 25 );" works because 25 is the real default.
For the live throughput picture, run wp action-scheduler run --batches=1 and read the action count and elapsed time, then compare that rate with how fast actions are being added. If actions arrive faster than one run can process them in its time limit, the backlog will grow no matter how patiently you wait.
/ Hosting Pitfalls
Which hosting environments break when you raise these?
Shared hosting with low pm.max_children values (Bluehost, GoDaddy, SiteGround starter plans). Every concurrent run is a full WordPress process held for up to 30 seconds; with a higher limit the async runner keeps re-dispatching itself while actions are due, and those self-issued requests compete with real visitors for workers. Symptom: slow pages or 502s while the queue has a backlog, worst while someone is working in wp-admin (which is what starts the async runner). Raising it also widens the window for MySQL deadlocks on the claim query on older Action Scheduler or MySQL versions.
Hosts that block loopback requests (some managed WordPress hosts, Cloudflare with strict firewall rules). The async runner posts to admin-ajax.php?action=as_async_request_queue_runner; when that is blocked, only the WP-Cron run is left. It still respects the concurrent-batches limit — there is no fallback that ignores it — so in practice you are running one queue at a time regardless of the setting.
PHP-FPM with pm = ondemand and aggressive pm.process_idle_timeout. Queue runs arrive in bursts, FPM spawns workers, then kills them — paying the worker startup cost again and again. Use pm = dynamic with a sensible pm.min_spare_servers instead.
On managed WordPress hosting (Kinsta, WP Engine, Pressable), check the host's docs before raising concurrent batches. Many enforce their own queue runner via a system cron and document recommended values — overriding them risks support deflection ("we don't support custom Action Scheduler tuning").
/ WP-Cron Interaction
How does this interact with WP-Cron and loopback requests?
Action Scheduler has two ways to start a run. The first is WP-Cron, via the action_scheduler_run_queue scheduled event every minute; that run happens inside the cron request itself and starts no loopbacks. If WP-Cron does not fire — because no page request triggered it, or because DISABLE_WP_CRON is set without a system cron — this run never starts.
The second is the async runner: at the end of a wp-admin request, Action Scheduler sends one non-blocking request to admin-ajax.php, at most once every 60 seconds. That request runs a queue, sleeps 5 seconds, and dispatches itself again as long as due actions remain and the claim count is under the concurrent-batches limit. This chain is what consumes extra PHP workers on a busy queue — and on a site where nobody uses wp-admin, it never starts.
On a low-traffic site, the realistic first fix is therefore not raising concurrent_batches. It is replacing page-load-triggered WP-Cron with a system cron entry hitting wp-cron.php every minute. See the WP-Cron replacement guide for the exact crontab line.
/ When to Stop
When should you stop tuning and switch to a real queue?
When you are tuning these filters more than once a quarter, the workload has outgrown Action Scheduler. The signal is consistent: pending stays above 5,000 even after tuning, the runner spends most of its time on retries, and you have started adding custom cron entries to run the queue runner more often than every minute.
At that point the next step is offloading dispatch to a real queue (Redis, SQS, RabbitMQ) with a dedicated worker process outside the PHP request cycle — the same architecture covered in Why WordPress Webhooks Silently Fail in Production. The Webhook Actions plugin sits in between: it ships its own persistent queue tables with smart retry routing and a delivery log, and uses Action Scheduler as the runner when available (falling back to WP-Cron). You configure concurrency once, then operate from the admin console.