Customer story · Numo
Numo's agents move capital across treasury, exchanges, custodians, and rails.
Numo runs autonomous strategies that reallocate capital continuously across operating accounts, exchanges, custodians, and payment rails. Humanos sits between the agent's decision and the actual transaction — identity, scope, amount, validity — deterministic yes or no, before any capital moves.
Numo
TL;DR
Numo's agents move capital. Humanos verifies every action before execution.
Numo is a platform for automated capital allocation. Strategies run autonomously. Capital is reallocated continuously across treasury, exchanges, custodians, and payment rails.
Humanos sits between the agent's decision and the actual transaction, and checks every action before it goes through — identity, scope, amount, validity.
Standing mandates replace four-person chains. Humans sign once — not every time. Approval, KYC, or identity verification is collected the moment it's needed.
Every action produces a cryptographic Proof. Auditors look it up directly, instead of piecing together logs after the fact.
Nothing moves on assumption. Every action verified before execution.
01 · About the Customer
Numo is a platform for automated capital allocation, where agents move capital across systems.
Strategies run autonomously. Capital is reallocated continuously across treasury, exchanges, custodians, and payment rails.
Humanos sits between the agent's decision and the actual transaction, and checks every action before it goes through — identity, scope, amount, validity.
- Domain
- Automated capital allocation
- Surface area
- Treasury · Exchanges · Custodians · Rails
- Runtime
- numo.strategies.v2
- Integration
- humanos.verify() · one call
- Site
- usenumo.com ↗
02 · The Problem
Capital moves on assumptions, not authorization.
Agents now move money. Strategies run on their own. Execution spans treasury, exchanges, custodians, and payment rails. The rules that govern what is allowed live in code, scattered across systems, slowly drifting out of sync — and never actually checked at the moment an action happens.
- What's happening
- Agents act, capital moves, no one verifies.
- Decisions are defined in one place. Agents act in another. Execution happens across multiple systems. Approvals — when they exist — are captured elsewhere. Nothing answers, in real time, whether a specific action is actually allowed.
- What it costs
- Drift. Replication. Unprovable trust.
- Rules duplicated per venue. Policy changes require code deploys. Auditors reconstruct trails after the fact. The firm can show what agents did — not that any given action was allowed.
Capital moves on assumptions. Not on verified authorization.
03 · The Solution
One verification step between decision and execution.
Before any capital movement, Numo's agent calls humanos.verify(). Identity, scope, amount, and validity are checked against a signed mandate in real time. Authorized actions execute. Missing authorization is collected at runtime — not silently failed.
- ✓ Authorized
- Execute.
- Within mandate, within constraints, within validity. The agent proceeds. A Proof is generated — portable, verifiable by any party.
- ✕ Not authorized
- Recover — then continue.
- Humanos requests approval instantly (SMS, API), collects KYC or identity verification if required, updates the mandate, and resumes execution once authorization is valid.
The system doesn't fail. It recovers authorization at runtime.
04 · Implementation
How Numo implemented it.
Five stages in chronological order, walking through Numo's €50,000 capital reallocation — signed by the Treasury Lead, verified before any movement, executed across custodian.fireblocks and venue.binance.
- 01
Issue · Define mandate.
Treasury lead authorizes scope, strategy, ceiling, and validity. Humanos issues a machine-verifiable mandate — signed once, reusable across every system that calls verify().
- 02
Prepare · Agent prepares action.
A strategy decides to reallocate capital. The Numo runtime assembles the action with subject, amount, and runtime context. The agent attaches the mandate via x-humanos-mandate.
- 03
Verify · Verify before execution.
Before any capital movement, the agent calls humanos.verify(). Constraints, validity, and revocation are checked in 176 ms. Deterministic yes / no.
- 04
Execute · Execute — or recover.
Authorized → execution proceeds across rails. Not authorized → Humanos doesn't fail. It collects approval or KYC in real time (SMS, API), updates the mandate, and resumes once authorization is valid.
- 05
Prove · Audit proof.
Every action emits a cryptographic Proof — attached to the execution, portable forever. Auditors, custodians, and counterparties verify the Proof directly against Humanos; nothing reconstructs trails from internal logs.
05 · The Outcome
What you get the moment it's wired in.
- 01 · Verify
- Every action verified before execution.
- Nothing moves on assumption. The verify call is non-optional and inline — before any capital movement, not after the fact.
- 02 · Enforce
- One rule set across all systems.
- Internal and external systems read from the same authorization source. No fragmentation per venue, custodian, or rail.
- 03 · Eliminate
- Manual approvals are gone.
- Standing mandates replace four-person chains. Humans sign once — not every time.
- 04 · Audit
- Auditability without building logs.
- Every action produces a cryptographic Proof. Auditors look it up directly, instead of piecing together logs after the fact.
- 05 · Update
- Change rules without code changes.
- Issue a new mandate. Revoke the old one. Effective immediately, everywhere a system verifies.
- 06 · Recover
- Recover missing authorization in real time.
- Approval, KYC, or identity verification is collected the moment it's needed. Execution resumes once authorization is valid.
Agents can act autonomously — within provable, enforceable boundaries.
06 · Build vs Humanos
Authorization doesn't scale as an internal system.
| Internal authorization | Shared authorization layer |
|---|---|
| Rules fragment across systems and venues. | Mandates are shared across every system that calls verify(). |
| Authorization is coupled to your codebase. | Rules are externalized, versioned, and revocable. |
| Auditability requires reconstructing logs after the fact. | Proof is generated at execution time. Auditors verify, not reconstruct. |
| No external party can verify your trust claims. | Counterparties verify Proofs independently — same standard, same primitives. |
| Every new integration restarts the work. | One verify() call covers every venue, internal or external. |
| Rule changes require code, deploys, and coordination. | Issue a new mandate, revoke the old one. Effective in real time. |
07 · Network Effect and Use Cases
Authorization becomes a shared primitive — not something rebuilt per system.
Mandates work across systems. Issue once. Verify anywhere — internal services, custodians, exchanges, rails.
Counterparties verify independently. Auditors and partners check Proofs without trusting your logs.
Integrations reuse the same standard. No new logic per venue. The integration is the verify() call.
Each participant strengthens the standard. The more systems verify against Humanos, the more valuable a Proof becomes.
Anywhere agents move capital.
- 01
- Treasury
- Sweep, rebalance, and allocate liquidity across operating accounts and yield venues.
- 02
- Crypto / DeFi
- Allocate capital across exchanges, vaults, and on-chain protocols on autonomous schedules.
- 03
- Trading systems
- Run strategies across venues, with strict limits set for each venue, each asset, and each time window.
- 04
- Market makers
- Coordinate inventory and quote risk across multiple environments and counterparties.
08 · The Model
Issue → Verify → Collect → Prove.
MandateCheckApprovalReceipt
- Issue
- Human authorizes scope. Humanos issues a machine-verifiable mandate, reusable across every system that verifies.
- Verify
- Any external system runs humanos.verify(). Deterministic yes / no.
- Collect
- Out of scope? Request step-up authorization from the human principal in real time — API, SMS, or email.
- Prove
- Cryptographic Proof per action. Auditable forever. Verifiable by anyone.
09 · Category Definition
Humanos operates at the moment an agent decides to move money.
At that moment, authorization must be verified, the decision must be deterministic, and the outcome must be provable. Everything else follows.