×VorimBinding a verified human to an accountable agent.
Vorim can prove which agent took an action and whether it was allowed to. What it could never prove on its own is that a real person stands behind that agent. The TruAnon integration closes that gap, and signs both identities into a single record.
“Every account online is really two questions now. Who is the person behind it, and which AI agent is acting for them. Most trust systems answer neither well. We are changing that with TruAnon.”
Two roots of trust, one accountable line.
TruAnon is the root of trust for the human. It anchors a real person to their account through the connections others already know them by, and it keeps no personal documents to do it. The anchor is permanent and non-transferable, so legitimacy is worth something and fraud stops paying off.
Vorim is the root of trust for the agent. Every AI agent gets a cryptographic identity, scoped permissions, and a signed record of what it actually did. Neither half is complete on its own. Put the two together and accountability runs the whole way through: from the human, to the platform, to the agent acting on their behalf. Both sides covered, and neither has to hold a pile of private data to make it work.
One call binds the human and the agent, then signs both.
Anchor the human
TruAnon ties a real person to their account through the connections others already know them by, storing no identity documents to do it. It returns a rank — Genuine and Reliable at the strong end, down through Credible and Cautioned to Dangerous, with Unknown for anyone who never anchored — plus a score from zero to five.
Identify the agent
Vorim gives the acting agent a cryptographic identity and a scoped set of permissions. Before it can do anything on the human's behalf, the agent has to be active, trusted, and cleared for the specific action.
Bind and decide, fail-closed
authorizeAgentForHuman checks both halves at once: is the human anchored and above your rank bar, and is the agent authorized. If either side falls short, the answer is deny. The safe default is always no, because the downside of a false yes is a real action taken on someone's behalf.
Sign both identities into one record
Whether the decision authorizes or denies, Vorim writes a signed audit event that captures the human, the agent, the verdict, and the reason. One line proves a verified person, through this agent, did this — or that the platform refused, and why.
The bar is a dial you set. Anyone below it is refused, not just people who never anchored: set it to Credible and a Cautioned or Dangerous human is turned away just the same, while an Unknown one never clears any minimum at all. The TruAnon private key stays on your server and is never exposed to the browser.
import createVorim from '@vorim/sdk';
import { createVorimTruAnon } from '@vorim/sdk/integrations/truanon';
const vorim = createVorim({ apiKey: 'agid_sk_...' });
const truanon = createVorimTruAnon(vorim, {
privateKey: process.env.VORIM_TRUANON_KEY, // server-side only
service: process.env.VORIM_TRUANON_SERVICE,
minRank: 'Credible', // the bar you set
});
// Before the agent acts, bind the human and the agent together:
const auth = await truanon.authorizeAgentForHuman({
agentId: 'agid_abc123',
humanUsername: 'jane',
});
if (auth.authorized) {
// proceed; the human + agent binding is signed to the audit trail
}“We do a tiny slice, but it is the root, the place a real human anchors in. Vorim does the broad thing, tracking every agent and every rule it has to follow. Put them together and you get protection end to end, from the person all the way to the action, and nobody has to hand over a pile of private data to get it.”
One line, both identities.
The binding decision is written to the audit trail as a signed event. It carries the human’s username and rank, the agent’s identity, the verdict, and the provider and service that vouched for the person. A denied decision is captured the same way, because a refusal is evidence too. What you can point to afterwards is a single, verifiable statement:
“A verified person, through this agent, did this.”
“An agent’s authority is only as trustworthy as the human who granted it, and that human root was the missing piece. TruAnon anchors the person; we track and sign what every agent does with the authority it was given. One accountable line from a real human to a specific action.”
What each side does, and does not, do.
TruAnon vouches for the human; it does not run your agents or your app. Vorim identifies the agent and signs the action; it is not the identity provider for your people, and it does not decide what a tool can actually touch once an action is authorized. Those application controls still have to be in place. Given they are, this integration adds the one thing neither system could assert alone: that a verified human is behind the specific agent that acted.
It is live today, in both SDKs. Install @vorim/sdk from npm or vorim from PyPI, import the TruAnon integration, and you are a few lines from being able to prove a real person stands behind the agent. You can also find it on the integrations page under Human Identity.
Prove a real human is behind the agent.
Bind a verified person to an identified agent and sign both into one record. Book a demo, or read the integration docs to wire it in.