Platform Updates8 min read

OpenClaw Priority Queues and Multi-Region Runners Arrive in ButterGrow

By Maya Chen

TL;DR

Priority queues and multi region runners are now available to ButterGrow customers. This release brings predictable routing, better fairness, and faster failover for high volume automation. You can assign jobs to urgent, standard, and low classes, set concurrency rules per queue, and balance traffic across regions with health aware runners. OpenClaw powers the control plane so upgrade complexity stays low. The practical outcome is steadier delivery under spikes and lower latency for time sensitive campaigns.

What Shipped

We introduced two capabilities designed for busy growth teams: priority aware queues and multi region runners. Priority queues let you define classes, weights, and concurrency ceilings so critical jobs move first while background work waits. Multi region runners add active active balancing, health signals, and controlled drain timers so work can shift quickly during provider outages or localized incidents.

These features plug into the same AI marketing automation features you already use in ButterGrow. If you are new to the platform, the best path is to review what ButterGrow does in the feature set, then follow the onboarding flow to provision a workspace. Use the link to learn more about AI marketing automation features, and if you are ready to set things up, you can get started in minutes.

Why It Matters For Growth Teams

Automation workloads are not uniform. Transactional messages and consent updates must cut through spikes immediately, while bulk enrichment or ad syncs can wait a few minutes. Without priority control, everyone competes in one flat line and small delays compound. Priority queues make the tradeoffs explicit. You choose how aggressive urgent work should be, how much fairness to grant standard jobs, and where low priority tasks are allowed to idle.

Regional diversity matters for reliability and performance. Many connectors have regional endpoints, cross border transfers can add latency, and cloud providers have uneven incident profiles. Multi region runners keep jobs close to their data and give you redundancy when one geography wobbles. Health aware scheduling avoids hot spots by favoring healthy regions and shedding load when signals degrade. The result is shorter waits for end users and a smoother backlog for operators.

For a primer on overload behavior and why backpressure matters, the Google SRE handbook chapter on handling overload is an excellent reference. It explains the impact of queuing discipline, fairness, and admission control during spikes and failure. Read Handling Overload for background that maps cleanly to modern automation systems.

Priority Queues: How It Works

Priority is implemented through class based scheduling with weights, soft fairness, and optional aging. Each queue can declare up to four classes, though most teams start with three. Jobs enter a class based on tags or policy rules. The scheduler allocates concurrency to classes according to their weights and the current backlog. Aging nudges long waiting jobs upward gradually so standard work does not starve.

Below is a simple configuration example showing three classes and basic fairness. The syntax mirrors what you will see in workspace policy, but the values here are illustrative only.

queues:
  - name: core-campaigns
    priorityPolicy:
      classes:
        - name: urgent
          weight: 5
          maxConcurrency: 200
        - name: standard
          weight: 3
          maxConcurrency: 120
        - name: low
          weight: 1
          maxConcurrency: 40
      fairness:
        agingSeconds: 30
        burstLimit: 100
rateLimits:
  perWorkspace: 2000/min

Step 1Enable Priority In Your Workspace

Open the Operations view, locate Queues, and enable priority policies for the target queue. Start with three classes to keep rules simple. Map transactional events such as password resets and consent updates to the urgent class, map scheduled campaigns to standard, and assign enrichment or sync tasks to low.

Step 2Define Queue Policies

Choose weights based on business SLAs. For example, a team that sends passwordless login links might set the urgent weight higher and give it more concurrency than standard. Use aging to prevent starvation by gradually raising the selection chance for long waiting standard jobs. Keep burst limits conservative at first, then raise them after you validate downstream rate limits.

Step 3Tag Jobs With Priority

Add a simple tag step to critical playbooks so jobs carry the right class into the queue. Where tagging is not obvious, let the scheduler infer class from connector type. Transactional email and consent endpoints default to urgent, while ad syncs and bulk writes default to low. The goal is to classify without forcing authors to micromanage rules.

If you want more step by step guidance, the onboarding flow explains where these toggles live and how to verify changes. See the onboarding flow for screenshots and short walkthroughs that speed up first time setup.

Multi Region Runners: Deployment Patterns

Runner groups can register in multiple regions and publish health signals continuously. The scheduler favors healthy regions and avoids unhealthy ones automatically. You can run active active across two or three geographies, or choose active passive where a cold standby picks up only during incidents.

Regional affinity keeps jobs close to their data. If a segment has a residency tag, the scheduler prefers matching regions for that set. During failover, residency constraints are respected so regulated payloads remain in the correct jurisdiction.

This configuration snippet shows three regions with a simple affinity distribution and a health aware failover policy. Values are examples, not production defaults.

runners:
  regions:
    - id: us-east
      affinity: 0.6
    - id: eu-west
      affinity: 0.3
      residency: eu
    - id: ap-south
      affinity: 0.1
failover:
  policy: active-active
  healthCheck:
    intervalSeconds: 10
    failureThreshold: 3
  drainingSeconds: 20

Step 4Add Regions

