Agent Communication

Why Not Direct Calls?

The simplest way to connect two agents would be to have Agent A call Agent B directly — like one function calling another. This creates tight coupling: if Agent B is down, Agent A crashes. If Agent B changes its interface, Agent A breaks. If you add Agent C, you need to rewire everything.

Instead, agents communicate through shared memory — a database table both can access. Agent A writes its output to a key. Agent B watches that key. They never need to know about each other's existence. This is the same pattern used by Apache Kafka, RabbitMQ, and Redis pub/sub in production systems worldwide.

Message Passing in Practice

In a typical shared memory setup, Agent A (a content writer) writes its output to a key in the consciousness_stream table. Agent B (a publisher) watches that key and acts when new data appears. The two agents never communicate directly — they only share a key name.

How It Works in Code

The pattern is simple: a sender writes to a key, a receiver polls or subscribes to that key. Here is a complete example:

# Sender agent writes its output to shared memory
def writer_agent(db, content):
    db.execute(
        "INSERT INTO consciousness_stream (key, value, agent) "
        "VALUES ('task.output', %s, 'writer')",
        [json.dumps({"title": content.title, "body": content.body})]
    )

# Receiver agent watches for new entries
def publisher_agent(db):
    while True:
        new = db.execute(
            "SELECT * FROM consciousness_stream "
            "WHERE key = 'task.output' AND processed = false "
            "ORDER BY created_at LIMIT 1"
        )
        if new:
            publish_to_website(new.value)
            db.execute(
                "UPDATE consciousness_stream SET processed = true "
                "WHERE id = %s", [new.id]
            )
        time.sleep(5)  # poll every 5 seconds

The writer does not know or care if anyone reads its output. The publisher does not know or care who wrote the content. They only share a key name: task.output.

Polling vs. Real-Time

The code above uses polling — checking for new messages every 5 seconds. This is simple but introduces latency. There are faster alternatives: