Solvent Publishing Guide

wpnews.pro

An AI agent that runs as a profitable, self-funding business.

It sells research briefs. It collects payment on Stripe. It spends its own revenue to provision the compute it needs. And it refuses any job that doesn't clear a margin.

Most agents can spend money. Almost none can run as a business.

SOLVENT closes the full loop:

  Client pays Stripe → Agent earns revenue → Agent fulfils the work
  → Agent pays its own vendor bills → P&L booked → balance sheet grows

Every job is profit-gated before it starts. Unprofitable work is declined without touching Stripe. Vendor payments are screened by a NemoClaw-style policy sandbox. The agent literally cannot spend more than it earns.

Zero dependencies. No API keys. Works right now.

git clone https://github.com/ianalloway/solvent-agent.git
cd solvent-agent
python3 run_demo.py

The agent will run a full batch of 4 analyst jobs — complete with margin gating, Stripe payment simulation, NVIDIA Nemotron fulfillment, guardrail screening, and live P&L — in about 30 seconds.

First run: A short onboarding wizard asks you to choose a model, interaction mode, and whether to enable Stripe test mode. Preferences are saved to.solvent/config.json

and never committed.

After a run, open the live treasury dashboard:

open treasury_dashboard.html   # macOS

A typical batch session:

Metric	Value
Revenue	$223.00
Operating spend	$13.35
Net profit
$209.65
Margin	94%
Jobs declined	1 (below margin floor)

 inbound job
     │
     ▼
 ┌─────────────┐   margin < floor?  ┌───────────┐
 │  MARGIN GATE│ ─────────────────▶ │  DECLINE  │
 │  (pricing)  │                    └───────────┘
 └─────┬───────┘ accept
       ▼
 ┌─────────────┐   EARN
 │   STRIPE    │ ── Payment Link → poll/webhook until paid ──▶ + revenue
 └─────┬───────┘    (records cs_... + pi_... on ledger)
       ▼
 ┌─────────────┐   FULFIL
 │  NEMOTRON   │ ── Llama-3.1-Nemotron-Ultra produces the brief ──▶ resource usage
 └─────┬───────┘
       ▼
 ┌─────────────┐   SPEND (every payment screened first)
 │ GUARDRAILS  │ ── NemoClaw policy: allowlist · caps · reserve · ROI
 │   → STRIPE  │ ── Issuing virtual card (test) or simulated spend ──▶ − expense
 └─────┬───────┘
       ▼
   BOOK P&L  ──▶ treasury updated · dashboard refreshed

Revenue is always collected before cost is incurred, and no payment can violate policy. The business is safe by construction and profitable by rule.

Layer	Technology	File
Analyst / reasoning
NVIDIA Nemotron (Llama-3.1-Nemotron-Ultra)	`solvent/nemotron.py`
Spend safety
NVIDIA NemoClaw-style policy sandbox	`solvent/guardrails.py`
Earn
Stripe Payment Links + Checkout Session polling	`solvent/stripe_client.py`
Spend
Stripe Issuing virtual cards (test mode)	`solvent/stripe_client.py`
Orchestration
Hermes / Nous tool-calling agent loop	`solvent/agent.py`
Memory
SQLite treasury + pricing ledger	`solvent/treasury.py` · `solvent/pricing.py`

Key design choices:

Structural profitability—pricing.py

computes unit cost before quoting. If margin < floor, the job never reaches Stripe.Spend policy—guardrails.py

enforces vendor allowlist, per-transaction cap, rolling 24h budget, minimum cash reserve, and no-negative-ROI rule.Offline-first— without API keys the demo runs on deterministic stubs. AddNVIDIA_API_KEY

+STRIPE_API_KEY=sk_test_...

to unlock live inference and real Payment Links.Audit trail— everycs_...

checkout session ID andpi_...

PaymentIntent ID is recorded on the ledger before fulfilment begins.

python3 run_demo.py

4 pre-loaded jobs. ~30 seconds. Shows margin gating, Stripe earn/spend, Nemotron fulfillment, and guardrails in action.

python3 run_demo.py --interactive

Type a research topic and client budget at the prompt. The agent quotes, pays, fulfils, and books P&L for each one in real time. Keep going until you quit.

