Memory Pub/Sub

An agent or process that generates and emits memory events or state updates to the system. Publishers categorize events into logical topics (e.g., agent:location, task:completed) without knowledge of which subscribers, if any, will receive them. This decoupling is the core of the pattern.

• Role: Initiates communication by pushing messages.
• Key Action: publish(topic, message)
• Example: An agent completing a navigation step publishes an event to the agent:movement topic containing its new coordinates.

An agent or process that registers interest in one or more topics and receives relevant messages as they are published. Subscribers implement a callback or handler function that is invoked asynchronously by the broker when a matching event arrives.

• Role: Listens for and reacts to specific events.
• Key Action: subscribe(topic, callback_handler)
• Example: A monitoring agent subscribes to the system:alert topic to log and escalate any error events published by other agents.

The central routing infrastructure that accepts published messages, filters them by topic, and distributes copies to all active subscribers for that topic. It manages connection state, message queues, and delivery semantics.

• Core Functions: Topic-based routing, connection management, persistence (optional).
• Delivery Semantics: Defines guarantees like at-most-once, at-least-once, or exactly-once delivery.
• Examples: Redis Pub/Sub, Apache Kafka, RabbitMQ, or a custom in-memory broker.

A named channel or category that acts as an address for messages. It is the primary routing key used by the broker to match publishers with subscribers. Topics provide a layer of abstraction, allowing publishers and subscribers to evolve independently.

• Structure: Often a hierarchical string (e.g., sensor/floor1/temperature).
• Wildcards: Systems may support pattern-based subscriptions (e.g., sensor/floor1/*).
• Purpose: Enables selective broadcasting; subscribers receive only messages relevant to their subscribed topics.

The structured data packet containing the state update or notification being communicated. The payload is opaque to the broker but must be serializable. In agentic memory systems, it often contains semantic embeddings, agent state, or action results.

• Common Formats: JSON, Protocol Buffers, Avro.
• Typical Fields: event_id, timestamp, source_agent, topic, data (the core payload).
• Example: {"agent_id": "nav_01", "timestamp": 1712345678, "data": {"x": 105, "y": 42}}

Defines how subscribers express interest and how messages are delivered. Beyond simple 1:1 topic matching, advanced patterns enable complex coordination.

• Fan-Out: A single message from one publisher is delivered to many subscribers (broadcast).
• Durable Subscriptions: The broker retains messages for offline subscribers, delivering them upon reconnection.
• Queue Groups: Multiple subscribers to the same topic form a competing consumers group, where each message is delivered to only one member, enabling load balancing.
• Pattern Subscription: Subscribing using wildcards (e.g., agent.*.status) to receive messages from a family of topics.

A consistency model guarantee that if no new updates are made to a data item, all reads to that item will eventually return the last updated value. It prioritizes high availability and partition tolerance over immediate synchronization, making it suitable for distributed, scalable systems like agent memory fabrics where perfect real-time sync is not required.

• Trade-off: Sacrifices strong consistency for lower latency and higher fault tolerance.
• Use Case: Ideal for agent state synchronization where temporary staleness is acceptable (e.g., agent status updates, non-critical shared context).

A data structure designed for distributed systems that can be updated concurrently by multiple agents without coordination, and whose state can always be merged deterministically. CRDTs are foundational for building convergent shared memory where agents can edit local copies that are later synchronized.

• Key Property: Commutative operations ensure merge order does not affect final state.
• Example Types: G-Counters (grow-only), PN-Counters (increment/decrement), OR-Sets (observed-remove sets) for collaborative agent task lists or shared knowledge bases.

A messaging middleware pattern that facilitates communication between decoupled components by allowing them to publish and subscribe to events. It acts as the central nervous system for a Memory Pub/Sub architecture, routing memory updates, state changes, and coordination signals between agents and services.

• Core Function: Decouples event producers from consumers.
• Implementation: Often built on technologies like Apache Kafka, RabbitMQ, or Redis Pub/Sub.
• Agent Use: Agents publish "memory updated" events; other agents subscribe to topics relevant to their domain.

A peer-to-peer communication protocol where nodes (agents) periodically exchange state information with a randomly selected set of peers to disseminate information throughout a cluster. It provides a robust, decentralized alternative to a central event bus for propagating memory updates in large-scale, ad-hoc agent networks.

• Epidemic Spread: Information propagates exponentially through the network.
• Fault Tolerance: No single point of failure; resilient to node churn.
• Agent Scenario: Used in swarm or mesh architectures where agents dynamically join/leave and need to share discovered environmental data.

A data structure used in distributed systems to track causality between different versions of a data object replicated across multiple nodes. In agent memory systems, it resolves update conflicts by identifying which changes happened before others, enabling intelligent merge operations or conflict detection.

• Mechanism: Each replica maintains a vector clock—a list of (node, counter) pairs.
• Outcome: Can determine if versions are concurrent (potential conflict) or if one is a descendant of another.
• Application: Essential for implementing causal consistency in agent shared memory.

The real-time processing of continuous, unbounded sequences of data records (streams). In agentic systems, memory updates and sensory inputs form event streams that can be processed for analytics, transformation, or aggregation before being stored or published.

• Core Concept: Enables continuous intelligence on agent activity and memory evolution.
• Frameworks: Apache Flink, Apache Spark Streaming, ksqlDB.
• Agent Integration: Processes streams of agent actions to compute real-time metrics, detect anomalous behavior patterns, or enrich memory events with derived context before publication.