RabbitMQ 4.3 for AI Agent Task Queues: Quorum Queues, Strict Priorities, Delayed Retry

TL;DR — RabbitMQ 4.3 (April 23, 2026) is the first release where I'd unreservedly pick AMQP for AI agent task queues. Strict priorities, delayed retry with backoff, consumer timeouts, 50% memory drop on small messages, and Khepri replacing Mnesia as the only metadata store. If your agent jobs are heterogeneous and stateful, this beats Kafka.

The pattern

AI agent work isn't always a stream — sometimes it's a queue of heterogeneous tasks: "research this lead", "draft this email", "analyze this call". Each task has a priority, a retry budget, and a TTL. RabbitMQ quorum queues model this directly.

In 2026, classic mirrored queues are gone. Quorum queues are the only data-safety queue type, with streams for log-style replay. The 4.3 release added the four features that mattered most for agent workloads: strict priorities, delayed retry, consumer timeouts, and the 50% memory reduction.

How it works (architecture)

flowchart LR
  API[Agent API] -->|publish task| Ex[Topic exchange]
  Ex -->|priority 9| HighQ[(quorum queue: high)]
  Ex -->|priority 5| MidQ[(quorum queue: mid)]
  Ex -->|priority 1| LowQ[(quorum queue: low)]
  HighQ --> W1[Worker pool A]
  MidQ --> W1
  LowQ --> W2[Worker pool B]
  W1 -->|nack + delay| Retry[(quorum queue: retry)]
  Retry -->|TTL elapsed| Ex
  W1 -->|max retries| DLQ[(quorum queue: dlq)]

The retry queue uses x-message-ttl + dead-letter-exchange to bounce messages back to the main exchange after backoff. As of 4.3, quorum queues do this natively with delayed retry — no shovel needed.

CallSphere implementation

CallSphere's Real Estate OneRoof uses NATS for the in-pod agent bus (post #1), but our GTM lead-gen launcher uses RabbitMQ quorum queues for batch enrichment work — heterogeneous, prioritizable, retryable. After-hours uses a Bull/Redis queue (post #4) because the work is high-cardinality and short-lived. 37 agents · 90+ tools · 115+ DB tables · 6 verticals · pricing $149/$499/$1499 · 14-day trial · 22% affiliate.

Build steps with code

1. Pin to 4.3+ with Khepri enabled (4.3 makes Khepri the only metadata store).
2. Declare quorum queue: x-queue-type=quorum, x-max-priority=10, x-dead-letter-exchange=dlx.
3. Set per-message priority on publish based on plan tier.
4. Use publisher confirms + transactions for at-least-once.
5. Consumer timeout prevents stuck deliveries (4.3 adds per-queue tuning).
6. Set delivery-limit for the new acquired-count tracking.
7. Monitor queue depth + Khepri Raft state via the management plugin.

import pika

params = pika.ConnectionParameters("rabbit", credentials=pika.PlainCredentials("u","p"))
conn = pika.BlockingConnection(params)
ch = conn.channel()

ch.queue_declare(
    queue="agent.tasks.high",
    durable=True,
    arguments={
        "x-queue-type": "quorum",
        "x-max-priority": 10,
        "x-dead-letter-exchange": "dlx",
        "x-delivery-limit": 5,
    },
)
ch.basic_publish(
    exchange="agent",
    routing_key="task.research",
    body=task_json,
    properties=pika.BasicProperties(priority=9, content_type="application/json"),
)

def on_msg(ch, method, props, body):
    try:
        run_agent_task(body)
        ch.basic_ack(method.delivery_tag)
    except Exception:
        ch.basic_nack(method.delivery_tag, requeue=False)  # to DLX

ch.basic_qos(prefetch_count=10)
ch.basic_consume(queue="agent.tasks.high", on_message_callback=on_msg)
ch.start_consuming()

Common pitfalls

