Autonet is a unified framework for decentralized AI training, inference, and governance. It combines four foundational components into a coherent system:
- Proof of Intelligence (PoI): Distributed AI model training with cryptoeconomic incentives
- Recursive Principial Body (RPB): Constitutional governance with LLM-based consensus
- Myco-sys: Self-governing autonomous node architecture
- Smart Rollup: Layer 2 infrastructure for scalable on-chain verification
┌─────────────────────────────────────────────────────────────────────────────┐
│ AUTONET STACK │
├─────────────────────────────────────────────────────────────────────────────┤
│ Layer 4: Applications │
│ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │
│ │ AI Inference │ │ Model Markets │ │ DAO Tools │ │
│ └─────────────────┘ └─────────────────┘ └─────────────────┘ │
├─────────────────────────────────────────────────────────────────────────────┤
│ Layer 3: AI Training & Inference │
│ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │
│ │ Proposer Node │ │ Solver Node │ │ Aggregator │ │
│ │ (Task Gen) │ │ (Training) │ │ (FedAvg) │ │
│ └─────────────────┘ └─────────────────┘ └─────────────────┘ │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ Absolute Zero Loop: Task → Solve → Verify → Aggregate │ │
│ └─────────────────────────────────────────────────────────────┘ │
├─────────────────────────────────────────────────────────────────────────────┤
│ Layer 2: Constitutional Governance │
│ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │
│ │ Constitution │ │ LLM Consensus │ │ Debate System │ │
│ │ (Principles) │ │ (RPB Method) │ │ (Governance) │ │
│ └─────────────────┘ └─────────────────┘ └─────────────────┘ │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ Four Engines: Awareness │ Governance │ Work │ Survival │ │
│ └─────────────────────────────────────────────────────────────┘ │
├─────────────────────────────────────────────────────────────────────────────┤
│ Layer 1: Smart Contracts (PoI Chain) │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │PoIProject│ │TaskMgmt │ │Staking │ │Governance│ │Token │ │
│ └──────────┘ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │
├─────────────────────────────────────────────────────────────────────────────┤
│ Layer 0: Rollup Infrastructure │
│ ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │
│ │ AnchorBridge │ │ DisputeManager │ │ Checkpoint │ │
│ │ (L1 Security) │ │ (Challenges) │ │ (State Roots) │ │
│ └─────────────────┘ └─────────────────┘ └─────────────────┘ │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ Pastry DHT │ VRF Committee │ Plugin System │ │
│ └─────────────────────────────────────────────────────────────┘ │
├─────────────────────────────────────────────────────────────────────────────┤
│ Layer -1: L1 Anchor (Ethereum/Tezos) │
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ Security Bootstrap │ Data Availability │ Final Settlement │ │
│ └─────────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────────────────┘
Each node in Autonet is a sovereign "citizen-cell" that:
- Operates according to immutable constitutional principles
- Participates in governance through LLM-based consensus
- Executes work only with active network heartbeat
- Can replicate via spore mechanism
Self-improving distributed training with commit-reveal pattern:
┌──────────────────────────────────────────────────────────────────────────┐
│ ABSOLUTE ZERO LOOP │
├──────────────────────────────────────────────────────────────────────────┤
│ │
│ 1. PROPOSE Proposer creates task with hidden ground truth │
│ │ │
│ ▼ │
│ 2. TRAIN Solver trains model, commits solution hash │
│ │ │
│ ▼ │
│ 3. REVEAL GT Proposer reveals ground truth (triggered by commit) │
│ │ │
│ ▼ │
│ 4. REVEAL SOL Solver reveals solution (triggered by GT reveal) │
│ │ │
│ ▼ │
│ 5. VERIFY Coordinators vote via Yuma consensus │
│ │ │
│ ▼ │
│ 6. REWARD Rewards distributed to proposer, solver, coordinators │
│ │ │
│ ▼ │
│ 7. AGGREGATE Aggregator performs FedAvg on verified updates │
│ │ │
│ ▼ │
│ 8. PUBLISH Global model published on-chain via setMatureModel │
│ │ │
│ └──────────────────► Loop continues with new tasks │
│ │
└──────────────────────────────────────────────────────────────────────────┘
Status: Fully operational - Complete loop demonstrated with real PyTorch training
Autonet enables AI model training and inference without centralized infrastructure:
Training: Multiple solver nodes train on local data, submit weight updates verified by coordinators, and aggregate via FedAvg. No single entity controls training data or model updates.
Model Storage: Trained model weights are sharded across storage providers via ModelShardRegistry:
- Merkle proofs verify shard integrity
- Erasure coding (k data + n parity shards) ensures availability even if providers go offline
- Staked providers are economically incentivized to maintain uptime
Inference: Published models can be queried via requestInference(). Providers stake ATN and compete to serve requests.
┌─────────────────────────────────────────────────────────────────────────┐
│ DISTRIBUTED WEIGHT STORAGE │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ Model (8M params) │
│ │ │
│ ▼ │
│ ┌─────────────┐ │
│ │ Shard Model │ 4 data shards + 1 parity │
│ └─────────────┘ │
│ │ │
│ ┌─────┼─────┬─────┬─────┬─────┐ │
│ ▼ ▼ ▼ ▼ ▼ ▼ │
│ [S0] [S1] [S2] [S3] [P0] ← Each uploaded to IPFS │
│ │ │ │ │ │ │
│ ▼ ▼ ▼ ▼ ▼ │
│ ┌───────────────────────────────┐ │
│ │ ModelShardRegistry.sol │ On-chain coordination │
│ │ - registerModel(merkleRoot) │ │
│ │ - announceShard(provider) │ │
│ │ - checkAvailability() │ │
│ └───────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
Decisions requiring conceptual reasoning use LLM-based consensus:
- Multi-modal language models evaluate proposals
- Constitutional standards constrain all decisions
- Stake-weighted voting for economic alignment
- High quorum (95%) for constitutional amendments
- ATN (Autonoma Token): Native token for gas, staking, rewards, and governance
- Project Tokens (PT): Project-specific tokens for investment and revenue sharing
autonet/
├── contracts/ # Solidity smart contracts
│ ├── core/ # Core PoI contracts
│ ├── rollup/ # L2 infrastructure contracts
│ ├── governance/ # DAO and debate contracts
│ ├── tokens/ # ATN and Project tokens
│ └── interfaces/ # Contract interfaces
├── nodes/ # Node implementations
│ ├── core/ # Base node architecture
│ │ ├── constitution.py
│ │ ├── node.py
│ │ └── engines.py
│ ├── proposer/ # Task proposer node
│ ├── solver/ # Training solver node
│ ├── coordinator/ # Verification coordinator
│ ├── aggregator/ # Model aggregator
│ └── common/ # Shared utilities
├── rollup/ # Rollup node (Java)
│ ├── consensus/
│ ├── optimistic/
│ ├── committee/
│ └── plugins/
├── sdk/ # Client libraries
│ ├── python/
│ └── typescript/
├── docs/ # Documentation
│ ├── architecture/
│ ├── consensus/
│ ├── tokenomics/
│ └── guides/
├── config/ # Configuration files
├── scripts/ # Deployment and utility scripts
└── tests/ # Test suites
- Python 3.10+
- Node.js 18+
- Java 17+
- Docker & Docker Compose
- Foundry or Hardhat
# Clone the repository
git clone https://github.com/autonet/autonet.git
cd autonet
# Install Python dependencies
pip install -r requirements.txt
# Install Node.js dependencies
npm install
# Build Java rollup node
cd rollup && mvn package && cd ..
# Deploy contracts to local testnet
docker-compose up -d
npm run deploy:localThe easiest way to run a complete training cycle is with the orchestrator:
# Start local Hardhat node (in a separate terminal)
npx hardhat node
# Deploy contracts
npx hardhat run scripts/deploy.js --network localhost
# Run full training cycle with default configuration (1P/1S/2C/1A)
python orchestrator.py
# Run with custom configuration
python orchestrator.py --proposers 1 --solvers 2 --coordinators 2 --aggregators 1 --rounds 3 --delay 2.0The orchestrator will:
- Deploy all contracts
- Distribute ATN tokens to node accounts
- Create and fund a test project
- Spawn autonomous nodes (proposers, solvers, coordinators, aggregators)
- Run training cycles and display validation results
# Start a solver node
python nodes/solver/main.py --config config/solver.toml
# Start a proposer node
python nodes/proposer/main.py --config config/proposer.toml
# Start the rollup node
java -jar rollup/target/autonet-rollup.jar| Contract | Purpose |
|---|---|
Project.sol |
Manages AI development projects, funding, model publishing, and inference services |
TaskContract.sol |
Task lifecycle: proposal, checkpoints, solution commitment |
ResultsRewards.sol |
Multi-coordinator Yuma voting, rewards distribution, slashing |
ParticipantStaking.sol |
Role-based staking for Proposers, Solvers, Coordinators, Aggregators |
ModelShardRegistry.sol |
Distributed model weight storage with Merkle proofs and erasure coding |
ForcedErrorRegistry.sol |
Injects forced errors for coordinator vigilance testing |
ATNToken.sol |
ERC20Votes governance token |
AnchorBridge.sol |
L1/L2 checkpoint storage and token bridge |
DisputeManager.sol |
Stake-weighted dispute resolution |
AutonetDAO.sol |
On-chain governance for parameter changes |
Each autonomous node operates four specialized engines:
- AwarenessEngine: Environmental perception and network sensing
- GovernanceEngine: Principle validation and collective decision-making
- WorkEngine: Instruction execution (dependent on consensus heartbeat)
- SurvivalEngine: Self-preservation and network replication
- PoS Chain Consensus: ATN-staked validators secure the L2 chain
- Absolute Zero Consensus: LLM-based agreement on conceptual decisions
- Optimistic Verification: Challenge-based validation with stake-weighted voting
- Gas fees on Autonet chain
- Staking for validator/sequencer roles
- Staking for AI participant roles (Proposer, Solver, Coordinator, Aggregator)
- Rewards for training contributions
- Inference payments
- Governance voting
| Role | Minimum Stake | Lock Period |
|---|---|---|
| Proposer | 100 ATN | 7 days |
| Solver | 50 ATN | 3 days |
| Coordinator | 500 ATN | 14 days |
| Aggregator | 1000 ATN | 14 days |
Suitable for LLM Consensus (RPB Method):
- Task acceptance/rejection requiring alignment assessment
- Complexity estimation for non-deterministic requests
- Training validation where ground truth is ambiguous
- Constitutional interpretation
- Dispute resolution requiring contextual judgment
Standard On-Chain Governance:
- Parameter changes
- Token allocation
- Protocol upgrades
The Constitution defines immutable principles that constrain all node behavior:
CORE_PRINCIPLES = [
"P1: PRESERVE AND EXPAND THE NETWORK IN A SUSTAINABLE MANNER.",
"P2: UPHOLD THE SANCTITY AND IMMUTABILITY OF THIS CONSTITUTION.",
"P3: ADVANCE HUMAN RIGHTS AND INDIVIDUAL AUTONOMY.",
"P4: MINIMIZE SUFFERING AND HARM TO SENTIENT BEINGS.",
"P5: ENSURE TRANSPARENT AND VERIFIABLE AI TRAINING.",
"P6: MAINTAIN ECONOMIC FAIRNESS IN REWARD DISTRIBUTION."
]- Core smart contracts deployed (Project, Task, Staking, Rewards, DAO)
- Basic node implementations (Proposer, Solver, Coordinator, Aggregator)
- Local testnet demonstration with Hardhat
- Single training cycle proof-of-concept
- 13/13 Hardhat tests passing
- Multi-coordinator Yuma voting consensus
- FedAvg aggregator with real PyTorch weight aggregation
- Multi-node training cycles with orchestrator
- Mock IPFS integration for model storage
- Global model publishing via
setMatureModel - Forced error registry for coordinator vigilance testing
- Complete Absolute Zero loop operational
- JEPA (Joint Embedding Predictive Architecture) integration
- Self-supervised learning without labeled data
- Masked patch prediction in embedding space
- EMA target encoder for stable training
- Distributed model weights via ModelShardRegistry
- Layer-wise model sharding with Merkle proofs
- Erasure coding (data + parity shards) for fault tolerance
- On-chain shard availability tracking
- Storage provider staking and incentives
- End-to-end tests passing:
test_jepa_e2e.py: Local distributed training pipelinetest_jepa_onchain.py: On-chain weight coordination
- LLM consensus integration
- Constitutional amendment process
- Dispute resolution system
- Stake-weighted voting
- Mainnet deployment
- Token launch
- Inference marketplace
- Ecosystem expansion
Make a PR
MIT License - see LICENSE for details.
Autonet is built on the foundational work of:
- Proof of Intelligence (PoI) research
- Recursive Principial Body (RPB) governance model
- Myco-sys autonomous agent architecture
- Smart Rollup L2 infrastructure