A compute-native Layer 1 blockchain powered by Proof of X (PoX) consensus
Mbongo Chain is a Rust-native, compute-first blockchain that combines Proof of Stake (PoS) with Proof of Useful Work (PoUW) to create a decentralized GPU compute network. By rewarding validators for both staking tokens and performing verifiable AI/ML computations, Mbongo Chain enables affordable, trustless compute while maintaining strong economic security.
Democratize access to GPU compute through decentralized, verifiable infrastructure.
The AI revolution is bottlenecked by expensive, centralized compute infrastructure. Mbongo Chain solves this by:
- Reducing costs by 30-50% compared to AWS/GCP through decentralized GPU markets
- Ensuring trust via cryptographic verification of compute results
- Preventing centralization through diminishing returns and adaptive economics
- Enabling Web3-native AI with on-chain verification and DAO-friendly governance
Phase 1 (Foundation) is COMPLETE and FROZEN.
- Phase 1 completion date: December 2025
- Status: No new Phase 1 changes will be accepted
- Scope: Block structure, Transaction model (Transfer-only), Account model, Cryptography, State storage
Phase 2 is now ACTIVE.
- Phase 2 start date: January 2026
- Status: Active development
- Branch: All Phase 2 development MUST target the
devbranch - Scope: TEE integration, networking, API, tooling, and higher-layer features
Branch Policy:
main: Reserved for audited, stable milestones only. Protected branch.dev: Active development branch for Phase 2 work. All pull requests must targetdev.
Mbongo Chain introduces PoX consensus, a novel hybrid mechanism that combines:
- Proof of Stake (PoS): Economic security through token staking (MBO)
- Proof of Useful Work (PoUW): Validators earn rewards by executing real AI/ML workloads
- Proof of Compute (PoC): Scoring system for computational contributions
Formula:
total_weight = (stake_weight × C_SR) + (√(poc_score) × C_NL)
Where C_SR and C_NL are dynamically adjusted by AIDA to maintain network balance.
Adaptive Intelligence for Dynamic Adjustment (AIDA) is an on-chain regulator that:
- Monitors stake-to-work ratio in real-time
- Dynamically adjusts consensus coefficients (C_SR, C_NL) to maintain 50/50 balance
- Prevents stake or compute dominance through automatic rebalancing
- Ensures long-term decentralization and economic sustainability
Mbongo Chain ensures compute correctness through a progressive verification strategy:
Phase 1 (Current): Redundant Execution
- 3 randomly selected validators verify each task
- 2/3 majority consensus required
- Optimistic fraud proofs with 100-block challenge period
Phase 2 (January 2026+): Trusted Execution Environments (TEE)
- Intel SGX / AMD SEV support
- Reduced redundancy (1 TEE + 2 standard validators)
- Remote attestation verification
Phase 3 (2026+): Zero-Knowledge Machine Learning (ZK-ML)
- Cryptographic proofs of correct computation
- O(1) verification time
- Privacy-preserving AI execution
- Square root function on PoC scores creates diminishing returns
- Large providers earn 3.16× more by splitting into 10 nodes vs 1 large node
- AIDA automatically adjusts incentives if centralization is detected
- No whale dominance: built-in economic pressure for decentralization
- MBO: Native utility token for staking, compute payments, and governance
- Compute Credits: Off-chain credits for seamless developer experience (optional)
- Flexible payment: MBO, stablecoins (USDC/DAI), or fiat conversion
Mbongo Chain is built entirely in Rust for performance, safety, and WebAssembly compatibility.
┌─────────────────────────────────────────────────────────────┐
│ Mbongo Chain │
├─────────────────────────────────────────────────────────────┤
│ Application Layer │
│ ├─ Compute Marketplace (task submission/matching) │
│ ├─ Staking Interface (validator registration) │
│ └─ Governance (DAO voting, parameter updates) │
├─────────────────────────────────────────────────────────────┤
│ Consensus Layer │
│ ├─ PoX Engine (stake + work weight calculation) │
│ ├─ AIDA Regulator (coefficient adjustment) │
│ ├─ Block Production (weighted validator selection) │
│ └─ Finality Gadget (BFT finalization) │
├─────────────────────────────────────────────────────────────┤
│ Verification Layer │
│ ├─ Redundant Execution (Phase 1) │
│ ├─ Fraud Proof System (challenge/arbitration) │
│ ├─ TEE Attestation (Phase 2) │
│ └─ ZK Proof Verification (Phase 3) │
├─────────────────────────────────────────────────────────────┤
│ Execution Layer │
│ ├─ Compute Runtime (Docker/WASM isolation) │
│ ├─ Resource Metering (CPU/GPU/RAM tracking) │
│ └─ Result Storage (IPFS/Arweave integration) │
├─────────────────────────────────────────────────────────────┤
│ Network Layer │
│ ├─ P2P Networking (libp2p) │
│ ├─ Block Propagation │
│ └─ Validator Discovery │
├─────────────────────────────────────────────────────────────┤
│ Storage Layer │
│ ├─ State Database (RocksDB) │
│ ├─ Block Storage │
│ └─ Merkle Tree (state commitments) │
└─────────────────────────────────────────────────────────────┘
mbongo-chain/
├── crates/
│ ├── mbongo-core/ # Core blockchain primitives
│ │ ├── types/ # Block, transaction, account types
│ │ ├── crypto/ # Cryptographic functions (hashing, signing)
│ │ └── storage/ # State management and persistence
│ │
│ ├── mbongo-consensus/ # PoX consensus implementation
│ │ ├── pox/ # PoX engine (stake + work weight)
│ │ ├── aida/ # AIDA regulator logic
│ │ ├── selection/ # Validator selection algorithm
│ │ └── finality/ # BFT finality gadget
│ │
│ ├── mbongo-verification/ # Compute verification layer
│ │ ├── redundant/ # Redundant execution (Phase 1)
│ │ ├── fraud_proofs/ # Optimistic fraud proof system
│ │ ├── tee/ # TEE attestation (Phase 2)
│ │ └── zk/ # ZK-ML proof verification (Phase 3)
│ │
│ ├── mbongo-compute/ # Compute execution runtime
│ │ ├── executor/ # Task execution engine
│ │ ├── metering/ # Resource usage tracking
│ │ ├── scheduler/ # Task scheduling and prioritization
│ │ └── isolation/ # Sandbox (Docker/WASM)
│ │
│ ├── mbongo-network/ # P2P networking
│ │ ├── p2p/ # libp2p integration
│ │ ├── rpc/ # JSON-RPC API server
│ │ └── sync/ # Block synchronization
│ │
│ ├── mbongo-runtime/ # Smart contract execution
│ │ ├── wasm/ # WebAssembly VM
│ │ ├── precompiles/ # Native precompiled contracts
│ │ └── gas/ # Gas metering
│ │
│ ├── mbongo-api/ # External APIs
│ │ ├── rest/ # REST API for compute jobs
│ │ ├── ws/ # WebSocket subscriptions
│ │ └── sdk/ # Client libraries (Rust, JS, Python)
│ │
│ ├── mbongo-wallet/ # Wallet and key management
│ │ ├── keystore/ # Encrypted key storage
│ │ ├── signing/ # Transaction signing
│ │ └── cli/ # CLI wallet interface
│ │
│ └── mbongo-node/ # Full node binary
│ ├── config/ # Node configuration
│ ├── telemetry/ # Metrics and monitoring
│ └── main.rs # Node entry point
│
├── docs/ # Documentation
├── scripts/ # Build and deployment scripts
├── tests/ # Integration tests
└── Cargo.toml # Workspace manifest
Key Dependencies:
- substrate-primitives: Core blockchain types (adapted)
- libp2p: P2P networking
- tokio: Async runtime
- serde: Serialization/deserialization
- rocksdb: Database backend
- ed25519-dalek: Cryptographic signing
- blake3: Fast hashing
- wasmtime: WebAssembly runtime
- Rust 1.75 or higher (install via rustup)
- Git
- Docker (optional, for compute execution)
- 16GB+ RAM recommended for full node
# Clone the repository
git clone https://github.com/mbongo-chain/mbongo-chain.git
cd mbongo-chain
# Build the project (release mode)
cargo build --release
# Run tests
cargo test --all
# Build documentation
cargo doc --no-deps --open# Run a development node (single validator, instant finality)
./target/release/mbongo-node --dev
# Run a node connected to testnet
./target/release/mbongo-node \
--chain testnet \
--bootnodes /ip4/35.123.45.67/tcp/30333/p2p/12D3KooWExample
# Run a validator node
./target/release/mbongo-node \
--chain mainnet \
--validator \
--name "My Validator" \
--rpc-port 9933 \
--ws-port 9944# Register as a compute provider
mbongo-cli provider register \
--gpu nvidia-rtx-4090 \
--stake 10000 \
--commission 5
# Start providing compute
./target/release/mbongo-node \
--chain mainnet \
--provider \
--compute-threads 4 \
--max-gpu-memory 24GB# Using the REST API
curl -X POST http://localhost:9933/compute/submit \
-H "Content-Type: application/json" \
-d '{
"model": "meta-llama/Llama-2-70b-chat-hf",
"input": "Explain quantum computing in simple terms",
"max_tokens": 500,
"payment": {
"amount": "100",
"currency": "MBO"
}
}'
# Response
{
"job_id": "0x1234...5678",
"status": "pending",
"estimated_completion": "30s",
"cost": "100 MBO"
}For detailed setup instructions, see:
Comprehensive documentation is available in the docs/ directory:
- Consensus Mechanics: Complete PoUW consensus specification
- PoX Formula: Mathematical formula for validator weight calculation
- Verification Strategy: Multi-layer compute verification approach
- AIDA Specification: Adaptive regulator design (coming soon)
- Economic Model: Tokenomics and incentive structure (coming soon)
- Full Node Setup: Running a full node
- Validator Setup: Becoming a validator
- Compute Provider Setup: Providing GPU compute
- Target Market Analysis: Customer segments and competitive positioning
- Roadmap: Development phases and milestones (coming soon)
- API Reference: REST and WebSocket API documentation (coming soon)
- SDK Documentation: Client library usage (coming soon)
Symbol: MBO (Mbongo) Max Supply: 31,536,000 MBO (one token per second per year) Decimals: 18
| Allocation | Amount | Percentage | Vesting |
|---|---|---|---|
| Validators & Compute Providers | 15,768,000 MBO | 50% | Ongoing emissions (10 years) |
| Community & Ecosystem | 6,307,200 MBO | 20% | 4 years linear |
| Team & Advisors | 4,730,400 MBO | 15% | 4 years, 1-year cliff |
| Investors | 3,153,600 MBO | 10% | 3 years, 6-month cliff |
| Treasury & DAO | 1,576,800 MBO | 5% | Governance-controlled |
Year 1: 3,153,600 MBO (10% of max supply)
Year 2: 2,522,880 MBO (20% reduction)
Year 3: 2,018,304 MBO (20% reduction)
...
Year 10: ~315,360 MBO (final emissions)
Block Rewards (decreasing over time):
- Year 1: ~6 MBO per block (6-second blocks)
- Year 5: ~2.5 MBO per block
- Year 10: ~0.6 MBO per block
Reward Split:
- 70% to validators (stake + compute)
- 20% to compute providers (pure compute)
- 10% to treasury (governance + development)
For detailed tokenomics, see Economic Model (coming soon).
Status: COMPLETE and FROZEN
- Core blockchain implementation (Rust)
- Block structure
- Transaction model (Transfer-only with chain_id)
- Account model
- State storage
- Cryptographic primitives (Ed25519 signing/verification)
Deliverables Completed:
- Core blockchain primitives in
mbongo-core - Transaction structure with mandatory chain_id for replay protection
- SCALE encoding for transactions
- State management with in-memory storage
- Account operations (credit, debit, nonce)
Status: ACTIVE (development on dev branch)
- TEE integration (Intel SGX, AMD SEV)
- Hybrid verification (1 TEE + 2 standard)
- Compute provider SDK (Rust, JavaScript, Python)
- REST API and WebSocket support
- Mainnet candidate launch
- DAO governance activation
Deliverables:
- Mainnet launch with TEE support
- 200+ validators, 100+ compute providers
- Public API for developers
- On-chain governance
Status: Planned (not yet active)
- ZK-ML proof generation and verification
- Privacy-preserving compute
- Cross-chain bridges (Ethereum, Cosmos, Polkadot)
- Enterprise-grade SLAs
- Advanced fraud detection (ML-based)
Deliverables:
- Full ZK-ML verification
- Multi-chain compute orchestration
- Enterprise partnerships
- 1,000+ validators globally
Target: AI startups, SaaS companies
Problem: High LLM inference costs ($0.50+/1M tokens on AWS)
Solution:
- Run Llama 2 70B for $0.25/1M tokens (50% savings)
- OpenAI-compatible API
- Pay in MBO or stablecoins
Example:
import mbongo
client = mbongo.Client(api_key="your_key")
response = client.inference(
model="meta-llama/Llama-2-70b-chat-hf",
messages=[
{"role": "user", "content": "Explain PoX consensus"}
],
max_tokens=500
)
print(response.text)
# Cost: ~0.05 MBO (~$0.10)Target: Decentralized Autonomous Organizations
Problem: Can't trust centralized AI for governance decisions
Solution:
- Cryptographically verified AI analysis
- On-chain result verification
- Fraud-proof guarantees
Example:
// Smart contract integration
contract ProposalAnalyzer {
function analyzeProposal(string memory proposalText)
external returns (bytes32 jobId)
{
// Submit to Mbongo Chain
jobId = mbongoCompute.submit(
"proposal-analysis",
proposalText,
100 * 1e18 // 100 MBO payment
);
// Result verified via fraud proofs
// DAO trusts the analysis
}
}Target: Solo developers, students, hobbyists
Problem: Can't afford $1,500+ GPUs or $2+/hour cloud costs
Solution:
- Pay-per-use GPU access at $0.50-1/hour
- No upfront investment
- Generous free tier (5 hours/month)
Example:
# Fine-tune a model without owning a GPU
mbongo-cli compute run \
--image pytorch/pytorch:latest \
--gpu nvidia-rtx-4090 \
--script train.py \
--budget 10 MBO
# Total cost: ~$5 for 10 hours of RTX 4090 timeRust is required only for core protocol development. We encourage contributors using a wide range of technologies and skill sets.
Contributions are welcome using:
- Python: SDK development, AI/ML tooling, testing automation
- Go: Infrastructure tools, monitoring, auxiliary services
- JavaScript/TypeScript: Web interfaces, client SDKs, tooling
- C++: Performance-critical components, GPU compute integration
- CUDA: GPU computation, performance optimization
- Bash/PowerShell: Scripts, automation, deployment tooling
You can contribute in the following areas:
Testing & QA:
- Integration testing frameworks
- End-to-end test scenarios
- Performance benchmarking
- Security testing and fuzzing
Tooling:
- Developer utilities and CLI improvements
- Monitoring dashboards and observability tools
- Local development environment setup
- Debugging and diagnostic tools
AI / GPU Compute:
- Compute task verification strategies
- Model optimization for blockchain execution
- GPU resource management
- ZK-ML proof research and implementation
Infrastructure:
- CI/CD pipeline configuration
- Cloud deployment automation
- Container orchestration
- Network infrastructure setup
Documentation:
- Technical documentation
- API reference guides
- Tutorials and how-to guides
- Translation and localization
Phase 2 development happens on the dev branch. All pull requests for Phase 2 work must target dev.
GitHub issues are labeled to help you find areas that match your skills:
phase-2: Active Phase 2 development worktesting: Testing and QA opportunitiestooling: Developer tooling and utilitiesai-compute: AI and GPU compute workinfrastructure: Infrastructure and DevOpsdocumentation: Documentation improvements
See Contributing Guide for detailed contribution guidelines and Contributing Roles for role definitions.
If you want to help build Mbongo Chain, there is a place for you.
We welcome contributions from the community! Mbongo Chain is open-source and community-driven.
- Fork the repository
- Create a feature branch (
git checkout -b feature/amazing-feature) - Commit your changes (
git commit -m 'Add amazing feature') - Push to the branch (
git push origin feature/amazing-feature) - Open a Pull Request
- Code Style: Follow Rust standard style (
cargo fmt) - Testing: Add tests for new features (
cargo test) - Documentation: Document public APIs with Rustdoc comments
- Commit Messages: Use conventional commits (e.g.,
feat:,fix:,docs:)
- Core Development: Consensus, networking, storage
- Verification: TEE integration, ZK proof research
- Compute Runtime: GPU scheduling, isolation, metering
- Tooling: CLI improvements, monitoring dashboards
- Documentation: Tutorials, guides, translations
- Testing: Integration tests, fuzzing, benchmarks
- Discord: discord.gg/mbongo-chain (coming soon)
- Twitter: @mbongo_chain (coming soon)
- Forum: forum.mbongochain.com (coming soon)
- GitHub Discussions: Discussions
If you discover a security vulnerability, please email security@mbongochain.com. Do not open public issues for security vulnerabilities.
We offer bug bounties for critical vulnerabilities:
- Critical: Up to 50,000 MBO
- High: Up to 20,000 MBO
- Medium: Up to 5,000 MBO
- Low: Up to 1,000 MBO
- Phase 1: Internal security review (Completed — December 2025)
- Phase 2: External audit by Certik (Planned — 2026)
- Phase 3: Ongoing bug bounty program (Mainnet launch)
This project is licensed under the Apache License 2.0 - see the LICENSE file for details.
Copyright 2025 Mbongo Chain Contributors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Mbongo Chain is inspired by and builds upon the work of:
- Substrate (Parity Technologies) - Blockchain framework architecture
- Ethereum - Smart contract design and EVM compatibility goals
- Filecoin - Proof of useful work concepts
- Cosmos - Inter-blockchain communication
- Gensyn - ML verification research
- Akash Network - Decentralized compute marketplace
Special thanks to the Rust blockchain community for tooling and support.
- Website: mbongochain.com (coming soon)
- Documentation: docs.mbongochain.com (coming soon)
- Block Explorer: explorer.mbongochain.com (coming soon)
- GitHub: github.com/mbongo-chain/mbongo-chain
Built with ❤️ in Rust for a decentralized AI future.