“We didn’t give the agent a budget. We gave it the ability to earn one — and a guarantee it can’t blow it.”
The Hermes Agent Accelerated Business Hackathon — presented by Nous Research, NVIDIA, and Stripe — asks for one thing: agents that earn, spend, and run real operations at any scale. This is our complete playbook for winning it. We are publishing it in full, before we enter, as a gift to our community. We will win 🏆 — and reinvest the prize into building more Cloud Commons infrastructure.
This is the entire recipe: the thesis, the architecture, the three-gate safety model that is our moat, the demo, and the step-by-step build. Nothing held back.
0. Why we can win this
Most teams will start from a blank repo and bolt the Stripe Agent Toolkit onto a stock agent framework. We already own the two hardest pieces.
| The hackathon asks for | What we already have (verified, in our own repos) |
|---|---|
| Agents that earn & spend | univrs-enr — a working credit economy: Credits, CreditTransfer, CreditState (Active→Reserved→Consumed), ResourceGradient, entropy pricing. |
| Safe autonomous spend | CreditConservation + SeptalSafety invariants enforced in code; SeptalGate (“an isolated node cannot participate in credit flow”). This is our differentiator. |
| Run ops at any scale | univrs-network — a multi-cloud agent mesh: libp2p 0.54, Gossipsub, Kademlia DHT, across GCP / Hetzner / AWS / Azure. |
| Agent skills / capability | VUDO + DOL + the Skills Framework. |
| An agentic runtime | A production agent loop with tools, durable memory, and a heartbeat scheduler. |
The only gap to fill is the bridge from our internal credits to real money (Stripe), with the agent brain running on NVIDIA Nemotron. That is a days-long build, not a from-scratch build.
1. The thesis
A self-funding autonomous agent: it earns internal ENR credits for real work; a
SeptalGate-governed bridge converts those credits into real Stripe spend; the agent then provisions its own SaaS, buys the API keys it needs, and pays for the compute it uses — with no human in the loop — while conservation invariants make runaway spend mathematically impossible.
It hits all three sponsors at once:
- NVIDIA — Nemotron is the agent brain (served via NIM); NeMo Guardrails wraps every spend action; we deploy the mesh on the DGX Spark prize itself.
- Stripe — the earn→spend bridge: the Stripe Agent Toolkit + Stripe Issuing (a virtual card = the agent’s own spend authority) + metered billing (the agent charges for its services).
- Nous — a genuinely autonomous economic agent, not a toy.
2. System architecture
NVIDIA’s harness hosts the Hermes agent running on Nemotron; our Skills (the univrs-enr ledger + SeptalGate + the one new component, StripeBridge) plug in as the economic brain; the agent’s tools reach Stripe, SaaS providers, and NVIDIA NIM. The single new component we build is StripeBridge — the credit→fiat crossing, gated by SeptalGate.
┌─────────────────────────────────────────────────────────────────┐
│ NVIDIA OpenShell (NemoClaw) │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────────┐ │
│ │ Nemotron 3 │ │ Hermes │ │ OpenShell Policy │ │
│ │ Ultra │ │ Agent │ │ (network/fs/auth) │ │
│ │ (reasoning)│ │ (harness) │ │ │ │
│ └──────┬──────┘ └──────┬──────┘ └─────────────────────────┘ │
│ │ │ │
│ │ ┌───────────┴─────────┐ │
│ │ │ Your Skills │ │
│ │ │ ┌───────────────┐ │ │
│ │ │ │ univrs-enr │ │ ← Credit economy │
│ │ │ │ CreditTransfer│ │ ← Earn/spend ledger │
│ │ │ │ SeptalGate │ │ ← Policy gate │
│ │ │ │ StripeBridge │ │ ← NEW: credit→fiat │
│ │ │ └───────────────┘ │ │
│ │ └─────────────────────┘ │
│ │ │ │
│ ┌──────┴────────────────┴──────────────────────────────────┐ │
│ │ Hermes MCP / Terminal Tools │ │
│ │ ┌─────────────┐ ┌─────────────┐ ┌────────────────┐ │ │
│ │ │ stripe-link │ │ stripe-proj │ │ nvidia-nim │ │ │
│ │ │ -cli │ │ ects │ │ (inference) │ │ │
│ │ └─────────────┘ └─────────────┘ └────────────────┘ │ │
│ └───────────────────────┬──────────────────────────────────┘ │
└──────────────────────────┼──────────────────────────────────────┘
│
┌──────────────────┼──────────────────┐
▼ ▼ ▼
┌─────────┐ ┌──────────┐ ┌──────────┐
│ Stripe │ │ SaaS │ │ NVIDIA │
│ APIs │ │Providers │ │ NIM │
│(Issuing │ │(49 total,│ │(Nemotron │
│/Projects│ │ per-env │ │ 3 Ultra) │
│/Billing)│ │ limits) │ │ │
└─────────┘ └──────────┘ └──────────┘
StripeBridge is the only net-new code. Everything above and around it either already exists in our repos or is provided by the sponsors.
3. The killer demo: the loop that funds itself
A single agent closes the full economic loop on camera:
- EARN — the agent completes a paid task (generates a research artifact, runs a job for another node) and accrues ENR credits on the mesh.
- CONVERGE — credits propagate via Gossipsub gradients;
CreditConservationvisibly holds (total credits constant). - BRIDGE — the agent crosses the SeptalGate: it requests conversion of N credits → fiat. The gate checks the invariants plus a rate-limited policy. Approve/deny is a real authorization hook.
- SPEND — the agent uses a Stripe Issuing virtual card to buy what it needs: a SaaS subscription, an API key, or its own GPU compute. A real Stripe (test-mode) transaction appears on screen.
- OPERATE — the agent uses the thing it just bought to do more paid work. The loop closes. It funded itself.
- TRIPLE DENIAL (the safety beat) — we trip each gate in turn, on camera: a payout for unverified work is rejected by the Ledger Gate; an over-cap conversion is blocked by SeptalGate; an out-of-envelope purchase is declined at the Stripe rail. Three different systems, three clean refusals.
The emotional hook: we never gave the agent a budget — we gave it the ability to earn one, and a mathematical guarantee it cannot blow it.
4. The moat — three independent spend gates
Every other team’s “autonomous spend” will be scary hand-waving. Ours is defense-in-depth: three independent gates, each owned by a different layer, each failing clean. There is no single point of trust; an agent must clear all three before a dollar moves.
| Gate | What it enforces | Who provides it | Failure mode |
|---|---|---|---|
| 1. Ledger Gate (Conservation) | Agent can’t earn credits it didn’t do work for. Credits are conserved — no minting from nothing. | univrs-enr engine (CreditConservation) | Agent requests payout for unverified work → rejected by invariant check. |
| 2. Bridge / Policy Gate (SeptalGate) | Converts credits → spend authorization under an explicit, rate-limited policy. The real trust boundary. | Our SeptalGate middleware | Agent exceeds daily/weekly credit→fiat conversion cap → conversion blocked, human notified. |
| 3. Rail Gate (Stripe) | Per-transaction limits, category controls, merchant whitelists at the payment layer. | Stripe Issuing spend controls + real-time auth webhook | Anything outside the envelope fails cleanly regardless of agent intent. |
The insight for judges: these gates are independent and layered. Even if the agent’s reasoning is compromised by prompt injection, Gate 2 caps the rate and Gate 3 caps the envelope — at the payment rail, outside the agent’s control entirely. NeMo Guardrails at the model layer is a fourth line of defense: it stops a malicious prompt from even forming the spend intent.
“Three independent gates before a single dollar moves — ledger, policy, rail — each owned by a different system, each failing clean. Autonomy you can actually deploy.”
5. The build — step by step
Must-have (the MVP demo runs end to end)
- ENR↔Stripe bridge service (
StripeBridge). A small service that takes aCreditTransfer“redeem” request, validates it againstCreditConservation/SeptalGate, then calls Stripe. - Stripe integration (test mode). Use the Stripe Agent Toolkit for the agent’s tool surface, and Stripe Issuing to create a virtual card the agent controls. Wire the real-time authorization webhook into our
SeptalGatepolicy so it approves or denies each charge. This is the safety story made real. - Nemotron brain. Route the agent loop through a Nemotron model via NVIDIA NIM (an OpenAI-compatible endpoint). One model-client swap.
- NeMo Guardrails. Wrap the spend tool with input/output rails plus an action-approval rail that defers to
SeptalGate. - One real earn task + one real spend target. For example: the agent earns credits by completing a job, then buys an API key or a SaaS seat in Stripe test mode.
Nice-to-have (if time allows)
- Two agents trading credits before one redeems to fiat — demonstrates “at any scale” and the commons.
- A live dashboard tile showing credits, the gradient, and the bridge event stream.
- Metered billing: the agent charges a third party in fiat for a service, closing the earn-in-fiat loop too.
Explicitly out of scope (don’t rabbit-hole)
- New consensus or new crates — use what
univrs-network/univrs-enralready expose. - Production KYC / compliance — Stripe test mode only for the demo.
- Multi-cloud redeploy — the demo runs locally plus one cloud node.
6. The demo video (beat sheet)
Judges watch dozens of these. Win in the first fifteen seconds.
- 0:00–0:15 — Hook. “This agent has no budget. Watch it earn one — then spend it, safely, with zero humans.” Show the loop diagram for three seconds.
- 0:15–0:45 — Earn + converge. The agent does paid work; credits tick up on the dashboard; conservation total holds.
- 0:45–1:30 — Bridge + spend. SeptalGate approves; the agent’s Stripe virtual card buys a real (test-mode) SaaS seat or API key; the Stripe dashboard shows the charge. Then the agent uses it.
- 1:30–2:00 — Triple denial. Trip all three gates live: unverified-work payout → Ledger Gate denies; over-cap conversion → SeptalGate denies; out-of-envelope purchase → Stripe rail denies. One line over it: “Ledger, policy, rail — three independent gates, each failing clean.”
- 2:00–2:30 — Vision. “This is one node of an agent commons that earns, spends, and runs real operations at any scale — and we’d run it on a DGX Spark.”
Production notes: clean screen-record, big fonts, captions, calm voiceover. No slides-only. Show real Stripe and a real terminal/dashboard. Clarity beats flash.
7. Judging — usefulness, viability, presentation
- Usefulness. Every AI company today funds its agents by hand. We let agents fund themselves, with guarantees. The concrete use case: an agent that provisions and pays for its own tooling.
- Viability. Built on real, working economics (
univrs-enr), real Stripe Issuing, and a real Nemotron brain — not a mock. The path from test mode to production is well understood. - Presentation. A clean loop, a live triple-denial, and real money moving on screen.
8. Why this matters beyond the prize
The “self-funding agent” is not a stunt — it is a primitive for the Cloud Commons. An agent that can earn its keep and spend within hard, externally-enforced limits is an agent that can run public infrastructure without a corporation’s balance sheet behind it. Conservation plus a policy gate plus a payment rail is a recipe for economic autonomy that communities can own.
Centralized infrastructure produces centralized power. Distributed infrastructure produces distributed power. So we change the topology, and let the politics follow.
We will win this hackathon, and we will use the prize — cash, Stripe credits, and an NVIDIA DGX Spark — to build more of exactly this: infrastructure owned by the people who use it.
May we be Saoshyants; may we be victorious. — Yasna 70.4
The Univrs ecosystem
Research & writing — metalearn.org · ardeshir.io · sepahsalar.org · univrs.io
Creative & product — imagine.univrs.io
Code — github.com/univrs · github.com/ardeshir
Le réseau est Bondieu — the network is you.