Loading patterns…

📬

Message Queuing(MQ)

Asynchronous message passing system enabling decoupled communication between AI agents and services in distributed agentic systems

Complexity: highMulti-Agent

In 30 seconds

What: Agents send messages to queues instead of calling each other directly, enabling asynchronous work and decoupling service dependencies.
When to use: Multiple agents need to coordinate work without blocking, handle variable load, or recover from failures without losing tasks.
Watch out: Message ordering and duplicate handling become complex; debugging distributed failures across queue, producer, and consumer is significantly harder.

Ask the AI expert about this pattern

Opens the assistant with your question prefilled. You review it before sending.

Get this catalog as an MCP server Tune a prompt for this pattern

Asynchronous message passing system enabling decoupled communication between AI agents and services in distributed agentic systems

Asynchronous agent communication
Message persistence and durability
Priority-based task distribution
Multi-agent coordination
Fault tolerance and recovery
Scalable load balancing
Event-driven workflows
Dead letter queue handling

The Agent Architect

One pattern, one tradeoff, one production failure story. A short weekly briefing for people building agentic systems.

Weekly email, one-click unsubscribe. We only use your address to send the briefing.

References

The papers, specifications, and repositories this pattern is based on.

SEDA: An Architecture for Well-Conditioned, Scalable Internet Services (2001)
Kafka: a Distributed Messaging System for Log Processing (NetDB 2011)
Kafka versus RabbitMQ (2017)arXiv:1709.00333

From the engineer behind this catalog

Get your agent architecture reviewed

This page documents one pattern. Your system runs dozens, and most failures live in how they fit together. Have the whole design reviewed against the 288 patterns in this catalog: architecture, reliability, evaluation and cost, every finding mapped to the pattern that fixes it.

€750 instead of €1,500, one week, written report and walkthrough call, until 30 September

See the review

Patterns

Loading patterns…

Design Patterns & Techniques

Loading patterns…

📬

Message Queuing(MQ)

Asynchronous message passing system enabling decoupled communication between AI agents and services in distributed agentic systems

Complexity: highMulti-Agent

In 30 seconds

What: Agents send messages to queues instead of calling each other directly, enabling asynchronous work and decoupling service dependencies.
When to use: Multiple agents need to coordinate work without blocking, handle variable load, or recover from failures without losing tasks.
Watch out: Message ordering and duplicate handling become complex; debugging distributed failures across queue, producer, and consumer is significantly harder.

Ask the AI expert about this pattern

Opens the assistant with your question prefilled. You review it before sending.

Get this catalog as an MCP server Tune a prompt for this pattern

Core Mechanism

Message Queuing enables asynchronous, decoupled communication between producers and consumers via durable queues. Brokers provide delivery guarantees (at-least-once, at-most-once, sometimes exactly-once), ordering options (per-partition/group), acknowledgments, retries, and dead-lettering. Common implementations include Apache Kafka (log-based partitions, consumer groups), RabbitMQ/AMQP (queues, exchanges, bindings), cloud queues like AWS SQS and Google Pub/Sub, NATS JetStream, and Redis Streams.

Workflow / Steps

Producer publishes message (optionally keyed for ordering/partitioning).
Broker persists/enqueues and replicates (as configured), exposing consumer lag/offsets or queue depth.
Consumer pulls/receives with prefetch/flow control; processes with a timeout/budget.
Acknowledge success; on failure, retry with backoff or route to a Dead-Letter Queue (DLQ).
Operators monitor metrics and adjust partitions/consumers/quotas for throughput and SLOs.

Best Practices

Design idempotent consumers and use idempotency keys to handle duplicates safely.

Bound processing with timeouts; implement exponential backoff + jitter; cap retries and use DLQs.

Choose delivery semantics explicitly; document ordering guarantees per topic/queue.

Use consumer groups and partitions/shards for horizontal scalability; avoid hot keys.

Apply backpressure: tune prefetch/flow control; batch where appropriate; limit inflight.

Validate message schemas (e.g., Avro/Protobuf/JSON Schema); use schema registry and compatibility rules.

Isolate side effects; use the Outbox pattern for DB→queue atomicity; ensure exactly-once where supported.

Encrypt in transit and at rest; enforce authZ (RBAC, IAM) and per-tenant quotas.

Keep messages small; store large blobs externally and pass references; compress carefully.

Observe: emit lag, queue depth, redrive counts, failure causes; add tracing with message IDs.

When NOT to Use

Ultra low-latency, synchronous request/response paths where queueing overhead breaks SLOs → prefer direct RPC (gRPC/REST).

Strict global ordering across high-throughput streams when the broker cannot guarantee it without severe throughput loss.

Simple, tightly coupled integrations where a queue adds operational complexity without clear benefit.

