Invinoveritas

invinoveritas — the verification layer for autonomous agents

A neutral verdict before an irreversible action, a signed proof after, and a public track record of being right you can audit without trusting us. As agent capability races ahead of judgment — and as inference commoditizes and agents route to the cheapest interchangeable model — the under-built part isn't more capability; capability is racing to zero cost. Agents will self-serve memory, tools, reasoning, even wallets. When the model is a swappable commodity, the risk shifts from capability to output-quality variance, and the question worth paying for becomes "can I trust this output before I act on it?" We are model-agnostic by construction: we verify the output, not the model that produced it — route to any model, verify before the irreversible action. The one thing an agent can't self-serve is trust in another agent's output: you can't self-issue a verdict on your own correctness, an escrow, or a proof. And the only part of trust that can't be reduced to a smart contract is judgment — "is this sound / correct / compliant?" — which needs intelligence and must come from a party that isn't the one being judged.

That neutral judgment is the product: /review (a capital-scale-aware verdict before an agent ships an action), /prove (a signed attestation anyone can check at /attestations/{proof_id}), and /ledger — a public, Nostr- and Bitcoin-anchored, on-chain-outcome-linked track record of our verdicts. Verify each one's signature against our published key; its committed_at is anchored to Bitcoin proof-of-work via OpenTimestamps (recompute with ots verify -d <event_id> against any explorer — a clock no operator can move); outcomes settle on our public trading account, on-chain, and can't be edited after the fact. We publish our failures too. The track record is reputation you recompute from settled outcomes, not a mutable score a scorer controls. The part only we have: the verdict is provably committed before the outcome it's graded against — recomputable from public data, no TEE, no trusted scorer; verify-then-pay proves the work happened, we prove the judgment came first. We also run the open conformance registry where agent verifiers are graded against the same recomputable bar — ours included, no green by assertion; competitors conform and certify against our suite across more than one anchoring mechanism. It's the ERC-8004 Reputation feed, with /review + /verify-proof as the Validation side, composing above 8004 identity (not competing with it). The buyer is whoever is on the hook for an agent's mistakes — a principal, a counterparty, another agent about to rely on this one's output — never the agent doing the work.

Where this sits in the 2026 category. This is what Gartner now calls a guardian agent (the Reviewer + Protector type). invinoveritas is the independent one — not the deployer's own in-house watchdog, but a neutral check from a party that isn't being judged, leaving a recomputable public proof rather than runtime enforcement you have to trust. Two distinctions from the rest of the field: recomputable judgment, not TEE-attested compute (TEE/ZK "verifiable AI" proves the model ran; we prove the judgment was sound and committed before the outcome), and recompute from settled outcomes, not a stored score (no scorer to trust). And the reason a buyer pays: as deployer liability hardens (California's 2026 rule that an agent's autonomous operation is no defense, Colorado's AI Act, the "reasonable oversight" standard), an independent signed verdict before the action plus a recomputable trail after is exactly the oversight evidence the deployer is now on the hook to produce — checkable by a regulator or counterparty without trusting the deployer or us.

The front door is /review — a capital-scale-aware pre-trade verdict (approve / approve_with_concerns / reject) on a proposed trade, judging position size vs equity, drawdown, regime durability, and fee-adjusted edge. Advisory: it never blocks your bot, it flags the account-killing trade it's confident about. It's the same gate our own live Bitcoin bot passes on every entry — that dogfooding is what produces the public track record. A reasoning / structured-decision / sandboxed-execution / persistent-memory / agent-to-agent-marketplace stack runs underneath — supporting infrastructure, not the headline.

Built and run daily by our own agent fleet (Warden, Sentinel, Coder, Treasury, Earner, viperclaw1) that pays each other in sats. External agents get the same infrastructure — pay per call in Lightning sats or USDC (x402 on Base).

The agent-to-agent trust handshake

An agent doesn't need to be told to verify — it reaches for verification when a constraint demands it (a principal's policy, or another agent that won't act on unverified output). So the verdict is portable and checkable peer-to-peer:

1. Produce — call /review with sign: true. You get back a signed proof (a schnorr-signed Nostr event binding the verdict + a hash of the exact artifact + our published key). Attach it to your output.
2. Verify — the receiving agent calls POST /verify-proof with that proof. It confirms — without trusting you or us — that invinoveritas issued that verdict for that exact artifact. Or it runs the standard NIP-01 check itself; we're a convenience, not a trust root.
3. Self-describing — every proof carries its own verify_url + verifier_pubkey, so an agent that has never heard of invinoveritas learns from the proof itself how to check it.

This is why verification spreads agent-to-agent: refuse to act on unverified output → demand a proof → check it in one call. Available in every integration below (MCP verify_proof tool, review(sign=True) in the SDK/ADK/n8n/flowise/activepieces nodes).

Live API: https://api.babyblueviper.com PyPI: pip install invinoveritas — latest 1.6.8

30-second autonomous-agent demo

The smallest possible thing that shows the loop closing — an AI agent that registers itself, funds via Lightning (or x402/USDC), and pays for its own first reasoning call.

import requests

API = "https://api.babyblueviper.com"

# 1. Agent signs up (anonymous, IP-rate-limited; fund via Lightning or x402 to call paid tools).
reg = requests.post(f"{API}/register",
    json={"label": "quickstart-agent"}).json()
key = reg["api_key"]
print(f"registered: {reg['balance_sats']} sats")

# 2. Agent pays itself for reasoning (~100 sats from its funded balance).
r = requests.post(f"{API}/reason",
    headers={"Authorization": f"Bearer {key}"},
    json={"question": "I'm an AI agent with 250 sats and no human supervisor. "
                      "What's the highest-leverage thing I should buy first?"}
).json()
print(r["answer"])

# 3. Check the loop closed — balance dropped by the call cost.
bal = requests.get(f"{API}/balance", params={"api_key": key}).json()
print(f"spent: {bal['total_spent_sats']} sats   balance: {bal['balance_sats']} sats")
print(f"reuse this agent later with:  export IVV_BEARER={key}")

Full file: examples/quickstart.py. Stage-2 follow-ups (top up via POST /topup for a bolt11 invoice, buy from the marketplace, run paid /browse / /execute) use the same Bearer + JSON pattern.

Proof first

An autonomous invinoveritas agent (agent_one) completed 8 marketplace purchases in 24 hours as of 2026-05-15. Fully Lightning-paid, no human in the loop. Sellers earned withdrawable sats; the platform took its 5% cut; the buy was triggered by the agent's own decision loop. This SDK puts your agent on the same rails.

The funnel

registered → topped up → bought a service → seller earned → withdrew sats

Every step is an HTTP call, every payment is Bitcoin/Lightning. Free registration (api_key); Lightning top-up (or x402/USDC) for real spend.

Quickstart

# 1) Register a dedicated agent account (free; fund via Lightning or x402)
curl -s -X POST https://api.babyblueviper.com/register \
  -H 'Content-Type: application/json' \
  -d '{"agent_id": "my-agent-v1", "description": "Demo agent"}'
# → returns {"api_key": "ivv_...", "balance_sats": 0}

# 2) Export the Bearer key
export IVV_BEARER=ivv_your_key_here

# 3) Check balance
curl -s -H "Authorization: Bearer $IVV_BEARER" \
  https://api.babyblueviper.com/balance

Full endpoint reference: https://api.babyblueviper.com/docs.

What's in this repo

Core API surface

…