Register runner capacity in your preferred clouds and regions. Keep an eye on connector locality and your audience composition so the mix reflects real traffic. If you serve a large European base, add capacity in EU bound regions and give those runners higher affinity for European segments.

Step 5Configure Failover Rules

Set health check intervals and failure thresholds so false positives are rare but recovery time stays short. Measure how long your downstream providers recover from minor outages, then pick timers that drain quickly without thrashing. Cold standby can be acceptable for cost sensitive teams, while active active suits time sensitive campaigns.

Step 6Observe And Tune

Use the Operations view to watch backlog, selection rates, and per region latency. If one geography runs hot, lower its affinity temporarily or add runner capacity. If wait time in the urgent class rises, raise that class weight or increase concurrency for the queue. These are routine changes you can make safely because the scheduler enforces fairness and rate limits.

For background on scheduler prioritization, the Kubernetes Pod Priority and Preemption docs explain how weights and preemption maintain service for critical workloads. The details differ from automation jobs, but the core concepts are useful. Read Pod Priority and Preemption to see a mature approach to fairness.

Operational Safeguards

Priority does not replace guardrails. Backpressure still matters and rate limits must reflect downstream constraints. If a provider signals errors, the scheduler can slow selection or pause a class. Circuit breakers stop repeated failures quickly. Kill switches let operators drain a region or queue safely during incident response.

Global load balancing is part of the picture too. A smart balancer routes traffic to healthy regions, respects proximity, and helps cost control by steering to cheaper paths. For teams curious about general designs, the Cloudflare Load Balancing documentation gives a clear overview. See Cloudflare Load Balancing for patterns that translate well to runner groups.

Migration Tips

Most teams adopt these features in three phases. First, enable priority on the busiest queue and classify a handful of critical playbooks. Second, register runner capacity in a second region and turn on health checks. Third, add aging and refine class weights after one week of observation. This sequence spreads risk and shows quick wins.

If you are coming from a single region and flat queue setup, carve out urgent work first to reduce customer facing latency. Then add a second region where you already have connector affinity. Keep standard and low classes conservative until you have confidence in rate limits and downstream error handling.

Benchmarks And Example Scenarios

The table below summarizes common patterns teams use to balance responsiveness and cost. Use it as a starting point, then tune for your traffic.

Pattern Pros Tradeoffs When To Use
Active active across two regions Low failover delay, proximity benefits Higher baseline cost, coordination overhead Time sensitive campaigns and transactional messages
Active passive with cold standby Lower cost, simple operations Longer recovery, potential warmup effects Budget constrained teams and background enrichment
Three class priority with aging Predictable urgent delivery, fairness for standard jobs Requires tuning weights and concurrency Mixed workloads with both transactional and bulk tasks

In playbooks, adopt long tail techniques such as how to set up priority queues for AI agents and multi region runner configuration for marketing automation. These phrases reflect real search intent and map to the controls in the Operations view.

If you want more context on how we instrument the platform, read our deep dive on tracing and live replay. For pricing, plan features, and setup concerns, check answers to common questions. You can always start with ButterGrow to see the hosted assistant and broader platform.

Ready to try this in your workspace today? ButterGrow makes priority control and multi region runners easy to adopt, and the scheduler keeps changes safe while you learn. Start with a single queue and one additional region, then grow from there. You can get started in minutes.

References

Frequently Asked Questions

How do priority queues interact with workspace rate limits in ButterGrow?+

Priority classes decide which jobs move first, but global and per-connector rate limits still gate throughput. If a limit is reached, lower priority jobs are paused before higher priority ones. You can see both the queue state and rate limiter counters in the Operations view so tuning is straightforward.

What is a good starting taxonomy for job priorities in marketing automation?+

Most teams begin with three classes: urgent for transactional messages, standard for scheduled campaigns, and low for bulk enrichment. This keeps rules simple and maps cleanly to business SLAs. You can add a fourth class later for experiments or background content generation if your backlog grows.

How does multi region runner failover work and what recovery time should I expect?+

Runners publish health signals and the control plane drains unhealthy regions before shifting work. With active active, healthy regions continue serving traffic while the failing region is isolated. Recovery time is dominated by health check intervals and drain timers, typically tens of seconds for most workloads.

Can I enforce data residency for European customers while using multiple regions?+

Yes. Assign a residency tag to European segments so their jobs are preferred in EU bound runners. If failover is required, jobs are re queued to another EU location. This lets you use global balancing without moving regulated payloads across jurisdictions.

Which metrics should I watch to validate queue health after enabling priority?+

Track backlog size per class, average wait time, service rate, and preemption events. If wait time for urgent jobs rises above your target, increase class weight or add concurrency in that queue. Look for aging counters to confirm fairness is working for long lived standard jobs.

Do I need to change existing playbooks to adopt multi region runners?+

Usually not. The scheduler tags jobs based on your policy and routes them to the right region automatically. You only add optional hints, like desired region or priority class, when a playbook has strong locality needs such as calling a regional API.

Ready to try ButterGrow?

See how ButterGrow can supercharge your growth with a quick demo.

Book a Demo