Common Pitfalls

Relying on implicit ordering across partitions/queues; not keying messages consistently.

Non-idempotent side effects with retries → duplicates and data corruption.

Unbounded queue growth and consumer lag due to missing backpressure or insufficient scaling.

Retry storms and thundering herds; missing circuit breakers and jittered backoff.

Large payloads in the broker; lack of schema evolution strategy leading to consumer breakage.

Key Features

Delivery semantics: at-least-once / at-most-once / exactly-once (platform-dependent).

Ordering controls: partition keys, FIFO groups, ordering keys.

Durability and replication; acknowledgment and redelivery policies.

DLQs, TTLs, and scheduled/ delayed delivery.

Consumer groups, prefetch/flow control, and backpressure.

Schema registry and compatibility modes; message versioning.

KPIs / Success Metrics

End-to-end latency p50/p95/p99; publish and consume latency.

Throughput (msgs/s, MB/s) per topic/queue and per consumer group.

Consumer lag/queue depth; oldest message age; redrive/DLQ rate.

Retry/duplicate rates; processing success/failure rates; MTTR.

Broker health: ISR/replication, partition leader balance, storage utilization.

Cost KPIs: egress, storage, request charges (for managed services).

Token / Resource Usage

Resource profile: CPU for serialization/compression and broker coordination; memory for buffers; disk I/O for durable logs; network for replication and client traffic.

Optimize with batching and compression; right-size partitions/consumer concurrency; bound message size (e.g., SQS 256 KB, Pub/Sub 10 MB, Kafka configurable).

Avoid embedding large blobs; store externally and send references; apply per-tenant quotas and rate limits.

Best Use Cases

Decoupling microservices; asynchronous workflows; background job processing.

Event-driven architectures and fan-out processing; audit/event logs.

Load leveling and burst smoothing; backpressure control in downstreams.

Cross-region buffering and intermittent-connectivity resilience.

References & Further Reading

Academic Papers

Implementation Guides

Apache Kafka: Exactly-Once Semantics
RabbitMQ: Dead Letter Exchanges, Prefetch/flow control
AWS SQS Developer Guide (FIFO/Standard, visibility timeout, DLQs)
Google Pub/Sub: Ordering Keys, Exactly-Once Delivery
NATS JetStream Concepts
Redis Streams & Consumer Groups

Tools & Libraries

Apache Kafka, RabbitMQ, AWS SQS, Google Pub/Sub, NATS JetStream, Redis Streams
Client SDKs: librdkafka/Confluent clients, Sarama (Go), Spring Kafka/AMQP, aio-pika, AWS SDKs
Job queues: Celery, Sidekiq, Resque, BullMQ, RQ

Community & Discussions

Asynchronous message passing system enabling decoupled communication between AI agents and services in distributed agentic systems

Asynchronous agent communication
Message persistence and durability
Priority-based task distribution
Multi-agent coordination
Fault tolerance and recovery
Scalable load balancing
Event-driven workflows
Dead letter queue handling

The Agent Architect

One pattern, one tradeoff, one production failure story. A short weekly briefing for people building agentic systems.

Weekly email, one-click unsubscribe. We only use your address to send the briefing.

References

The papers, specifications, and repositories this pattern is based on.

SEDA: An Architecture for Well-Conditioned, Scalable Internet Services (2001)
Kafka: a Distributed Messaging System for Log Processing (NetDB 2011)
Kafka versus RabbitMQ (2017)arXiv:1709.00333

From the engineer behind this catalog

Get your agent architecture reviewed

€750 instead of €1,500, one week, written report and walkthrough call, until 30 September

See the review

Loading patterns…

Message Queuing(MQ)

In 30 seconds

Ask the AI expert about this pattern

Message Queuing: Overview

The Agent Architect

References

Get your agent architecture reviewed

Patterns

Loading patterns…

Design Patterns & Techniques

Loading patterns…

Message Queuing(MQ)

In 30 seconds

Ask the AI expert about this pattern

Core Mechanism

Workflow / Steps

Best Practices

When NOT to Use

Common Pitfalls

Key Features

KPIs / Success Metrics

Token / Resource Usage

Best Use Cases

References & Further Reading

Academic Papers

Implementation Guides

Tools & Libraries

Community & Discussions

Message Queuing: Overview

The Agent Architect

References

Get your agent architecture reviewed

Patterns

Design Patterns & Techniques

Loading patterns…

Design Patterns & Techniques

Core Mechanism

Workflow / Steps

Best Practices

When NOT to Use

Common Pitfalls

Key Features

KPIs / Success Metrics

Token / Resource Usage

Best Use Cases

References & Further Reading

Academic Papers

Implementation Guides

Tools & Libraries

Community & Discussions

Design Patterns & Techniques