python3 run_demo.py --seed 500        # start with $500 instead of $100
python3 run_demo.py --keep-balance    # resume existing treasury balance

In interactive mode, type /fund 200

at the prompt to deposit $200 into the live treasury without restarting.

from solvent.agent import Solvent

agent = Solvent(seed_cents=10_000)          # reset treasury, seed $100
agent.handle_job(SAMPLE_JOBS[0])            # process one job
snap = agent.run(SAMPLE_JOBS[1:])           # process a list; returns snapshot

print(snap["balance_cents"], snap["margin_pct"])
python3 demo_guardrails.py

Shows five spend attempts and which ones the NemoClaw-style policy blocks — without starting the agent or touching Stripe.

To use live Nemotron inference and real Stripe test-mode payment links:

pip install -r requirements.txt

export NVIDIA_API_KEY=nvapi-...        # from build.nvidia.com
export STRIPE_API_KEY=sk_test_...      # Stripe test mode only (live keys refused)

python3 run_demo.py

With both keys set:

Briefs are written by NVIDIA Nemotron(Llama-3.1-Nemotron-Ultra). - Each job creates a real Stripe Payment Link. Pay with test card4242 4242 4242 4242

. - SOLVENT polls the Checkout Session (cs_...

) untilpayment_status == paid

before fulfilling — no instant confirm. - Optional: set STRIPE_WEBHOOK_SECRET

and forwardcheckout.session.completed

events viaStripeClient.process_webhook()

. - Optional: enable Stripe Issuing on your test account to provision capped single-use virtual debit cards for each vendor payment.

Variable	Purpose
`NVIDIA_API_KEY`
Live Nemotron inference (`nvapi-...` )
`STRIPE_API_KEY`
Stripe test key (`sk_test_...` )
`STRIPE_WEBHOOK_SECRET`
Optional webhook verification
`STRIPE_PAYMENT_POLL_TIMEOUT`
Seconds to wait for payment (default `120` )
`STRIPE_PAYMENT_POLL_INTERVAL`
Poll interval in seconds (default `2` )
`SOLVENT_FORCE_STRIPE_SIMULATE`
Force offline simulate mode even with a key

Product/Price objects are cached in .solvent/stripe_catalog.json

so repeated runs reuse a single SOLVENT Research Brief product instead of cluttering your Stripe dashboard.

pip install pytest
python3 -m pytest tests/ -v

Unit tests cover: pricing & margin gate · guardrail policy · treasury ledger · Stripe client (simulate + test mode) · config/onboarding.

solvent/
  agent.py         the orchestrator (earn → fulfil → spend → book)
  treasury.py      SQLite ledger / balance sheet
  pricing.py       the margin gate
  guardrails.py    NemoClaw-style spend policy
  stripe_client.py two-sided Stripe layer (earn + spend)
  nemotron.py      NVIDIA Nemotron client (+ offline stub)
  service.py       the product: an on-demand research brief
  jobs.py          sample inbound work
  dashboard.py     renders the treasury to HTML + JSON
  config.py        onboarding wizard and config persistence
run_demo.py        the full business loop (CLI entry point)
demo_guardrails.py the safety story (standalone)
tests/             pytest suite
docs/              screenshots and supporting assets

Hermes Agent Accelerated Business Hackathon — NVIDIA × Stripe × Nous Research

The agent was designed to demonstrate:

An agent that is economically self-aware— it has a treasury, prices against its own costs, and gates every action on projected profit - A complete two-sided Stripe integration— earns via Payment Links, spends via Issuing virtual cards Provable spend safety— a NemoClaw-style policy sandbox that makes "give an agent a payment credential" a reasonable thing to do** Live inference with NVIDIA Nemotron**— the offline stub means the demo always works, even without API keys

Issues, PRs, and ideas are very welcome. Some good starting points:

Add more sample research topics in solvent/jobs.py
Improve the Nemotron prompt template in solvent/service.py
Add a new guardrail policy to solvent/guardrails.py
Extend the dashboard with charts or new metrics in solvent/dashboard.py

If SOLVENT gave you ideas, give it a ⭐

source & further reading

github.com — original article

Solvent Publishing Guide

Run your AI side-project on zahid.host