There is a question that quietly sits underneath every agent that does real work. When an agent moves money, changes a record, or acts on someone's behalf, who is actually accountable. Vorim has always answered half of that. We prove which specific agent took the action and whether it was allowed to. But there is a second half we could never answer on our own, and it turns out to be the half that a bank or a hospital cares about most. Is there a real person behind this agent, and are they someone you can trust.
An agent identity tells you the machine acted. It does not tell you a genuine human stands behind it rather than a script someone spun up an hour ago. For a lot of use cases that gap is the whole risk. If an agent is about to approve a payout or act on a customer's account, "an agent did this" is not enough. You want to be able to say a verified person, working through this agent, did this.
That is why we built an integration with TruAnon.
What TruAnon does, in plain terms
TruAnon anchors a real human to their account by tying them to the connections other people already know them by, without collecting or storing identity documents. Instead of a passport scan sitting in a database somewhere, you get a signal that a real, established person is who they say they are. TruAnon returns a rank for that person, from Genuine and Reliable at the strong end, down through Credible and Cautioned, to Dangerous, with Unknown for anyone who has not anchored at all. It also returns a score from zero to five.
So TruAnon proves the human. Vorim proves the agent. Neither one is complete on its own, and together they close the loop.
How the integration works
The integration lives in both our SDKs, TypeScript and Python. You set a minimum human rank you are willing to accept, for example Credible, which is roughly the bar you would expect from an identity check. Then, before an agent does something that matters, you make one call.
That call does two things at once. It checks that the human behind the request meets the rank you required, and it checks that the acting agent is itself authorized, active, and above your trust threshold. Only if both are true does the action go ahead. And when it does, Vorim writes a single signed record that captures both identities in one line, the human and the agent, so afterward you can show exactly who was behind what.
A few details that matter. The TruAnon private key stays on your server and is never exposed to the browser. An Unknown rank never clears a minimum, so the safe default is always to deny. If in doubt, nothing happens. That is the posture you want when the downside is a real action taken on someone's behalf.
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',
});
// 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
}Why one signed record with both identities matters
The point is not just to check a box before an action. It is what you can prove afterward. Most systems can, at best, tell you an agent did something. A smaller number can tell you which agent. Almost none can hand you a single, tamper evident record that says a verified person, through this specific agent, took this action, on this authority, at this time.
That is the record an auditor actually wants. It is also the record that makes an agent safe to put near something that matters, because the accountability does not stop at the machine. It runs all the way back to a real person.
Where this fits
Vorim is the trust layer for AI agents. Identity, permissions, signed audit. TruAnon is the human anchor. The integration is a clean example of what we mean when we say Vorim sits underneath the things you already use rather than replacing them. Keep your agents, your stack, your identity provider. Add the layer that binds a verified human to an identified agent and signs the two together.
It is live now 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 human is behind the agent. You can see it on our integrations page under Human Identity, or reach us at team@vorim.ai.
Ready to build with agent identity?
Free plan: 10 agents, 10K auth events/month, full SDK access. No credit card.