🧠 SOLANA $CLAWD
The Neural Operating System for Solana
██████╗ ███████╗
██╔═══██╗██╔════╝
██║ ██║███████╗
██║ ██║╚════██║
╚██████╔╝███████║
╚═════╝ ╚══════╝Recursive Intelligence • Token-Gated Inference • Autonomous Agents
Token Paper License: MIT PyTorch ## 🌐 What is Solana $CLAWD?
**Solana $CLAWD** is a token-gated AI infrastructure layer combining a **3.5M parameter Tiny Recursive Model (TRM)** with blockchain-native utility. It powers intelligent Solana development assistance, autonomous agents, and on-chain AI inference.┌─────────────────────────────────────────────────────────────────┐
│ SOLANA $CLAWD ECOSYSTEM │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ $CLAWD TRM │───▶│ CLAWDBOT │───▶│ INFERENCE │ │
│ │ Model │ │ Agent │ │ API │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
│ │ │ │ │
│ └──────────────────┼──────────────────┘ │
│ ▼ │
│ ┌─────────────┐ │
│ │ $CLAWD TOKEN│ │
│ │ UTILITY │ │
│ └─────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘
---
## 💰 $CLAWD Token Utility
The **$CLAWD token** unlocks access to the entire Solana $CLAWD ecosystem:
### 🎫 Tier System
| Tier | $CLAWD Holdings | Benefits |
|------|----------------|----------|
| 🥉 **Bronze** | 10,000 $CLAWD | 100 inference calls/day |
| 🥈 **Silver** | 100,000 $CLAWD | 1,000 inference calls/day + Clawdbot basic |
| 🥇 **Gold** | 500,000 $CLAWD | 5,000 inference calls/day + Clawdbot pro |
| 💎 **Diamond** | 1,000,000+ $CLAWD | Unlimited + Clawdbot autonomous + API keys |
### 🔑 Access Methods
**1. Hold to Access (Recommended)**
Simply hold $CLAWD tokens in your connected wallet to unlock tier benefits automatically.
**2. Burn for Credits**
Burn $CLAWD tokens to receive permanent inference credits:
- 1,000 $CLAWD burned = 500 inference credits (never expire)
**3. Stake for Premium**
Stake $CLAWD to earn yield while maintaining access:
- Staked tokens count toward tier qualification
- Earn additional $CLAWD from protocol fees
---
## 🤖 Clawdbot Integration
**Clawdbot** is an autonomous AI agent powered by Solana $CLAWD, capable of:
```typescript
// Clawdbot Capabilities
interface ClawdbotFeatures {
// Solana Development
codeAnalysis: "Smart contract review & optimization";
pdaGeneration: "Generate PDAs with derivation paths";
txBuilder: "Construct & simulate transactions";
// Autonomous Actions
portfolioMonitor: "Track & alert on positions";
dexAggregation: "Find optimal swap routes";
yieldFarming: "Auto-compound strategies";
// Intelligence
marketAnalysis: "Real-time sentiment & signals";
contractAudit: "Security vulnerability detection";
documentation: "Auto-generate project docs";
}Clawdbot Access Tiers
Feature Silver Gold Diamond Q&A Responses ✅ ✅ ✅ Code Analysis ✅ ✅ ✅ Transaction Building ❌ ✅ ✅ Autonomous Monitoring ❌ ❌ ✅ Custom Agent Training ❌ ❌ ✅ API Access ❌ ❌ ✅
🧠 Model Architecture
Solana $CLAWD is built on the Tiny Recursive Model (TRM) architecture:
┌────────────────────────────────────────────────────────┐
│ TRM-SOLANA-CLAWD ARCHITECTURE │
├────────────────────────────────────────────────────────┤
│ │
│ Input: "What is a PDA?" │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────┐ │
│ │ BYTE-LEVEL TOKENIZATION │ │
│ │ (UTF-8 → 258 vocab tokens) │ │
│ └─────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────┐ │
│ │ RECURSIVE REASONING CORE │ │
│ │ ┌─────────────────────────────────────────┐ │ │
│ │ │ H-Cycle 1 ──▶ H-Cycle 2 │ │ │
│ │ │ │ │ │ │ │
│ │ │ ▼ ▼ │ │ │
│ │ │ L-Cycle 1,2 L-Cycle 1,2 │ │ │
│ │ └─────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ Output: Refined Solana expertise │
│ │
└────────────────────────────────────────────────────────┘Specifications
Component Value Parameters 3.5M (~1/1000th of GPT-3) Layers (L) 1 transformer layer High-level cycles (H) 2 reasoning iterations Low-level cycles (L) 2 refinement iterations Vocabulary 258 tokens (byte-level) Max Sequence 512 tokens Inference CPU/MPS/GPU compatible Memory <1GB during inference
🚀 Quick Start
1. Connect Wallet & Verify Holdings
1 import { Connection , PublicKey } from '@solana/web3.js' ;
2 import { getAssociatedTokenAddress , getAccount } from '@solana/spl-token' ;
3 const CLAWD_TOKEN_MINT = new PublicKey ( '8cHzQHUS2s2h8TzCmfqPKYiM4dSt4roa3n7MyRLApump' ) ;
4 async function checkCLAWDBalance ( walletPubkey : PublicKey ) : Promise < number > {
5 const connection = new Connection ( 'https://api.mainnet-beta.solana.com' ) ;
6
7 const ata = await getAssociatedTokenAddress ( CLAWD_TOKEN_MINT , walletPubkey ) ;
8
9 try {
10 const account = await getAccount ( connection , ata ) ;
11 return Number ( account . amount ) / 1e6 ; // Assuming 6 decimals
12 } catch {
13 return 0 ;
14 }
15 }
16 function getTier ( balance : number ) : string {
17 if ( balance >= 1_000_000 ) return 'diamond' ;
18 if ( balance >= 500_000 ) return 'gold' ;
19 if ( balance >= 100_000 ) return 'silver' ;
20 if ( balance >= 10_000 ) return 'bronze' ;
21 return 'none' ;
22 }
2. API Inference
1 // Token-gated inference endpoint
2 const response = await fetch ( 'https://api.solana-clawd.ai/v1/inference' , {
3 method : 'POST' ,
4 headers : {
5 'Content-Type' : 'application/json' ,
6 'X-Wallet-Address' : walletAddress ,
7 'X-Signature' : signedMessage , // Prove wallet ownership
8 } ,
9 body : JSON . stringify ( {
10 question : 'How do I create a PDA in Anchor?' ,
11 model : 'trm-solana-clawd-v1' ,
12 max_tokens : 512 ,
13 } ) ,
14 } ) ;
15 const { answer , tokens_used , remaining_calls } = await response . json ( ) ;
3. Clawdbot Discord/Telegram
# Discord Commands (Silver+ tier)
/clawdbot ask "What is rent exemption in Solana?"
/clawdbot analyze <contract_address>
/clawdbot build-tx transfer 1 SOL to <address>
# Telegram Commands
/ask What are CPIs?
/audit <program_id>
/monitor <token_address>🔧 Self-Hosted Inference
For Diamond tier holders, run the model locally:
Installation
1 # Clone the repository
2 git clone https://github.com/8bitlabs/solana-clawd-model
3 cd solana-clawd-model
4 # Install dependencies
5 pip install torch transformers huggingface_hub numpy
6 # Download model
7 python scripts/download_model.py --token YOUR_HF_TOKEN
Local Inference
1 import torch
2 import numpy as np
3 from huggingface_hub import hf_hub_download
4 from models . trm import TinyRecursiveReasoningModel
5 # Download checkpoint
6 checkpoint_path = hf_hub_download (
7 repo_id = "ordlibrary/trm-solana-clawd-v1" ,
8 filename = "model.pt"
9 )
10 # Load model
11 checkpoint = torch . load ( checkpoint_path , map_location = 'cpu' )
12 model = TinyRecursiveReasoningModel ( ** checkpoint [ 'config' ] [ 'arch' ] )
13 model . load_state_dict ( checkpoint [ 'model_state_dict' ] )
14 model . eval ( )
15 # Byte-level encoding
16 def encode ( text : str , max_len : int = 512 ) - > torch . Tensor :
17 bytes_arr = np . frombuffer ( text . encode ( 'utf-8' ) , dtype = np . uint8 )
18 tokens = ( bytes_arr + 2 ) . astype ( np . uint8 )
19 seq = np . zeros ( max_len , dtype = np . uint8 )
20 seq [ : min ( len ( tokens ) , max_len - 1 ) ] = tokens [ : max_len - 1 ]
21 seq [ min ( len ( tokens ) , max_len - 1 ) ] = 1 # EOS
22 return torch . tensor ( seq ) . unsqueeze ( 0 )
23 def decode ( tokens : torch . Tensor ) - > str :
24 tokens = tokens . squeeze ( ) . numpy ( )
25 tokens = tokens [ tokens > 1 ] - 2 # Remove PAD/EOS, unshift
26 return bytes ( tokens ) . decode ( 'utf-8' , errors = 'replace' )
27 # Inference
28 question = "What is a Program Derived Address (PDA) in Solana?"
29 input_tensor = encode ( question )
30 with torch . no_grad ( ) :
31 output = model ( input_tensor )
32 answer = decode ( output . argmax ( dim = - 1 ) )
33 print ( answer )
📊 Training Details
Dataset
Metric Value Total Pairs 8,970 Q&A Training Set 8,073 (90%) Test Set 897 (10%) Topics Solana architecture, accounts, programs, transactions, security, DeFi Encoding Byte-level UTF-8
Training Configuration
1 # config/training.yaml
2 architecture :
3 L_layers : 1
4 H_cycles : 2
5 L_cycles : 2
6 vocab_size : 258
7 max_seq_len : 512
8 training :
9 epochs : 5000
10 global_batch_size : 64
11 learning_rate : 1e-4
12 weight_decay : 0.5
13 ema_enabled : true
14 ema_rate : 0.999
15 hardware :
16 device : mps # Apple Silicon
17 training_time : "~4 hours"
Performance
Metric Value Training Loss ~2.3 Test Loss ~2.5 Inference Speed <100ms Memory Usage <1GB
🎯 Example Queries
The Solana $CLAWD model excels at:
┌────────────────────────────────────────────────────────┐
│ EXAMPLE QUERIES │
├────────────────────────────────────────────────────────┤
│ │
│ ✓ "What is a Program Derived Address (PDA)?" │
│ ✓ "How do Solana transactions differ from Ethereum?" │
│ ✓ "Explain the Solana account model" │
│ ✓ "What is rent exemption?" │
│ ✓ "How do cross-program invocations (CPI) work?" │
│ ✓ "What is the System Program?" │
│ ✓ "How does Anchor simplify Solana development?" │
│ ✓ "What are the security best practices for PDAs?" │
│ │
└────────────────────────────────────────────────────────┘🛡️ Tokenomics
┌─────────────────────────────────────────────────────────┐
│ $CLAWD TOKENOMICS │
├─────────────────────────────────────────────────────────┤
│ │
│ Token: $CLAWD │
│ Contract: 8cHzQHUS2s2h8TzCmfqPKYiM4dSt4roa3n7MyRLApump │
│ Chain: Solana │
│ Standard: SPL Token │
│ │
│ ┌─────────────────────────────────────────────────┐ │
│ │ UTILITY FLYWHEEL │ │
│ │ │ │
│ │ ┌──────────┐ │ │
│ │ │ HOLD │◀─────────────────┐ │ │
│ │ │ $CLAWD │ │ │ │
│ │ └────┬─────┘ │ │ │
│ │ │ │ │ │
│ │ ▼ │ │ │
│ │ ┌──────────┐ ┌─────┴────┐ │ │
│ │ │ ACCESS │ │ VALUE │ │ │
│ │ │ TIERS │ │ ACCRUAL │ │ │
│ │ └────┬─────┘ └──────────┘ │ │
│ │ │ ▲ │ │
│ │ ▼ │ │ │
│ │ ┌──────────┐ ┌─────┴────┐ │ │
│ │ │ USE │───────────▶│ DEMAND │ │ │
│ │ │ SERVICES│ │ GROWS │ │ │
│ │ └──────────┘ └──────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────┘ │
│ │
│ Revenue Streams: │
│ • Inference API fees → 50% to stakers │
│ • Clawdbot premium features → 30% buyback & burn │
│ • Enterprise licensing → Treasury │
│ │
└─────────────────────────────────────────────────────────┘🔗 Integration Examples
Next.js App Router
1 // app/api/inference/route.ts
2 import { NextRequest , NextResponse } from 'next/server' ;
3 import { verifyWalletSignature , checkTier } from '@/lib/auth' ;
4 export async function POST ( req : NextRequest ) {
5 const { question , walletAddress , signature } = await req . json ( ) ;
6
7 // Verify wallet ownership
8 const isValid = await verifyWalletSignature ( walletAddress , signature ) ;
9 if ( ! isValid ) {
10 return NextResponse . json ( { error : 'Invalid signature' } , { status : 401 } ) ;
11 }
12
13 // Check $CLAWD holdings
14 const tier = await checkTier ( walletAddress ) ;
15 if ( tier === 'none' ) {
16 return NextResponse . json ( {
17 error : 'Insufficient $CLAWD holdings' ,
18 required : 10000 ,
19 contract : '8cHzQHUS2s2h8TzCmfqPKYiM4dSt4roa3n7MyRLApump'
20 } , { status : 403 } ) ;
21 }
22
23 // Process inference
24 const answer = await runInference ( question ) ;
25
26 return NextResponse . json ( { answer , tier } ) ;
27 }
React Hook
1 // hooks/useSolanaCLAWD.ts
2 import { useWallet } from '@solana/wallet-adapter-react' ;
3 import { useState } from 'react' ;
4 export function useSolanaCLAWD ( ) {
5 const { publicKey , signMessage } = useWallet ( ) ;
6 const [ loading , setLoading ] = useState ( false ) ;
7
8 const askQuestion = async ( question : string ) => {
9 if ( ! publicKey || ! signMessage ) {
10 throw new Error ( 'Wallet not connected' ) ;
11 }
12
13 setLoading ( true ) ;
14
15 try {
16 // Sign message to prove ownership
17 const message = new TextEncoder ( ) . encode ( ` Solana CLAWD: ${ Date . now ( ) } ` ) ;
18 const signature = await signMessage ( message ) ;
19
20 const response = await fetch ( '/api/inference' , {
21 method : 'POST' ,
22 headers : { 'Content-Type' : 'application/json' } ,
23 body : JSON . stringify ( {
24 question ,
25 walletAddress : publicKey . toBase58 ( ) ,
26 signature : Buffer . from ( signature ) . toString ( 'base64' ) ,
27 } ) ,
28 } ) ;
29
30 return await response . json ( ) ;
31 } finally {
32 setLoading ( false ) ;
33 }
34 } ;
35
36 return { askQuestion , loading } ;
37 }
⚠️ Limitations
Limitation Description Domain Specific Trained only on Solana content Knowledge Cutoff Limited to training data timeframe Not for Audits Do not use for production security audits English Only Trained exclusively on English data Q&A Format Optimized for questions, not conversations
📜 License
MIT License - Open source and free to use.
🙏 Acknowledgments
Alexia Jolicoeur-Martineau - TRM ArchitectureSolana Foundation - Documentation & EcosystemOrdLibrary - Original model training8bit Labs - $CLAWD Token Integration
📚 Resources
## 💎 Get $CLAWD Now
```
8cHzQHUS2s2h8TzCmfqPKYiM4dSt4roa3n7MyRLApump
```
**[Pump.fun](https://pump.fun/8cHzQHUS2s2h8TzCmfqPKYiM4dSt4roa3n7MyRLApump)** • **[DexScreener](https://dexscreener.com/solana/8cHzQHUS2s2h8TzCmfqPKYiM4dSt4roa3n7MyRLApump)** • **[Birdeye](https://birdeye.so/token/8cHzQHUS2s2h8TzCmfqPKYiM4dSt4roa3n7MyRLApump)**
---
**Built by [8bit Labs](https://8bitlabs.ai) for the Solana ecosystem**
*The Neural Operating System for Solana*
```
