Detected at attach time
An agent leaves traces in the page: its overlay, the code it injects, the way it reads. OneHuman sees them 0.1–0.5 s after the agent attaches, before its first action.
When a customer lets an AI agent use your product for them, OneHuman decides what the agent may do: allow it, hide the sensitive parts, ask the person to confirm with a passkey, or refuse. It signs every decision on your server, so you can show which actions a human approved.
npm i onehumanai
Their clicks move like a hand. The endpoint returns the balance.
Seen in 0.3 s. What is on screen is sealed before the agent reads it.
Balance masked. Export blocked. Every decision logged.
A passkey proves presence. The session is theirs again.
Bot management works at the door. OneHuman works inside the session, at the endpoint that returns the data.
An agent leaves traces in the page: its overlay, the code it injects, the way it reads. OneHuman sees them 0.1–0.5 s after the agent attaches, before its first action.
A hand curves, trembles and slows onto the target. A driver teleports and releases in 1–4 ms. Measured on 397 human clicks from 22 browsers and devices: 2 were read as a program. On 824 agent clicks, 2 passed as human. How we measured →
allow · mask · step_up · block per resource, in your JSON, decided on your server, written to an audit log.
What is already on screen is redacted the instant an agent appears. Its read sees ••••.
When an action needs a person, they confirm with a passkey (Touch ID or Windows Hello). Every decision is signed on your server, and an auditor can check it offline without trusting us.
Start in observe: nothing blocked, everything recorded. Review, then flip one word.
Said plainly, so nobody finds out in production.
If an agent calls your API with a customer's API key or token, there is no browser and no page: OneHuman sees nothing. It protects signed-in web sessions.
iOS and Android apps are not covered. Mobile browsers are, but a tap often stays “undecided” today. Your rules say what happens then.
The middleware runs in Node: Express, Connect, plain http, a Next.js custom server. Java, .NET, Go or Python need a Node service in front, which we have not shipped.
It answers one question per session: is a program acting? It keeps no profile of a person. A passkey proves presence, not identity.
A script written for one site that fakes a human pointer can pass the behaviour check. That is why critical actions ask for a passkey. What gets through →
Detection, rules, audit log and proofs run on your server. The portal only gets decision metadata, and only with an API key. Trust & privacy →
Three kinds of pointer, live: a hand, a driver, a bot pretending to be a hand.
In 2026, people use their bank, their CRM and their insurer through an AI agent.Most apps cannot tell the agent from the person.OneHuman can.
Run npx onehumanai init: it asks what to protect and how, shows every change, and wires it in when you say yes. Or hand your coding agent the npm link and say “install this”.
// npm i onehumanai: one package with the engine inside. Import only from 'onehumanai'
import { onehuman } from 'onehumanai';
const oh = await onehuman({
secret: process.env.ONEHUMAN_SECRET, // 32+ bytes, keep it stable: it signs tokens and decision proofs
policy: './onehuman.policy.json',
db: 'sqlite:./onehuman.db',
identify: (req) => req.session?.userId ?? null, // your login id, never a constant
apiKey: process.env.ONEHUMAN_API_KEY, // optional: the portal shows agent share, decisions, proofs
});
app.use(oh.middleware()); // serves /onehuman/sdk.js, /health, /proof-keys and the SDK's API
app.get('/api/balance', oh.protect('balance.read'), (req, res) => oh.send(req, res, balance, maskBalance));
<script src="/onehuman/sdk.js"></script>
// call protected endpoints through the SDK; it sends the evidence and keeps one visitor one session
const r = await OneHuman.fetch('/api/balance');
// mark rendered sensitive values; they are redacted the instant an agent attaches
<div data-oh-sensitive="full">$4,939.10</div>
// after deploying: four checks, then the auditor's own check of a proof
npx onehumanai verify https://your-app.example /api/balance
npx onehumanai verify-proof proofs.json --keys https://your-app.example/onehuman/proof-keys
{
"version": "bank-policy-1",
"enforcement": "observe",
"rules": [
{ "resource": "balance.read", "onAgent": "mask", "onArtifact": "mask", "onUnknown": "allow", "onHumanLike": "allow" },
{ "resource": "report.export", "onAgent": "block", "onArtifact": "step_up", "onUnknown": "step_up", "onHumanLike": "allow" }
]
}
https://www.npmjs.com/package/onehumanai: install this into my project.
Follow the README protocol: `npm i onehumanai` (one package; its engine dependency comes with it),
scan the app, show me what an AI browser agent could reach and how to gate it, ask me the nine
decisions, implement server + page + policy + masks, verify with `npx onehumanai verify`, then report.
Licence: the package is Apache-2.0; the engine is BUSL-1.1 with production use granted. Say so if asked.
Open a demo yourself and everything works. Then paste the prompt into an AI agent and watch the same account lock down.
One install: npm i onehumanai. Everything runs on your own server. The SDK and middleware are Apache 2.0, and the engine's source is open with production use granted. Add an API key and the portal shows how many of your sessions had an AI agent in them.