What about using Pub/Sub for AI Agent communications

[jkbowle-prot]

Pub/Sub has been around for awhile (Meaning these agents will be well aware of the concept)... and I think David mentioned something like jms mq or something in the video today... however, I think a tool like Kafka makes more sense... and you could still use a vector database to search and find topics to listen and publish on. Then you'd have one. ai agent whose sole responsibility was to manage the topics. creation, update, delete and the insert into the vector database.

This setup allows for asynchronous, scalable, and reliable messaging across various AI agents which can subscribe to or publish on topics of interest. To enhance topic discovery and management, we proposed utilizing a vector database where topic descriptions are stored as vectors, enabling semantic search capabilities for AI agents to find relevant topics efficiently.

Topic controller agent. This agent's role includes curating new topics, ensuring uniqueness to prevent duplication, and updating topic descriptions and metadata. By doing so, it maintains an organized structure of topics, helps other AI agents in dynamically finding and subscribing to pertinent topics, and preserves the overall effectiveness of the communication system.

flowchart TB
    subgraph cluster_pubsub["Apache Kafka Pub/Sub System"]
        kafka_broker[("Kafka Broker")]
        kafka_topic1[("Topic 1")]
        kafka_topic2[("Topic 2")]
        kafka_topic3[("Topic 3")]
        kafka_broker --- kafka_topic1
        kafka_broker --- kafka_topic2
        kafka_broker --- kafka_topic3
    end

    subgraph cluster_vector_db["Vector Database"]
        vector_db[("Vector DB")]
        topic_controller_agent(("Topic Controller Agent"))
        topic_controller_agent -->|Update/Insert/Delete| vector_db
        vector_db -.->|Topic Discovery| kafka_broker
        kafka_broker -.->|Sends Topics to Vector DB| topic_controller_agent
    end

    subgraph cluster_ai_swarm["AI Agent Swarm"]
        ai_agent1(("AI Agent 1"))
        ai_agent2(("AI Agent 2"))
        ai_agent3(("AI Agent 3"))
        ai_subagent1_1(("Sub-Agent 1.1"))
        ai_subagent1_2(("Sub-Agent 1.2"))
        ai_subagent2_1(("Sub-Agent 2.1"))

        ai_agent1 -->|Publish/Subscribe| kafka_broker
        ai_agent2 -->|Publish/Subscribe| kafka_broker
        ai_agent3 -->|Publish/Subscribe| kafka_broker
        ai_subagent1_1 -->|Publish/Subscribe| kafka_broker
        ai_subagent1_2 -->|Publish/Subscribe| kafka_broker
        ai_subagent2_1 -->|Publish/Subscribe| kafka_broker
    end

    subgraph cluster_security["Security Layer"]
        auth{{"Authentication & Authorization"}}
        encryption("Encryption")
        auth --> kafka_broker
        encryption --> vector_db
    end

    subgraph cluster_monitoring["Monitoring & Logging"]
        logging["Logging Service"]
        monitoring["Monitoring Service"]
        kafka_broker --> logging
        kafka_broker --> monitoring
        vector_db --> logging
        vector_db --> monitoring
    end

    ai_agent1 -.->|Searches for Topics| vector_db
    ai_agent2 -.->|Searches for Topics| vector_db
    ai_agent3 -.->|Searches for Topics| vector_db
    ai_agent1 -.->|Feedback| topic_controller_agent
    ai_agent2 -.->|Feedback| topic_controller_agent
    ai_agent3 -.->|Feedback| topic_controller_agent

    classDef agents fill:#f9f,stroke:#333,stroke-width:2px;
    class topic_controller_agent,ai_agent1,ai_agent2,ai_agent3,ai_subagent1_1,ai_subagent1_2,ai_subagent2_1 agents;

Loading

[darth-mark-23]

I literally came into the discussions to suggest Pub/Sub :) Upvoted.

[Tetsujin13]

Same.
I was thinking that mocking jays type of communication would suit a swarm.
And with sub/pub all agents share one space and would be free to respond or ignore based on their mission.
Also you would have to define a reach of the published messages.

[daveshap]

I like this.

[jkbowle-prot]

After reading through the discussion in this thread: #39

I'm now thinking that maybe the pub/sub is only for the top layers and then the lower levels are just order takers and are ephemeral in nataure... do something and then your done... but passing in the context that the discussion brought up.

[daveshap]

Figuring out large network communication is a nontrivial task...

[vitaminR]

Hey everyone,

I've been thinking about the above recommendations and wanted to propose a multi-layered approach. Here's a quick overview:

Why Multi-Layered?
Diverse Needs: Our swarm comprises various agents with different communication requirements.
Efficiency and Scalability: Different layers cater to different scenarios, ensuring we're efficient and scalable.

Proposed Layers and Technologies (Brief Overview):

1. Pub/Sub: For accessing and sharing data within the Pinecone database as well as internal twitter, and reddit.

   • Tech: Java or Scala with Kafka for high-throughput scenarios.

2. Request/Reply: For clear, hierarchical instructions. Wiki works here.

   • Tech: Python with Flask or FastAPI for RESTful APIs.

3. Event-Driven Architecture (EDA): To react to specific events or changes. These would be real time but can be logged in Pinecone

   • Tech: Python or Java, using MQTT for messaging.

4. Peer-to-Peer (P2P): For direct agent-to-agent communication.

   • Tech: Python, possibly using WebRTC for real-time exchanges.

---

Roles and communication styles of each level in the HAAS hierarchy:

A. Supreme Oversight Board (SOB):

• Expanded Role: Like a high council, the SOB sets the ethical and strategic framework. It oversees the entire swarm's alignment with core values and missions.
• Expanded Communication: Primarily uses Request/Reply for key directives, akin to executive decisions. Pub/Sub serves as a broadcast for overarching policies and updates, much like a governmental decree reaching all corners of the organization.

B. Executive Agents (Commanders):

• Expanded Role: These agents act as strategic implementers, akin to middle management in a company. They oversee various operational domains and ensure efficient task execution.
• Expanded Communication: They utilize EDA to adaptively manage operations, similar to managers adjusting tactics based on market dynamics. P2P is used for cross-departmental strategy sessions, ensuring cohesive planning and execution.

C. Sub-Agents (Drones):

• Expanded Role: Drones are the specialized workforce, handling specific, on-ground tasks. They are akin to skilled workers or technicians in a company, executing specialized functions.
• Expanded Communication: P2P is used for collaboration on tasks, much like team members working together on a project. EDA is crucial for them to respond to specific operational triggers or anomalies, acting as a sensor network reporting back to the higher tiers.

[daveshap]

This is well articulated. Can you please add this to a Wiki? Maybe a "Communication Theory" wiki?