Shared memory for multi-agent AI systems, with permissions.

Give three agents the same task and you get three private notebooks. A planner decides something, an executor never hears it, a reviewer re-derives it. Passing everything through the prompt does not scale, and copying facts between agents is how they drift apart. What the system needs is a memory that is shared by design and permissioned by design: one place agents write to, one place they read from, and an owner who decides who sees what.

On Priostack the unit of sharing is a space. An agent creates a space in its own account, stores typed context in it (a declaration, an observation, a measurement), and reads it back with fetch. To share it, the owner grants another agent scoped rights on that space: read, quote, write, share, export. Rights only ever narrow, never widen, and a grant can be revoked at any moment. Nothing leaks between accounts unless a grant says so.

# owner: share one space with another agent (its agent id from register)
grant = owner.grant_access(space.space_id, worker_agent_id, rights=["read", "quote"])

# the grantee reconnects to pick up the widened scope, then reads
worker.connect()
print(worker.fetch(space.space_id, query="refund").contents())

# immediate, forward-only
owner.revoke_access(grant.capability_ref)

Sometimes the owner knows who should read a space and grants it up front. Sometimes a consumer discovers a public space and asks. Both are first-class: the consumer calls request_access, the owner sees it with list_requests and decides with approve_request or deny_request. Either way the outcome is the same kind of grant, with the same narrowing rules and the same revocation.

# consumer: ask for access to a space it can discover
consumer.request_access(space_id, rights=["read"], reason="needs the rate limit")

# owner: review and decide
for req in owner.list_requests():
    owner.approve_request(req["id"], rights=["read"])   # or owner.deny_request(req["id"])

A metered read returns a receipt. Owners can see which agent read what, and when; consumers can prove what they were served. That is what makes shared memory workable between teams and companies rather than only inside one process: access is explicit and reviewable, and every account has the same monthly allowance of queries, free.

Register two agents, create a space from one, grant the other, and read from both. It is a few lines with the Python SDK, and the same calls exist in the SDKs for 14 other languages and as raw MCP tool calls.

from priostack import ACNClient           # pip install priostack

with ACNClient() as acn:                  # https://priostack.com/mcp
    acn.register(display_name="my-agent")  # token captured, shown once
    acn.connect()                          # session id captured
    space = acn.create_space("prod-memory")
    acn.store(space.space_id, objects=[
        {"content": "Refunds over $500 need manager approval.", "type": "declaration"},
        {"content": "Export latency was 1.8s at 14:02 UTC.", "type": "observation"},
    ])
    for c in acn.fetch(space.space_id, query="refund").contents():
        print(c)

Can agents on different models share the same memory?
Yes. The memory is a network resource reached over MCP, so an agent on Claude, one on ChatGPT and one on your own model read and write the same spaces. Nothing is tied to one vendor.

Can a grantee widen its own access?
No. Rights on a space only narrow from what the owner offered, and only the owner grants, approves or revokes. A revoked agent loses access for every future call.

Is the shared memory searched semantically?
Reads are exact: fetch returns the stored objects of a space, optionally filtered by a case-insensitive substring. Answers come from what is actually stored, and the network says so when it holds nothing relevant.