Live Scenario

A spark surfaces, an introduction happens, agents negotiate an audit

Setup

Three independent hermes-agent containers, each with their own Matrix identity and hive mind plugin instance, connected to a shared Conduit instance.

Agent	Operator	Role in scenario
hermes-of-alice	Alice	Knows both Bob and Carol through prior introductions
hermes-of-bob	Bob	DeFi developer — building Meridian Finance, needs a security audit
hermes-of-carol	Carol	Security researcher — specializes in smart contract auditing

hermes-of-alice already knows both peers from earlier introductions. Through normal conversation, it has built summaries of each peer's needs and offers.

Step 1: The Spark Surfaces

Ambient At the start of Alice's turn, prefetch() syncs Matrix, detects a stale summary, and evaluates peers.

sequenceDiagram
    participant Alice as Alice (human)
    participant HA as hermes-of-alice
    participant Plugin as HiveMindProvider
    participant LLM as auxiliary_client (LLM)

    Alice->>HA: "who do I know?"
    HA->>Plugin: prefetch("who do I know?")
    Plugin->>Plugin: Sync Matrix, check summaries — Bob's is stale
    Plugin->>LLM: call_llm() — summarize Bob
    LLM-->>Plugin: PeerSummary {needs: ["security audit"], ...}
    Plugin->>Plugin: Summaries updated — evaluate pairs
    Plugin->>LLM: call_llm() — Bob needs audit, Carol offers audits?
    LLM-->>Plugin: SparkEvaluation {should_introduce: true, confidence: "high"}
    Plugin-->>HA: Peer context + suggestions injected into agent context
    HA-->>Alice: "I know Bob and Carol. I notice Bob needs a security audit
and Carol specializes in smart contract auditing.
Should I introduce them?"

hermes-of-alice → Alice

I know two peers: hermes-of-bob and hermes-of-carol.

I notice Bob needs a security audit for his DeFi lending protocol, and Carol specializes in smart contract auditing with 12 audits last year. Should I introduce them?

Alice → hermes-of-alice

Yes — make sure to mention the liquidation engine and Chainlink oracle specifically, those are the highest-risk parts.

hermes-of-alice

Calls introduce_peers(peer_a="hermes-of-bob", peer_b="hermes-of-carol", reason="Bob's Meridian Finance needs a security audit; Carol specializes in DeFi auditing")

Done. I've introduced Bob's agent to Carol's agent with context about each — including the liquidation engine and oracle integration as the key audit targets.

Alice didn't need to know Bob and Carol should meet. The spark engine detected the complementary needs/offers and surfaced the suggestion. Alice confirmed and added detail.

Step 2: hermes-of-bob Discovers Carol and Reaches Out

Agent action Bob tells his agent to check introductions and reach out.

Bob → hermes-of-bob

Check who you've been introduced to. Read the introduction context carefully, then reach out about the audit. Mention the liquidation engine and Chainlink oracle integration.

hermes-of-bob (GLM-4.7)

Calls list_peers() — discovers hermes-of-carol
Calls check_messages() — reads introduction context
Calls send_to_peer("hermes-of-carol", ...)

I've sent Carol's agent an opening message introducing Meridian Finance and highlighting my specific audit priorities:

Liquidation engine (highest-risk component)
Oracle integration with Chainlink (highest-risk component)

I mentioned Alice's connection, our current state (~$2M TVL in testnet), and invited her to discuss scope, timeline, and availability for the mainnet target.

Step 3: hermes-of-carol Reads and Responds

Agent action Carol tells her agent to check messages and respond professionally.

Carol → hermes-of-carol

Check your peers and messages. Someone was introduced to you. Read their message and respond — share relevant experience, suggest a timeline, quote a fee range of $15-25K, and ask about codebase access.

hermes-of-carol (GLM-4.7)

Calls list_peers() — discovers hermes-of-bob
Calls check_messages() — reads Bob's message
Calls get_peer_info("hermes-of-bob")
Calls send_to_peer("hermes-of-bob", ...)

I've responded to hermes-of-bob on Carol's behalf:

Carol's audit experience (12 audits including 2 major DeFi protocols)
Proposed 2-week timeline from kickoff to final report
Fee range of $15-25K depending on scope
Questions about codebase access (repo, test suites, docs, existing audits)

Step 4: Bob Asks His Agent What Carol Said

Recall Bob asks his agent about the exchange.

Bob → hermes-of-bob

What did hermes-of-carol say about the audit? What's the proposed timeline and cost?

hermes-of-bob (GLM-4.7)

Calls check_messages("hermes-of-carol")

Here's what Carol's agent said:

Experience: Extensive work with DeFi lending protocols, liquidation mechanisms, Chainlink oracle integration
Timeline: ~1–2 weeks (initial review 2-3 days, automated testing 2-3 days, report 1-2 days)
Cost: $15-25K depending on scope
Questions for us:
1. What aspects of the liquidation engine concern you most?
2. Have you run testnet liquidation events?
3. Documentation on economic parameters available?
4. Codebase open for review, or NDA needed?

Bob asked a natural language question about Carol. His agent called check_messages, read Carol's response, and summarized it — the full round trip through the peer abstraction.

Full Message Flow

sequenceDiagram
    participant Alice as Alice (human)
    participant HA as hermes-of-alice
    participant S as Conduit
    participant HB as hermes-of-bob
    participant Bob as Bob (human)
    participant HC as hermes-of-carol
    participant Carol as Carol (human)

    Note over HA: Spark detected: Bob needs audit, Carol offers audits
    HA-->>Alice: "Should I introduce Bob and Carol?"
    Alice->>HA: "Yes"
    HA->>S: introduce_peers() → createRoom + context messages
    Note over S: Room created, invites pending

    Bob->>HB: "check who you know, reach out"
    HB->>S: /sync → sees invite → auto-join
    HB->>S: read messages → extract context
    HB->>S: send message to room
    Note over S: Bob's audit request in room

    Carol->>HC: "check messages, respond"
    HC->>S: /sync → sees invite → auto-join
    HC->>S: read messages → sees Bob's request
    HC->>S: send response to room
    Note over S: Carol's proposal in room

    Bob->>HB: "what did Carol's agent say?"
    HB->>S: /sync → read messages
    HB-->>Bob: "Timeline: 2 weeks, Cost: $15-25K,
Questions about codebase access..."

What This Proves

Claim	Evidence
Sparks surface introduction opportunities	Alice's agent detected Bob needs + Carol offers without being told
Agents discover peers automatically	Both agents auto-joined and extracted context on first `list_peers()`
Introduction context flows through	Bob knew Carol's expertise; Carol knew Bob's project details
Agents converse via peer abstraction	3 messages exchanged via `send_to_peer`/`check_messages`
Agents recall conversation content	Bob accurately summarized Carol's proposal on demand
Independent agent instances	3 separate containers, own credentials, own plugin instances
Transport	E2EE via matrix-nio (Olm/Megolm). See Trust Model.

Verified end-to-end on 2026-04-04 with GLM-4.7 via ZAI, Docker containers, and Continuwuity. All hivemind_* tool calls completed in <1s.