• Still using classic mirrored queues — gone in 4.0; migrate before upgrading.
• prefetch=1 — kills throughput; pick prefetch based on task duration variance.
• No delivery-limit — poison messages loop forever; 4.3's acquired-count makes this visible.
• Putting priorities on every queue — priority queues cost CPU; reserve for tiered SLAs.
• Using AMQP for high-fanout streaming — that's a stream, not a queue; use RabbitMQ Streams or Kafka.

FAQ

Quorum queues vs streams? Quorum = work queue (consume-once). Streams = log (replay).

Mnesia is gone? Yes — 4.3 makes Khepri the only metadata store.

How big is the 4.3 memory win? Up to 50% for messages ≤ 32 KiB; matters at queue depths in the millions.

Should we use RabbitMQ or Kafka for AI agents? Heterogeneous, retryable tasks → RabbitMQ. High-throughput append-only events → Kafka. Both is fine.

Where does CallSphere offer Rabbit-backed agents? Across the catalog at /pricing; see the demo.

Sources

• RabbitMQ 4.3 Highlights
• Quorum Queues Docs
• Streams and Superstreams
• RabbitMQ 4.0 Quorum Queue Features

## RabbitMQ 4.3 for AI Agent Task Queues: Quorum Queues, Strict Priorities, Delayed Retry: production view RabbitMQ 4.3 for AI Agent Task Queues: Quorum Queues, Strict Priorities, Delayed Retry forces a tension most teams underestimate: agent handoff state. A single LLM call is easy. A booking agent that hands a confirmed slot to a billing agent that hands a follow-up to an escalation agent — that's where context loss, hallucinated IDs, and double-bookings live. Solving it well means treating the conversation as a stateful workflow, not a chat. ## Serving stack tradeoffs The big fork is managed (OpenAI Realtime, ElevenLabs Conversational AI) versus self-hosted on GPUs you operate. Managed wins on cold-start, model freshness, and zero-ops; self-hosted wins on unit economics past a certain conversation volume and on data residency for regulated verticals. CallSphere runs hybrid: Realtime for live calls, self-hosted Whisper + a hosted LLM for async, both routed through a Go gateway that enforces per-tenant rate limits. Latency budgets are non-negotiable on voice. End-to-end target is sub-800ms ASR-to-first-token and sub-1.4s first-audio-out; anything beyond that and turn-taking feels stilted. GPU residency in the same region as your TURN servers matters more than choosing a slightly bigger model. Observability is the unglamorous backbone — every conversation produces logs, traces, sentiment scoring, and cost attribution piped to a per-tenant dashboard. **HIPAA + SOC 2 aligned** isolation keeps healthcare traffic separated from salon traffic at the storage layer, not just the API. ## FAQ **What's the right way to scope the proof-of-concept?** Real Estate runs as a 6-container pod (frontend, gateway, ai-worker, voice-server, NATS event bus, Redis) backed by Postgres `realestate_voice` with row-level security so multi-tenant data never crosses tenants. For a topic like "RabbitMQ 4.3 for AI Agent Task Queues: Quorum Queues, Strict Priorities, Delayed Retry", that means you're not starting from scratch — you're configuring an agent template that's already been hardened across thousands of conversations. **How do you handle compliance and data isolation?** Day one is integration mapping (scheduler, CRM, messaging) and prompt tuning against your top 20 real call transcripts. Day two through five is shadow-mode running, where the agent transcribes and recommends but a human still answers, so you can compare side-by-side. Go-live is the moment your eval pass-rate clears your internal bar. **When does it make sense to switch from a managed model to a self-hosted one?** The honest answer: it scales until your tool catalog gets stale. The agent is only as good as the integrations it can actually call, so the operational discipline is keeping schemas, webhooks, and fallback paths green. The platform handles the rest — observability, retries, multi-region routing — without your team owning the GPU layer. ## Talk to us Want to see how this maps to your stack? Book a live walkthrough at [calendly.com/sagar-callsphere/new-meeting](https://calendly.com/sagar-callsphere/new-meeting), or try the vertical-specific demo at [salon.callsphere.tech](https://salon.callsphere.tech). 14-day trial, no credit card, pilot live in 3–5 business days.