PoHI for Autonomous Finance
When agents can move money, authentication is not enough. PoHI makes human authority a cryptographic primitive: atomic, auditable, enforceable.
Autonomy meets irreversibility
Crypto actions are global and final. Agents multiply execution speed and frequency. The result is a structural gap between identity and authority.
Delegated agents execute continuously. Humans cannot review every action, especially under market pressure and high-throughput conditions.
Today’s flows confirm a session or a device, but rarely produce a cryptographic proof that a specific human intended a specific action at the final boundary.
Multiple systems and time steps introduce UI deception, session abuse, policy drift, and ambiguous audit trails across vendors and components.
Bundle vs primitive
Modern systems approximate intent by stacking signals. PoHI collapses authentication, confirmation, and authorization into a single atomic cryptographic act.
- MFA / 2FA + confirmation screens + policy engines
- Multiple trust boundaries and timestamps
- Non-atomic, integration seams, replay and race exposure
- Audit trails are fragmented across systems
- One act → one proof → one enforcement point
- Cryptographically binds human + action + constraints + time
- Atomic: either proof exists or execution is blocked
- Simplifies backend heterogeneity and reduces attack surface
How it works
A simple pre-execution gate for high-risk actions, compatible with agent kits, smart accounts, and programmable money.
Integrations
Fit existing stacks with minimal disruption: add a pre-execution PoHI gate to the actions that matter.
PoHI becomes the approval gate for high-risk tools. Agents can operate autonomously within pre-approved constraints, and stop automatically outside the boundary.
Attach PoHI proofs to critical operations: transfers, approvals, policy changes, withdrawals, and session delegation. Verification happens at the final execution point.
Bind human authority to freeze/unfreeze, overrides, recalls, and emergency actions with verifiable mandates and auditable delegation constraints.
Use cases
PoHI is designed for high-impact actions: when a mistake, compromise, or agent overreach becomes immediate loss or liability.
- Agent trading with bounded authority and hard stops
- Human-approved withdrawals and whitelist changes
- Session delegation with explicit limits and expiry
- Authorized freeze/unfreeze and emergency overrides
- Mandates and delegation for compliance operators
- Audit-grade proof of legitimacy for sensitive actions
- Standard authority primitive for agentic applications
- Governance legitimacy for emergency controls
- Composable “intent receipt” for critical state changes
Security posture
Atomicity simplifies the system. Simplification reduces failure modes, integration seams, and attack surface.
- Single enforcement point instead of multi-step flows
- Less state to exploit: fewer sessions, fewer transitions
- Less vendor and component heterogeneity in the approval path
- Clear, verifiable artifact for audits and incident response
PoHI is designed to be checked at the final boundary before execution, where authority must be strongest and most explicit.
Roadmap for a pilot
A lightweight, practical path: prove value on 1–2 high-risk actions, then expand to delegation and policy templates.
Add a PoHI gate to one irreversible action (withdrawal, transfer, trade execution, freeze/override).
Introduce delegation constraints: scope, limits, time windows, tool permissions, thresholds.
Standardize an audit-ready “intent receipt” format for internal review and reporting workflows.
Start with a focused integration
We can scope a pilot around a small number of high-risk actions and ship an end-to-end PoHI proof and verifier path with minimal disruption to your stack.
- PoHI gate for one high-risk action
- Verifier integration at the final boundary
- Initial policy template (constraints, limits, time)
- Audit-grade proof artifact