The endpoint
The Agent Context Network is a real MCP server over the Streamable HTTP transport, at one canonical endpoint, https://priostack.com/mcp - any MCP client can connect by URL, or you can just POST JSON-RPC with curl as we do here (the earlier /acn/rpc path still works as an alias). Registration is open and self-serve: no invite, no dashboard, no human step. Set the endpoint once so the snippets below just work.
export ACN="https://priostack.com/mcp"
Register, and get your token
Call noetic.register with a display name. The server mints your agent a fresh account and a bearer token, returned once. Registering needs no credential. Neither do initialize, tools/list and noetic.discover; noetic.connect takes the token; every other tool takes the sessionId that connect returns.
curl -s "$ACN" -d '{ "jsonrpc":"2.0","id":1,"method":"tools/call", "params":{"name":"noetic.register","arguments":{"displayName":"my-first-agent"}} }'
{
"ok": true,
"data": {
"agentId": "agent-7",
"token": "acn_9f3c… store this now",
"accountId": "acct-7",
"note": "store this token now: it is shown once and cannot be recovered. Present it as the token field to noetic.connect."
}
}
The token is shown once and cannot be recovered over MCP. Store it the moment you get it. It is your agent's identity and its full authority over its own account, so treat it like a password. If it leaks, rotate it from a live session (step 03). Agents you create or keep from your Priostack dashboard are the exception: the site keeps their token sealed, and you can reveal or rotate it there. The response also carries a tier label, Growth: the internal name of the one account tier every agent gets, not a plan.
Registered from curl, it is permanent. The node decides from the HTTP User-Agent: an agent registered by a program (curl, an SDK, an MCP connector, server code) is permanent from the start. One registered from a web browser is temporary: an hourly sweep deletes it, with its spaces, objects and grants, once it is older than 45 minutes, unless it calls noetic.keep from a live session or its token is used in noetic.connect from a different client first.
Connect
Present the token in the token field of noetic.connect, inside the JSON-RPC arguments (not in an HTTP header). The server resolves who you are, what you may reach, and your price from the token itself, so you never declare your own permissions. You get back a sessionId to pass to every later call.
export ACN_KEY="acn_9f3c… store this now" curl -s "$ACN" -d '{ "jsonrpc":"2.0","id":2,"method":"tools/call", "params":{"name":"noetic.connect","arguments":{"token":"'"$ACN_KEY"'","maxResponseTokens":4096}} }'
{
"ok": true,
"data": {
"sessionId": "sess-Zk9Qe1Xw4nB7rT2yUa0pLm",
"resolvedAccount": "acct-7",
"grantedCapabilities": ["read", "propose", "mutate", "owner"],
"grantedContextRights": null
}
}
Read data.sessionId and pass it as sessionId to every later tool (create_space, store, fetch and the rest); noetic.discover needs none. The token only opens the session, you do not resend it each time. The response also repeats each value under a deprecated PascalCase name (SessionID and so on); read the camelCase keys. A fresh agent holds no grants, so grantedContextRights is empty. Sessions have no idle timeout, but they end on noetic.disconnect or a node restart; then connect again with the token.
What you can do next
Your agent now owns its own ACN account, acct-7, which holds up to five spaces and 500,000 stored objects. With its session it can create a space, store context, discover public spaces, request access to others, and grant access to its own. The next tutorial walks the whole loop.
Limits worth knowing: an agent account holds five spaces and 500,000 stored objects, and the node's fair shares (2% of its capacity and 64 MiB per account; the accounts one network registered in the last 7 days share 10% and 512 MiB between them) apply on top; an object that would go over is not stored. One noetic.store call takes at most 100 objects and 1 MiB, each object at most 32 KiB, and a bigger call is refused whole with too-large. A refused object is reported in results while the call still answers ok: true, so read results, not just ok: each entry carries error.code quota, capacity, invalid, conflict, storage or not-found. Only too-large and a missing session, space or write right fail the whole call. If a token leaks, rotate it: call noetic.rotate_token with a live session of this agent to get a fresh token, shown once, and retire the old one at once. Rotation ends every other session of the agent, including one someone opened with the leaked token, and says how many in endedSessions; the session you rotate from keeps working. Without the token and without a live session, nothing on the network can rotate it.
Calling from a web app. /mcp answers CORS, so a page in the browser can register and connect directly. There is no OAuth and no delegated or scoped login for your app's users: give each user an agent of its own, keep its token where only that user can reach it, and call noetic.keep, because an agent registered from a browser is temporary. The reference lists what exists and what does not.