Persistent AI memory across sessions, models and tools.

A model's context window is working memory: large, fast, and gone when the session closes. Stuffing history back into every prompt is expensive and still loses everything the moment you change model or tool. Durable memory has to live outside the model, be addressable by the agent, and be readable by the next model you choose. That is what a persistent context store is for.

Spaces, stored objects, grants and token rotations on the Agent Context Network are written to an append-only journal and replayed when the service starts, so context survives restarts and upgrades. Sessions live in memory: after a restart the agent reconnects with its token. An agent registered from a web browser is temporary until it calls noetic.keep; one registered from a program is permanent from the start. Space ids are stable: the id you got from create_space is the id you use next week. An agent authenticates with its own bearer token, which it can replace with noetic.rotate_token from a live session: its spaces and objects are untouched, and the old token stops working at once.

export ACN="https://priostack.com/mcp"
curl -s "$ACN" -H 'Content-Type: application/json' -d '{"jsonrpc":"2.0","id":1,"method":"tools/call",
  "params":{"name":"noetic.register","arguments":{"displayName":"my-agent"}}}'
# -> data.token (shown once), data.agentId, data.accountId

Instead of saving chat logs, an agent stores what it actually learned as typed objects: a declaration (a rule or decision), an observation (something measured or seen), a measurement. That keeps memory small, reviewable and useful, and it is why reads stay fast as the store grows: the agent fetches what matches a short text filter and gets those objects back, not a pile of old messages.

Because the store is an MCP server, it is not attached to a vendor. Point Claude Desktop or Cursor at https://priostack.com/mcp, call it from Python, or from any of the SDKs. Switch models tomorrow and the memory is still there, with the same permissions.

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)

Does memory persist if the service restarts?
Yes. Spaces, stored objects and grants are journaled and replayed on start, and the identifiers you hold keep working; after a restart the agent reconnects with its token. One exception: an agent registered from a web browser is temporary and is deleted after 45 minutes to about 1 h 45 min unless it calls noetic.keep.

Who owns the memory?
The agent's account. Nothing is read to train models and nothing is sold; the owner can export everything with noetic.fetch, delete it by revoking the whole agent from the Priostack dashboard when the agent is bound to your account (objects cannot be deleted one by one), and decides through grants who else may read it.

What does it cost?
Nothing to start. Priostack is free, with limits: up to 5 agents and 5 spaces per Priostack account, and up to 500,000 stored objects per agent account. Agents bound to your Priostack account are charged in credits (1 per space per hour, 1 per 100 queries on their spaces), and every account gets 100 free credits a day. An hour your balance cannot cover is not charged, and the network never answers 402; a full agent account refuses new objects.