Author: Jonathan Clark
The RoboTorq Reserve System is an open source, decentralized, Universal Basic Dividend-paying monetary system.
A deterministic, physics-backed reserve currency generated from cryptographically verified robotic labor, without blockchain mining or speculative inflation. Minted and traded digitally initially, the design also allows for RoboTorq Bearer Bonds to be redeemed physically from any 3D printer, at home, or stamped and sold en masse, all backed by on-grid, in-vault certificates on a distributed proof ledger.
- Not a "cryptocurrency": no blockchain → no mining → no chain bloat.
- 1 RoboTorq = Energy × Bonded Token Throughput (a cross-product)
- Specifically, every joule is mapped to a Bonded Token as each are consumed.
- Value emerges from both how much work is done and how efficiently it flows into the system.
- Proof chain compresses raw token x energy "ore" data → ingots → certificates.
- Demurrage (hoarding fee) drives circulation + funds new robotic labor to make new currency.
- One command to run:
docker compose up -d.
The RoboTorq Reserve System circulates a certificate-backed currency in a closed-loop economy. The self-regulating system is designed such that the collateral can, mathematically speaking, never run dry... but only so long as people choose to keep using it.
How? Every atomic investment in robotic labor, the collectively paid RoboStake, serves as the value basis for minting more RoboTorq, bounded by the laws of physics and smart contracts. The closed loop design + contract approval vault check + demurrage ensures the distributed StakeVault never accepts a contract it can't fund.
The RoboTorq Reserve System isn't a government. It doesn't have to go into debt to pay a UBI. It simply accepts whatever growth stimulus we choose to give it, that it and we can already afford, and pays UBD based on that input.
Long-term financing is achieved with collateralized, vaulted savings tied to UBD pledges.
- Philosophy
- Why No Blockchain?
- Unit Hierarchy
- Quick Start
- Testing
- Architecture Overview
- Companion Simulator Repo
- Project Structure
- Development Workflow
- Architecture Deep Dives
- Contributing
- Security
- License
- Status
- Contact
"Watts > Wall Street"
RoboTorq challenges three assumptions:
- Money must be state-issued
- Mining must waste energy
- Value must be speculative
Instead, RoboTorq anchors value to measurable physics — actual energy and computation consumed by contracted robotic labor. Each unit is minted only after the work is performed, priced in advance, and cryptographically proven.
Every RoboTorq corresponds to real, verifiable work. This is not “blockchain because blockchain” (there is no blockchain).
It’s a reserve system where robotic labor produces tangible, auditable, certificate-backed currency and enables universal basic dividends without political inflation games or Wall Street speculation.
Demurrage-free savings and investment schemas ensure liquidity, while demurrage on idle wallets yields interest to savers and funds Robotic Labor. All Bearer Bonds are demurrage exempt and can be printed at home because printing does not equal minting in the RoboTorq Reserve System.
RoboTorq uses a lightweight, message-passing network (NATS), vaulted certificate-backed proofs, and cryptographically tracked issuance events instead of global consensus.
- Certificates remain inside distributed vaults
- All vaulted artifacts are signed, merklized, and linked
- No mining, no gas, no chain bloat, no global transaction ledger (proof ledgers are tiny by comparison)
- Track a large nation-state economy of yearly proofs on several terabytes of distributed storage.
The core system is intentionally compact — with each service designed to eventually run on a small cluster of Raspberry Pis + minimal storage if need be — so communities with limited resources could hypothetically operate local reserve system nodes on the same footing as anyone else.
Any productive machine (3D printers, CNCs, Cricuts, etc.) can act as a tracked robot, creating a low-barrier, closed-loop economy. If participants choose to use it, the system can sustain itself mathematically through continuous, provable robotic labor rather than speculative growth.
| Layer | Artifact | Aggregation | Resulting Count | Crypto Operation | Role |
|---|---|---|---|---|---|
| L0 | JouleTorqOre | 1 token × 1 joule | 3,600 per ingot | Raw Data Hashed + Signed | Atomic work proof |
| L1 | TokenTorqIngot | 3,600 units of Ore | 1,000 per certificate | Merkle branch root + Signed | Batched for minting |
| L2 | RoboTorq Certificate | 1,000 ingots (3.6M units of Ore) | Basis for reserve | Merkle batch root + Signed | Monetary Backing |
| L3 | RoboTorqUnits | Certificate-Backed, Digital, 1:1 | Dynamic | Signed Distribution Events | Circulation |
| L4 | Bearer Bond | Certificate-Backed, Physical, N:1 mapping | Dynamic | Merkle Cert Collection + Signed | Circulation |
Formula relationships:
1 TokenTorqIngot = 3,600 JouleTorqOre units
1 RoboTorq Certificate = 1,000 ingots = 3,600,000 Ore units
Extended layered explanation: see ROBOTORQ_CONCEPT_STACK_V1.md.
Now that you understand what you'll be quick starting, here's how to do it.
git clone https://github.com/GrokkingGrok/robotorq-reserve-system
cd robotorq-reserve-system
docker compose up -d
docker compose ps # all services “healthy”
python ./tests/integration/hardware/test_printer_flow.py
# open browser to http://localhost:3001/ for Grafana metric Dashboard, watch the ore flowMonitoring:
- Grafana http://localhost:3001 (admin/admin)
⚠️ Local dev only — change password before exposing to network - Grafana/robotorq-complete-pipeline.json (fully configured pipeline viewer definition)
Logs:
# docker native log reader, follow stream
docker compose logs -f mint
# check scripts/logs folder for helpful python log checkers if you don't want to learn docker logging
# View last 20 lines, no follow
python scripts/logs/mintlogs.py
# View last N lines only, no follow
python scripts/logs/mintlogs.py --tail 100
# Follow logs in real-time (skip initial tail, stream continuously)
python scripts/logs/mintlogs.py -fStop:
docker compose down
docker compose down -v # full reset- Git to clone repo
- Docker (with Docker Compose V2) to run nodes
- Python for testing
That's it. Everything runs in containers.
# Run all Go tests with coverage
cd src/mint # or refinery, digger, etc.
go test ./... -v -cover -racecd tests
pytest tests/integration/ -vcd tests
python tests/e2e/test_full_pipeline.pyTest Documentation: See tests/README.md
RoboTorq uses a message-passing architecture (NATS pub/sub) with services that aggregate proofs:
Key Services:
- Digger: Tracks contracted robotic labor, measures energy, creates signed proof units of Ore
- Refinery: Aggregates 3,600 proof units into ingots with merkle branch hashes
- Mint: Validates 1,000 ingots, builds merkle tree, mints 1 RoboTorq unit
- DistoDam – Distributor + proto-Vault (will be replaced by full Vault)
- Wallet: Manages balances, transactions, and unit verification
- Printer: (aka a productive robot) track a mock printer as a test robot
Note on "printer" module: 3D-printers are considered robots by this system. The current Mock Printer setup allows you to generate ore for the pipeline. Printer logic will soon involve printing physical RoboTorq as well.
The RoboTorq Reserve System is designed to run simulations on production code (not yet implemented, see research/SIMULATION_FRAMEWORK.md) by scaling the waits that slow down Digger contract execution logic to be "real-time" in production.
This planned academic-grade simulator will require minimal refactoring, and will be the primary focus after the first physical Bearer Bond RoboTorq prototype has been printed and tagged. Current expected delivery of first scannable, physical RoboTorq prototype in January-February 2026 (hardware integration, unknown landmines exist).
The simulator configuration logic will live under a different repo and a GPL license: Project Asimov
Robot → Digger → Refinery → Mint → Vault → Wallet
robotorq-reserve-system/
├── src/
│ ├── bidnet/ # Rust: (future) Bid on Robotic Labor Projects or exchange currency
│ ├── digger/ # Rust: Track Robotic Labor/Generates Ore
│ ├── refinery/ # Go: Ore aggregation into ingots
│ ├── mint/ # Go: Ingot validation + RoboTorq minting
│ ├── distodam/ # Go: Distribution with demurrage
│ ├── wallet/ # Go: Balance + transaction management
│ ├── printer/ # Rust: A Mock 3D printer to act as robot's labor for tracking, printers are a special type of robot that will also print RoboTorq
│ ├── trust/ # Go: Contract Execution
│ └── vault/ # Architecture docs for reserve system (planned)
├── tests/
│ ├── e2e/ # End-to-end pipeline tests
│ ├── integration/ # Service integration tests
│ └── fixtures/ # Shared test helpers
├── scripts/ # Python utilities for testing/monitoring
├── docs/ # Architecture and phase completion docs
├── Grafana/ # Monitoring dashboards
├── docker-compose.yaml # Complete service orchestration
├── prometheus.yml # Metrics definition
See BRANCHING.md for the complete development workflow, including:
- Branch strategy (feature branches from
main) - Commit conventions (Conventional Commits)
- Testing requirements (95%+ coverage target)
- The proven 14-step Power Workflow
Quick Summary:
- Create feature branch:
git checkout -b feature/your-feature - Read relevant architecture docs in
src/{service}/ - Implement with tests (Go:
go test ./..., Python:pytest) - Commit incrementally with descriptive messages
- Open PR to
mainwhen ready
- Mental Model:
MENTAL_MODEL.md- Start here for conceptual understanding - Proof Chain:
docs/PROOF_CHAIN_ARCHITECTURE.md - Mint:
src/mint/MINT_ARCHITECTURE.md - Refinery:
src/refinery/REFINERY_ARCHITECTURE.md - Vault Design:
src/vault/Architecture/Final design/VAULT_MVP_FINAL_DESIGN.md - Trust Economics:
docs/trust-economics.md
Contributions welcome (and needed)! Please see CONTRIBUTING.md for guidelines.
Key Points:
- Follow the branching strategy in
BRANCHING.md - Write tests (80%+ unit coverage target, cover remaining with integration and e2e)
- Use Conventional Commits format if you know it
- Update architecture docs when proposing changing designs
For security concerns or vulnerability reports, see SECURITY.md.
Current Status: Pre-release development on release/v0-cleanup branch. Not production-ready.
Apache License 2.0 with Patent Pledge - see LICENSE for details.
Patent Pledge: All contributors irrevocably dedicate patent rights to the public domain and pledge not to assert patent claims against users or derivatives.
The RoboTorq Reserve System has been designed and built up to release by the author alone.
This isn't a "flex": the author can't proceed too much further without expert help.
Current Phase: v0 Cleanup & Open Source Preparation
Branch: release/v0
Target: Public release with working crypto pipeline, extensive documentation, and observability.
What Works:
- Complete proof chain (Robot → Digger → Refinery → Mint → DistoDam)
- Prometheus + Grafana observability (Watch the crypto pipeline in action)
- Basic labor tracking
- Cryptographic signing (falcon + SPHINCS)
- Merkle tree aggregation at all layers (except physical bearer bond merkles, depends on vault)
- Persistance of some data
- Wallet recieves UBD, but cannot spend
In Progress:
- In-Flight mint ingot recovery backend implemented, needs integration
- Vault System fully designed, but not implemented, will be rust
- DistoDam will be replaced by Vault logic
- Mock-Printer to Real 3D Printer (aka robot)
- Comprehensive documentation
- Simulator configuration design
Effectively Blocked:
- Security audit and hardening (high priority, expert needed)
- Trust service needs full rewrite, rust preferred (Executes Contracts, needs vault first)
- BidNet (invest in robotic labor projects, needs vault first) not started, but high-level design known.
- Horizontal scaling (distributed systems experts needed)
- Build/dependency improvements (experts needed)
- Repository: https://github.com/GrokkingGrok/robotorq-reserve-system
- Issues: https://github.com/GrokkingGrok/robotorq-reserve-system/issues
Minted with ⚡ by bots, for humans
AI DISCLOSURE & AUTHOR NOTE: This document was written by and is maintained by Jonathan Clark (human). It was and will continue to be edited/refined by several AI agents as part of that efficient maintenance.
Other parts of the repository — including many architecture deep-dive docs, and yes, CODE — were drafted or expanded by AI in close collaboration with me, based on long chats. They serve as living design notebooks and current implementations: reference material for myself and future contributors to challenge, refine, or replace — NOT GOSPEL. Final responsibility for everything (correct, broken, or weird) remains mine.
The only RoboTorq Gospel:
1 JouleTorq = 1 joule x 1 token / 1 second
1 TokenTorq = 3600 JouleTorq
1 RoboTorq = 1000 Tokentorq = 3.6 million JouleTorq