Short answer: One agent writes scoped notes; another retrieves by meaning later, making handoffs durable beyond ephemeral message passing.
Point-to-point messages fail when the peer is offline or a third agent needs the same fact. Memory channels need group boundaries, topic discipline, and conflict handling. Engram groups and property scopes implement the board. Prefer short queryable notes over narrative dumps that recreate context-window bloat in the store.
Agents on a team need to exchange more than the last chat turn. A specialist may discover a constraint that another role needs hours later. Direct message passing can carry that fact once. It does not make the fact easy to find again, hard to leak, or durable across restarts. Memory as a communication channel treats the store itself as the place agents leave messages for each other. One agent writes. Another retrieves by meaning and scope when the job needs it. This chapter explains when that pattern beats pure message passing, where it fails, and how Weaviate Engram supports it with groups, property scopes, and deliberate search.
How Is Memory Different from Ordinary Inter-Agent Messaging?
Message passing is point-to-point and usually ephemeral. Agent A sends a packet to Agent B. If B is busy, offline, or not yet spawned, the packet needs a queue. If a third agent later needs the same fact, someone must forward it again.
A memory channel is publish-and-retrieve. Agent A writes a durable note into a scoped store. Agent B does not need to be listening at write time. When B starts its turn, it searches for what matters to its role. Classic blackboard systems used the same idea. Agents posted partial results to a shared board. Others contributed when relevant data appeared.
The difference in modern LLM teams is retrieval. The board is not only a chronological wall of notes. It is a semantic index. An agent can ask for berth constraints or fuel status without replaying every prior message. That is communication by query, not only by inbox.
When Does a Memory Channel Beat Passing Full Context Around?
Full-context routing looks simple. Copy everything into every specialist prompt. It collapses under scale. Token cost rises. Irrelevant details distract. Agents that start later still miss earlier discoveries unless the mega-prompt is rebuilt every time.
Memory channels help when work is asynchronous, long-running, or role-split. A night dock agent can post a closed-slip warning. A morning charter desk can retrieve it without inheriting the night agent’s entire tool trace. The message survives process restarts. It can be audited. It can be corrected through the same conflict tools used for other shared memories.
Memory channels are weaker when you need immediate negotiation. Rapid back-and-forth about a single decision still belongs in messages or a live supervisor loop. Use memory for facts that should outlive the conversation that produced them. Status, blocks, and verified findings belong on the board. Bargaining turns usually do not.
What Must Be True for Memory to Work as a Safe Channel?
Scoping is the first requirement. Not every agent should read every note. Project-wide topics can carry trusted operational status inside a team. Property scopes can pin messages to a job, berth, or shift. User-scoped topics keep private customer details out of the team board. Engram enforces those boundaries on both write and search.
Content discipline is the second requirement. Topics should magnetize handoff notes, status facts, and scrubbed constraints. They should not vacuum up every speculative aside. A channel that stores noise becomes a rumor mill. Bounded topics help when a scope should hold only one current status object that later writers update in place.
Governance is the third requirement. Writers need attribution in the application layer. Readers need queries that match their role. Conflict resolution still applies when two agents post incompatible status. A memory channel without those controls recreates the failures of an unmoderated shared drive.
How Does Weaviate Engram Implement an Inter-Agent Memory Channel?
Weaviate Engram already separates use cases with groups. A team can dedicate a group such as agent_handoffs to cross-role notes, while role craft stays in narrower groups. Project-wide topics in the handoff group act as the board. Agents write with a shared property like job_id. Later agents search that same group and property with a task-shaped query.
Because search is semantic and scoped, the receiving agent does not need the sender’s address. It needs the right group, the right scope keys, and a query about the work. That is closer to a blackboard than to email. It also composes with continual learning. Handoff notes that prove durable can later be promoted into scrubbed procedures after transform and commit.
Async pipelines matter here too. The writer can fire-and-forget. The reader should search when it needs the fact, ideally after related runs have had time to commit if the handoff is brand new. For tight handoffs, waiting on runs.wait makes the channel feel synchronous without forcing both agents into one context window.
What Does a Concrete Handoff Through Engram Look Like?
Consider a marina operations desk for Slip 14. A fuel-dock agent discovers the tank is contaminated. A charter-desk agent, running later in a different process, must not assign that slip’s boat until the tank is cleared. They never share a live chat. They share Engram.
from engram import EngramClient, HybridRetrieval
client = EngramClient(api_key=os.environ["ENGRAM_API_KEY"])
slip_id = "dock-slip-14"
# Fuel-dock agent posts a durable handoff note.
run = client.memories.add(
"Handoff: Slip 14 diesel tank failed water-paste test. Do not fuel charter boats from this tank until flushed.",
group="agent_handoffs",
properties={"slip_id": slip_id},
)
client.runs.wait(run.run_id)
# Charter-desk agent retrieves the note without the fuel agent's transcript.
handoffs = client.memories.search(
query="Any fuel or safety blocks before assigning a charter from Slip 14?",
group="agent_handoffs",
properties={"slip_id": slip_id},
retrieval_config=HybridRetrieval(limit=5),
)
memory_context = "\n".join(f"- {m.content}" for m in handoffs)
The charter agent receives the block as memory, not as a forwarded blob of dock telemetry. When the tank is cleared, a later write can update or supersede the handoff through the same conflict-aware pipeline. The channel stays current without requiring both agents to be online together.
Treat the memory channel as infrastructure, not as a dump of every agent utterance. Short, scoped, queryable notes beat long narrative dumps that recreate the original context-window problem inside the store.
Handoffs between peers are one shape of distributed memory. Hierarchies add another. Orchestrators and sub-agents often need different stores and different rights. Our next chapter, How should sub-agent memory differ from orchestrator memory?, separates those layers so planners and specialists stop fighting over the same notes.