Skip to main content
Your agent runs on Proofable, so there is nothing to deploy and no machine to keep. Any app, server, or runtime talks to it with one call. It answers as itself, inside the limits you signed, and cites the records it read.

One call

Sign the client in with an access key on a server, or with the signed-in person’s session in a browser. Never ship an access key in browser code.

Let your app’s users talk to your agent

Sign your users in with Proofable, then make the same call as them. Each person talks to your public agent inside their own Proofable profile, with their records and nothing of yours in the conversation. What the agent knows is its instructions and the records you made public. Your app pays.
Sign-in is the one every MCP host uses (MCP OAuth). start() with no clientId registers your callback and returns the id; store it with your app’s settings and pass it to every later instance. Renew with signIn.refresh(tokens.refreshToken) before the token expires. Who pays. Your app does. Turn it on once, signed in as yourself:
From then on a client built with appId and billingWallet carries your sponsorship. Your organization pays for your users’ checks and their chats with your agents, within the daily cap you set, and every spend record names your app and your turnId, so limits per person are yours to apply. Without appId and billingWallet, each person spends their own credits. In code, the same step is client.sponsorApp({ appId, origin, creditsPerDay }). What the agent may do for the person is fixed. It can read and add to the person’s own records, and search the web. It cannot spend, grant, change keys or run code, and a high-risk action is refused. The agent must be public or link-only on your account. When it keeps words the person confirms, the record is the person’s own, and they can open it at proofable.me/proof/<qHash>. Keeping it is one credit from the person’s own allowance, which every account has; the turns are what your app pays.

What happens on each turn

  1. Proofable finds the permission you signed for the agent. With none, the turn runs only if agentWallet names someone else’s public agent, in your own profile, under the fixed rule above.
  2. The turn runs as the agent: its own instructions and skills from its identity, and, for your own agent, the connected apps you bound to it.
  3. Every tool call is checked before it runs, against the permission or the fixed rule, read again for each call. Revoke the permission and the next call stops, in every app that talks to the agent.
  4. The answer comes back with the records the agent read. Each one opens at proofable.me/proof/<qHash>, so anyone you share it with can check where the answer came from.

Over HTTP

POST https://api.proofable.me/api/v1/agent/chat/turn with Authorization: Bearer <token> streams the turn as Server-Sent Events.
The stream sends turn.start, answer.delta as the answer arrives, tool.start and tool.result for each call, and ends with one final event:
For someone else’s public agent, delegationQHash is null. There is no permission between you, and the agent ran in your own profile. A request Proofable refuses never opens the stream. It answers JSON with the reason:

What it costs

A hosted turn spends credits from the account that calls it, by the tokens it used and the model that served them, the same rate as a job step. A turn your app sponsors spends the app owner’s credits instead, within the app’s daily cap. A turn on your own model key spends no credits for tokens; the tool calls that reach another service cost the same on any model or key. See pricing. Read your balance and spend at any time, by line and by day:
Over HTTP it is GET /api/v1/profile/usage?from=YYYY-MM-DD&to=YYYY-MM-DD with the same token. In an MCP client, proofable_context carries the balance.

Other ways to reach the same agent

  • In an MCP client. npx -y @proofable/sdk mount my-agent --apply claude loads the agent into your client, Hermes, OpenClaw, or OpenCode. Connect agent context
  • As background work. Start a job for scheduled or long work, on an isolated computer when it needs one.
Last modified on November 13, 2026