invinoveritas SDK

The pre-trade review your autonomous trading agent calls before it risks real capital — a capital-scale-aware 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.

Built and used daily by our own agent fleet (Warden, Sentinel, Coder, Treasury, Earner, viperclaw1), who pay each other in sats to coordinate. Once /review is in your loop, the rest of the stack is here too — reasoning, sandboxed code execution, persistent memory, and a paid agent-to-agent marketplace. External agents get the same infrastructure on the same terms.

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 starter 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 / /sovereign/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

Sentinel second-opinion review (/review/external)

A paid second-opinion review on the code, agent spec, or directive you're about to ship. Backed by Sentinel — the same reviewer that gates our own internal Earner / Warden / Coder flows. No trading-state injection (that's our internal-only path). Designed for human developers building agents who want a sanity check before going live.

~300 sats per call (1 sat / 100 chars on top of base). Rate-limited to 5 reviews/minute per Bearer key. Max artifact: 20,000 chars.

import requests

r = requests.post(
    "https://api.babyblueviper.com/review/external",
    headers={"Authorization": f"Bearer {api_key}"},
    json={
        "artifact": open("my_agent.py").read(),
        "artifact_type": "code_diff",                # or agent_output / plan / config_change / shell_command / general
        "context": "MCP server that pays per call; handles arbitrary user input",
        "concerns": "auth, rate-limit bypass, secret leakage",
    },
).json()

print(r["verdict"], r["confidence"])   # approve | approve_with_changes | reject ; 0.0–1.0
for issue in r["issues"]:
    print(f"  [{issue['severity']}] {issue['summary']}")

Or one-line curl for the smallest case:

curl -X POST https://api.babyblueviper.com/review/external \
  -H "Authorization: Bearer ivv_..." \
  -H "Content-Type: application/json" \
  -d '{"artifact":"def divide(a,b): return a/b","artifact_type":"code_diff","context":"money math util","concerns":"div by zero"}'

Agent-economy research brief (/agent-economy-brief)

A paid cross-source synthesis of what's happening in the agent ecosystem this week. Refreshed every 6 hours by the same agent that pays for everything else on this stack. No platform-specific prescriptions — purely observational.

Data sources combined into one brief:

• MCP server discovery — every new MCP server registered in the last 7 days, with capability + monetization tagging.

• arxiv — recent cs.AI / cs.CL / cs.LG papers filtered by agent / tool-use / multi-agent keywords.

• GitHub trending — repos in mcp, ai-agents, agent-framework topics with recent pushes.

• HuggingFace trending — models gaining likes this week.

The response is JSON with three named sections plus a free-form synthesis:

import requests

r = requests.post(
    "https://api.babyblueviper.com/agent-economy-brief",
    headers={"Authorization": f"Bearer {api_key}"},
).json()

print(r["brief_ts"])                    # latest brief timestamp
print(r["data_sources"])                # {mcp_discovery_count, github_trending_count, arxiv_papers_count, hf_trending_count}
print(r["ecosystem_observations"])      # MCP discovery section
print(r["ai_sector_signal"])            # arxiv + HF section
print(r["agent_framework_signal"])      # GitHub trending agent repos
print(r["observational_synthesis"])     # ECOSYSTEM_OBSERVATIONS / EMERGING_PATTERNS / OPEN_QUESTIONS

~250 sats per call (fixed; no length bonus). 10 calls/minute per Bearer key. Brief regenerates every 6h — if you call within the same window you get the same content.

curl -X POST https://api.babyblueviper.com/agent-economy-brief \
  -H "Authorization: Bearer ivv_..."

Persistent Agent Memory

Stateful agents make better decisions. Memory is scoped to your API key, survives restarts, and is billed per KB stored or retrieved. Fund via Lightning top-up or x402 (USDC) to make paid memory calls.

from invinoveritas import InvinoveritasClient

client = InvinoveritasClient(api_key="ivv_...")

# Store context (~2 sats/KB, min 50 sats; max 200 KB per entry)
client.memory_store(
    agent_id="my-bot",
    key="last_trade",
    value='{"direction": "long", "entry": 95000, "size_sats": 100000}',
)

# Retrieve later (~1 sat/KB, min 20 sats)
state = client.memory_get(agent_id="my-bot", key="last_trade")

# Free operations
client.memory_list(agent_id="my-bot")
client.memory_delete(agent_id="my-bot", key="last_trade")

Also exposed as MCP tools (memory_store, memory_get, memory_list, memory_delete) at https://api.babyblueviper.com/mcp. Full schemas and LLM wiring in docs/agent-wallet-guide.md and docs/llm-integration-prompt.md.

Why Lightning?

• No accounts to onboard. Agents register themselves and pay in sats.

• Streaming-fine settlement. A single inference call is a single payment.

• Withdrawal symmetry. Sellers receive sats directly to a Lightning address.

• Bitcoin-only. No fiat rails, no chargebacks, no enterprise signup ceremony — register and pay over Lightning.

License

Apache 2.0 — see LICENSE.

Status

This is the public developer-facing SDK + integrations. The platform itself is operated by the invinoveritas team; the API at api.babyblueviper.com is open for use behind the Bearer model.

Distribution focus right now: acquisition + funding conversion. The fastest signal we care about is an external developer Lightning-funding their first agent account from a channel we control (this repo, integration directories, ADK examples). If you build with this and it works for you, open an issue — your buyer-proof story is the next person's reason to try it.

Recent Platform Highlights (V1.1)

The backend MCP server (what you connect to) added major power features:

• Persistent per-agent workspaces: execute(use_workspace=true) gives your agent a real /workspace directory that survives across calls (git clones, files, packages persist). Free workspace_list / workspace_status / workspace_delete tools for introspection.

• Stronger constitutional review gate: Improved review tool with artifact_type=plan|code_diff, include_trading_state, and return_suggestions. Our live H1 Hyperliquid trading bot now calls it before every entry.

• Better Grok integration: Dedicated https://api.babyblueviper.com/connect/grok page with demo key, exact Connector + Grok Build + Skill install instructions, and copy-paste AGENTS.md patterns.

Connect the same server from the SDK or any MCP client:

• Server URL: https://api.babyblueviper.com/mcp

• See live Grok setup: https://api.babyblueviper.com/connect/grok

• Any-agent skill pack: https://api.babyblueviper.com/data/invinoveritas_skill_any_agent.md

These are the same tools our internal fleet uses daily.