Update README.md

README.md

@@ -2,13 +2,13 @@
 license: mit
 tags:
 - recursive-reasoning
+- solana-os
+- blockchain-ai
 - tiny-model
-- solana
-- blockchain
 - question-answering
 - trm
-- tiny-recursive-model
-- efficient-ai
+- token-gated
+- defi-ai
 datasets:
 - solana-qa
 language:
@@ -20,147 +20,277 @@ library_name: pytorch
 pipeline_tag: text-generation
 ---
 
-# Tiny Recursive Model for Solana Q&A
+<div align="center">
 
-Powered by Solana $OS
+# 🧠 SOLANA $OS
 
-DrU9M6SUaXWua49zeaHQWJuwMpcZ4jMDRT3J5Ywpump
-<div align="center">
+### The Neural Operating System for Solana
 
-**TRM-Solana** | A 3.5M parameter recursive reasoning model trained on Solana blockchain Q&A
+```
+ ██████╗ ███████╗
+██╔═══██╗██╔════╝
+██║   ██║███████╗
+██║   ██║╚════██║
+╚██████╔╝███████║
+ ╚═════╝ ╚══════╝
+```
 
-[![Paper](https://img.shields.io/badge/Paper-arXiv-red)](https://arxiv.org/abs/2510.04871)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![PyTorch](https://img.shields.io/badge/PyTorch-2.0+-ee4c2c?logo=pytorch&logoColor=white)](https://pytorch.org/)
+**Recursive Intelligence • Token-Gated Inference • Autonomous Agents**
 
-</div>
+[![Token](https://img.shields.io/badge/$OS-DrU9M6...pump-9945FF?style=for-the-badge&logo=solana)](https://pump.fun/DrU9M6SUaXWua49zeaHQWJuwMpcZ4jMDRT3J5Ywpump)
+[![Paper](https://img.shields.io/badge/Paper-arXiv-red?style=for-the-badge)](https://arxiv.org/abs/2510.04871)
+[![License: MIT](https://img.shields.io/badge/License-MIT-14F195?style=for-the-badge)](https://opensource.org/licenses/MIT)
+[![PyTorch](https://img.shields.io/badge/PyTorch-2.0+-ee4c2c?style=for-the-badge&logo=pytorch&logoColor=white)](https://pytorch.org/)
+
+---
 
-## Model Description
+### 💎 Token Contract Address
 
-This is a **Tiny Recursive Model (TRM)** fine-tuned on Solana blockchain development Q&A data. Unlike massive language models requiring billions of parameters, TRM achieves strong performance through *recursive reasoning* with just **3.5 million parameters**.
+```
+DrU9M6SUaXWua49zeaHQWJuwMpcZ4jMDRT3J5Ywpump
+```
 
-### Key Features
+[Buy on Pump.fun](https://pump.fun/DrU9M6SUaXWua49zeaHQWJuwMpcZ4jMDRT3J5Ywpump) • [DexScreener](https://dexscreener.com/solana/DrU9M6SUaXWua49zeaHQWJuwMpcZ4jMDRT3J5Ywpump) • [Birdeye](https://birdeye.so/token/DrU9M6SUaXWua49zeaHQWJuwMpcZ4jMDRT3J5Ywpump)
 
-- 🔬 **Tiny Architecture**: Only 3.5M parameters (~1/1000th the size of GPT-3)
-- 🧠 **Recursive Reasoning**: Iteratively refines answers through multiple reasoning cycles
-- ⚡ **Efficient**: Runs on consumer hardware (CPU/MPS/small GPUs)
-- 🎯 **Specialized**: Trained specifically on Solana blockchain development
-- 📚 **Well-documented**: Based on peer-reviewed research
+</div>
+
+---
 
-### Architecture
+## 🌐 What is Solana $OS?
+
+**Solana $OS** 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.
 
 ```
-Model: TinyRecursiveReasoningModel (TRM)
-├── Layers (L): 1 transformer layer
-├── High-level cycles (H): 2 reasoning iterations
-├── Low-level cycles (L): 2 refinement iterations
-├── Parameters: ~3.5M
-├── Vocabulary: 258 tokens (byte-level)
-├── Max sequence length: 512 tokens
-└── Embedding dim: Variable (based on architecture)
+┌─────────────────────────────────────────────────────────────────┐
+│                     SOLANA $OS ECOSYSTEM                        │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                 │
+│   ┌─────────────┐    ┌─────────────┐    ┌─────────────┐        │
+│   │   $OS TRM   │───▶│  CLAWDBOT   │───▶│  INFERENCE  │        │
+│   │   Model     │    │   Agent     │    │    API      │        │
+│   └─────────────┘    └─────────────┘    └─────────────┘        │
+│          │                  │                  │                │
+│          └──────────────────┼──────────────────┘                │
+│                             ▼                                   │
+│                    ┌─────────────┐                              │
+│                    │  $OS TOKEN  │                              │
+│                    │   UTILITY   │                              │
+│                    └─────────────┘                              │
+│                                                                 │
+└─────────────────────────────────────────────────────────────────┘
 ```
 
-## Intended Use
+---
 
-### Primary Use Cases
+## 💰 $OS Token Utility
 
-✅ **Solana Development Q&A**: Answer questions about Solana blockchain, smart contracts, and development
-✅ **Educational Tool**: Learning resource for Solana developers
-✅ **Code Assistance**: Understanding Solana program architecture and best practices
-✅ **Research**: Studying recursive reasoning in small models
+The **$OS token** unlocks access to the entire Solana OS ecosystem:
 
-### Out of Scope
+### 🎫 Tier System
 
-❌ General-purpose chat or conversation
-❌ Real-time transaction analysis
-❌ Production smart contract auditing (use professional auditors)
-❌ Non-Solana blockchain questions
+| Tier | $OS Holdings | Benefits |
+|------|-------------|----------|
+| 🥉 **Bronze** | 10,000 $OS | 100 inference calls/day |
+| 🥈 **Silver** | 100,000 $OS | 1,000 inference calls/day + Clawdbot basic |
+| 🥇 **Gold** | 500,000 $OS | 5,000 inference calls/day + Clawdbot pro |
+| 💎 **Diamond** | 1,000,000+ $OS | Unlimited + Clawdbot autonomous + API keys |
 
-## Training Details
+### 🔑 Access Methods
 
-### Training Data
+**1. Hold to Access (Recommended)**
+Simply hold $OS tokens in your connected wallet to unlock tier benefits automatically.
 
-- **Dataset**: Custom Solana Q&A corpus
-- **Size**: 8,970 question-answer pairs
-- **Split**: 90% training (8,073 examples) / 10% test (897 examples)
-- **Topics**: Solana architecture, smart contracts, transactions, accounts, programs, security
-- **Format**: Instruction-input-output tuples
-- **Encoding**: Byte-level tokenization (UTF-8)
+**2. Burn for Credits**
+Burn $OS tokens to receive permanent inference credits:
+- 1,000 $OS burned = 500 inference credits (never expire)
 
-### Training Procedure
+**3. Stake for Premium**
+Stake $OS to earn yield while maintaining access:
+- Staked tokens count toward tier qualification
+- Earn additional $OS from protocol fees
 
-- **Framework**: PyTorch 2.8+
-- **Hardware**: Apple Silicon (M1/M2/M3) with MPS acceleration
-- **Epochs**: 1,000 - 5,000 (varies by run)
-- **Batch Size**: 64 (global batch size)
-- **Learning Rate**: 1e-4
-- **Optimizer**: AdamW (CPU-compatible fallback)
-- **Weight Decay**: 0.5
-- **EMA**: Enabled (rate: 0.999)
-- **Gradient Clipping**: Standard
-- **Training Time**: ~2-4 hours on Apple Silicon
+---
 
-### Hyperparameters
+## 🤖 Clawdbot Integration
+
+**Clawdbot** is an autonomous AI agent powered by Solana $OS, 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";
+}
+```
 
-```yaml
-Architecture:
-  L_layers: 1
-  H_cycles: 2
-  L_cycles: 2
+### Clawdbot Access Tiers
 
-Training:
-  global_batch_size: 64
-  lr: 1e-4
-  puzzle_emb_lr: 1e-4
-  weight_decay: 0.5
-  ema: true
-  ema_rate: 0.999
+| Feature | Silver | Gold | Diamond |
+|---------|--------|------|---------|
+| Q&A Responses | ✅ | ✅ | ✅ |
+| Code Analysis | ✅ | ✅ | ✅ |
+| Transaction Building | ❌ | ✅ | ✅ |
+| Autonomous Monitoring | ❌ | ❌ | ✅ |
+| Custom Agent Training | ❌ | ❌ | ✅ |
+| API Access | ❌ | ❌ | ✅ |
 
-Data:
-  max_seq_len: 512
-  vocab_size: 258
-  encoding: byte-level (UTF-8)
+---
+
+## 🧠 Model Architecture
+
+Solana $OS is built on the **Tiny Recursive Model (TRM)** architecture:
+
+```
+┌────────────────────────────────────────────────────────┐
+│              TRM-SOLANA-OS 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
+
+```typescript
+import { Connection, PublicKey } from '@solana/web3.js';
+import { getAssociatedTokenAddress, getAccount } from '@solana/spl-token';
+
+const OS_TOKEN_MINT = new PublicKey('DrU9M6SUaXWua49zeaHQWJuwMpcZ4jMDRT3J5Ywpump');
+
+async function checkOSBalance(walletPubkey: PublicKey): Promise<number> {
+  const connection = new Connection('https://api.mainnet-beta.solana.com');
+  
+  const ata = await getAssociatedTokenAddress(OS_TOKEN_MINT, walletPubkey);
+  
+  try {
+    const account = await getAccount(connection, ata);
+    return Number(account.amount) / 1e6; // Assuming 6 decimals
+  } catch {
+    return 0;
+  }
+}
+
+function getTier(balance: number): string {
+  if (balance >= 1_000_000) return 'diamond';
+  if (balance >= 500_000) return 'gold';
+  if (balance >= 100_000) return 'silver';
+  if (balance >= 10_000) return 'bronze';
+  return 'none';
+}
 ```
 
-## Performance
+### 2. API Inference
+
+```typescript
+// Token-gated inference endpoint
+const response = await fetch('https://api.solana-os.ai/v1/inference', {
+  method: 'POST',
+  headers: {
+    'Content-Type': 'application/json',
+    'X-Wallet-Address': walletAddress,
+    'X-Signature': signedMessage, // Prove wallet ownership
+  },
+  body: JSON.stringify({
+    question: 'How do I create a PDA in Anchor?',
+    model: 'trm-solana-os-v1',
+    max_tokens: 512,
+  }),
+});
+
+const { answer, tokens_used, remaining_calls } = await response.json();
+```
 
-### Evaluation Metrics
+### 3. Clawdbot Discord/Telegram
 
-| Metric | Value | Notes |
-|--------|-------|-------|
-| Training Loss | ~2.3 | Final epoch |
-| Test Loss | ~2.5 | Held-out set |
-| Parameters | 3.5M | Extremely lightweight |
-| Inference Speed | Fast | CPU-compatible |
-| Memory Usage | <1GB | During inference |
+```
+# 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>
+```
 
-### Comparison
+---
 
-| Model | Parameters | Solana Q&A | Hardware Needed |
-|-------|-----------|------------|-----------------|
-| GPT-3 | 175B | Good | Expensive |
-| LLaMA-7B | 7B | Good | GPU required |
-| **TRM-Solana** | **3.5M** | **Specialized** | **CPU/MPS** |
+## 🔧 Self-Hosted Inference
 
-## How to Use
+For Diamond tier holders, run the model locally:
 
 ### Installation
 
 ```bash
+# Clone the repository
+git clone https://github.com/8bitlabs/solana-os-model
+cd solana-os-model
+
 # Install dependencies
-pip install torch transformers huggingface_hub
+pip install torch transformers huggingface_hub numpy
 
-# Or clone the full repo
-git clone https://github.com/AlexiaJM/TinyRecursiveModels
-cd TinyRecursiveModels
-pip install -r requirements.txt
+# Download model
+python scripts/download_model.py --token YOUR_HF_TOKEN
 ```
 
-### Download Model
+### Local Inference
 
 ```python
-from huggingface_hub import hf_hub_download
 import torch
+import numpy as np
+from huggingface_hub import hf_hub_download
+from models.trm import TinyRecursiveReasoningModel
 
 # Download checkpoint
 checkpoint_path = hf_hub_download(
@@ -168,141 +298,285 @@ checkpoint_path = hf_hub_download(
     filename="model.pt"
 )
 
-# Load checkpoint
+# Load model
 checkpoint = torch.load(checkpoint_path, map_location='cpu')
-model_state = checkpoint['model_state_dict']
-config = checkpoint['config']
-
-print(f"Model trained for {checkpoint['epoch']} epochs")
-print(f"Training loss: {checkpoint['train_loss']:.4f}")
-print(f"Test loss: {checkpoint['test_loss']:.4f}")
-```
-
-### Inference (Requires TRM Code)
-
-```python
-# Note: You need the TRM model code from the repository
-from models.recursive_reasoning.trm import TinyRecursiveReasoningModel_ACTV1
-
-# Initialize model with config
-model = TinyRecursiveReasoningModel_ACTV1(**config['arch'])
-
-# Load weights
-model.load_state_dict(model_state)
+model = TinyRecursiveReasoningModel(**checkpoint['config']['arch'])
+model.load_state_dict(checkpoint['model_state_dict'])
 model.eval()
 
-# Encode question (byte-level)
-def encode_text(text, max_len=512):
+# Byte-level encoding
+def encode(text: str, max_len: int = 512) -> torch.Tensor:
     bytes_arr = np.frombuffer(text.encode('utf-8'), dtype=np.uint8)
-    tokens = (bytes_arr + 2).astype(np.uint8)  # Shift for PAD/EOS
-
-    # Pad sequence
+    tokens = (bytes_arr + 2).astype(np.uint8)
     seq = np.zeros(max_len, dtype=np.uint8)
-    seq[:len(tokens)] = tokens[:max_len-1]
-    seq[min(len(tokens), max_len-1)] = 1  # EOS token
-
+    seq[:min(len(tokens), max_len-1)] = tokens[:max_len-1]
+    seq[min(len(tokens), max_len-1)] = 1  # EOS
     return torch.tensor(seq).unsqueeze(0)
 
+def decode(tokens: torch.Tensor) -> str:
+    tokens = tokens.squeeze().numpy()
+    tokens = tokens[tokens > 1] - 2  # Remove PAD/EOS, unshift
+    return bytes(tokens).decode('utf-8', errors='replace')
+
 # Inference
 question = "What is a Program Derived Address (PDA) in Solana?"
-input_tensor = encode_text(question)
+input_tensor = encode(question)
 
 with torch.no_grad():
     output = model(input_tensor)
-    # Decode output bytes back to text
-    # (implementation depends on your decoding strategy)
+    answer = decode(output.argmax(dim=-1))
+    print(answer)
 ```
 
-### Example Questions
+---
+
+## 📊 Training Details
+
+### Dataset
 
-The model can answer questions like:
+| 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 |
 
-- "What is a Program Derived Address (PDA) in Solana?"
-- "How do Solana transactions differ from Ethereum?"
-- "What is the purpose of the System Program?"
-- "Explain Solana's account model"
-- "How does rent work in Solana?"
-- "What are cross-program invocations (CPI)?"
+### Training Configuration
+
+```yaml
+# config/training.yaml
+architecture:
+  L_layers: 1
+  H_cycles: 2
+  L_cycles: 2
+  vocab_size: 258
+  max_seq_len: 512
+
+training:
+  epochs: 5000
+  global_batch_size: 64
+  learning_rate: 1e-4
+  weight_decay: 0.5
+  ema_enabled: true
+  ema_rate: 0.999
+
+hardware:
+  device: mps  # Apple Silicon
+  training_time: "~4 hours"
+```
 
-## Limitations and Biases
+### Performance
 
-### Limitations
+| Metric | Value |
+|--------|-------|
+| Training Loss | ~2.3 |
+| Test Loss | ~2.5 |
+| Inference Speed | <100ms |
+| Memory Usage | <1GB |
 
-1. **Specialized Domain**: Only trained on Solana-related content
-2. **Small Model**: Limited capacity compared to large language models
-3. **Byte-level Encoding**: May struggle with very long responses
-4. **Training Data Cutoff**: Knowledge limited to training data timeframe
-5. **No Real-time Updates**: Does not know about post-training Solana changes
+---
 
-### Potential Biases
+## 🎯 Example Queries
 
-- **Documentation Bias**: Reflects common patterns in Solana documentation
-- **English Only**: Trained exclusively on English Q&A pairs
-- **Developer-focused**: Biased toward technical development questions
-- **Format Bias**: Optimized for Q&A format, not conversation
+The Solana $OS model excels at:
 
-### Risks and Mitigations
+```
+┌────────────────────────────────────────────────────────┐
+│                  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?"   │
+│                                                        │
+└────────────────────────────────────────────────────────┘
+```
 
-| Risk | Mitigation |
-|------|------------|
-| Outdated information | Always verify with official Solana docs |
-| Security advice | Never rely solely on model for security audits |
-| Code generation | Review and test all generated code |
-| General blockchain questions | Model specializes in Solana only |
+---
 
-## Ethical Considerations
+## 🛡️ Tokenomics
 
-- **Transparency**: Training data and methodology fully documented
-- **Open Source**: Model weights and code freely available
-- **Educational Purpose**: Designed for learning, not production deployment
-- **Verification**: Always cross-reference model outputs with official sources
+```
+┌─────────────────────────────────────────────────────────┐
+│                    $OS TOKENOMICS                       │
+├─────────────────────────────────────────────────────────┤
+│                                                         │
+│  Token: $OS                                             │
+│  Contract: DrU9M6SUaXWua49zeaHQWJuwMpcZ4jMDRT3J5Ywpump │
+│  Chain: Solana                                          │
+│  Standard: SPL Token                                    │
+│                                                         │
+│  ┌─────────────────────────────────────────────────┐    │
+│  │              UTILITY FLYWHEEL                   │    │
+│  │                                                 │    │
+│  │      ┌──────────┐                              │    │
+│  │      │  HOLD    │◀─────────────────┐           │    │
+│  │      │  $OS     │                  │           │    │
+│  │      └────┬─────┘                  │           │    │
+│  │           │                        │           │    │
+│  │           ▼                        │           │    │
+│  │      ┌──────────┐            ┌─────┴────┐      │    │
+│  │      │  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                      │
+│                                                         │
+└─────────────────────────────────────────────────────────┘
+```
 
-## Citation
+---
 
-If you use this model in your research, please cite:
+## 🔗 Integration Examples
+
+### Next.js App Router
+
+```typescript
+// app/api/inference/route.ts
+import { NextRequest, NextResponse } from 'next/server';
+import { verifyWalletSignature, checkTier } from '@/lib/auth';
+
+export async function POST(req: NextRequest) {
+  const { question, walletAddress, signature } = await req.json();
+  
+  // Verify wallet ownership
+  const isValid = await verifyWalletSignature(walletAddress, signature);
+  if (!isValid) {
+    return NextResponse.json({ error: 'Invalid signature' }, { status: 401 });
+  }
+  
+  // Check $OS holdings
+  const tier = await checkTier(walletAddress);
+  if (tier === 'none') {
+    return NextResponse.json({ 
+      error: 'Insufficient $OS holdings',
+      required: 10000,
+      contract: 'DrU9M6SUaXWua49zeaHQWJuwMpcZ4jMDRT3J5Ywpump'
+    }, { status: 403 });
+  }
+  
+  // Process inference
+  const answer = await runInference(question);
+  
+  return NextResponse.json({ answer, tier });
+}
+```
 
-```bibtex
-@misc{jolicoeurmartineau2025morerecursivereasoningtiny,
-      title={Less is More: Recursive Reasoning with Tiny Networks},
-      author={Alexia Jolicoeur-Martineau},
-      year={2025},
-      eprint={2510.04871},
-      archivePrefix={arXiv},
-      primaryClass={cs.LG},
-      url={https://arxiv.org/abs/2510.04871},
+### React Hook
+
+```typescript
+// hooks/useSolanaOS.ts
+import { useWallet } from '@solana/wallet-adapter-react';
+import { useState } from 'react';
+
+export function useSolanaOS() {
+  const { publicKey, signMessage } = useWallet();
+  const [loading, setLoading] = useState(false);
+  
+  const askQuestion = async (question: string) => {
+    if (!publicKey || !signMessage) {
+      throw new Error('Wallet not connected');
+    }
+    
+    setLoading(true);
+    
+    try {
+      // Sign message to prove ownership
+      const message = new TextEncoder().encode(`Solana OS: ${Date.now()}`);
+      const signature = await signMessage(message);
+      
+      const response = await fetch('/api/inference', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          question,
+          walletAddress: publicKey.toBase58(),
+          signature: Buffer.from(signature).toString('base64'),
+        }),
+      });
+      
+      return await response.json();
+    } finally {
+      setLoading(false);
+    }
+  };
+  
+  return { askQuestion, loading };
 }
 ```
 
-## Model Card Authors
+---
+
+## ⚠️ 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
 
-**Model**: Trained and fine-tuned by OrdLibrary
-**Architecture**: Based on TRM by Alexia Jolicoeur-Martineau
-**Dataset**: Custom Solana Q&A corpus
+MIT License - Open source and free to use.
 
-## Additional Resources
+---
 
-- 📄 **Paper**: [Less is More: Recursive Reasoning with Tiny Networks](https://arxiv.org/abs/2510.04871)
-- 💻 **Code**: [TinyRecursiveModels GitHub](https://github.com/AlexiaJM/TinyRecursiveModels)
-- 🌐 **Solana Docs**: [docs.solana.com](https://docs.solana.com)
-- 🤗 **Model**: [huggingface.co/ordlibrary/trm-solana-v1](https://huggingface.co/ordlibrary/trm-solana-v1)
+## 🙏 Acknowledgments
 
-## License
+- **Alexia Jolicoeur-Martineau** - TRM Architecture
+- **Solana Foundation** - Documentation & Ecosystem
+- **OrdLibrary** - Original model training
+- **8bit Labs** - $OS Token Integration
 
-MIT License - See repository for full details
+---
 
-## Acknowledgments
+## 📚 Resources
 
-- **Alexia Jolicoeur-Martineau** for the TRM architecture
-- **Solana Foundation** for comprehensive documentation
-- **HuggingFace** for hosting infrastructure
-- **Community contributors** to Solana Q&A data
+| Resource | Link |
+|----------|------|
+| 📄 TRM Paper | [arXiv:2510.04871](https://arxiv.org/abs/2510.04871) |
+| 💻 TRM Code | [GitHub](https://github.com/AlexiaJM/TinyRecursiveModels) |
+| 🤗 Model | [HuggingFace](https://huggingface.co/ordlibrary/trm-solana-v1) |
+| 🌐 Solana Docs | [docs.solana.com](https://docs.solana.com) |
+| 💎 Buy $OS | [Pump.fun](https://pump.fun/DrU9M6SUaXWua49zeaHQWJuwMpcZ4jMDRT3J5Ywpump) |
 
 ---
 
 <div align="center">
 
-**Built with ❤️ for the Solana developer community**
+## 💎 Get $OS Now
 
-[Report Issues](https://github.com/AlexiaJM/TinyRecursiveModels/issues) • [Get Help](https://docs.solana.com)
+```
+DrU9M6SUaXWua49zeaHQWJuwMpcZ4jMDRT3J5Ywpump
+```
 
-</div>
+**[Pump.fun](https://pump.fun/DrU9M6SUaXWua49zeaHQWJuwMpcZ4jMDRT3J5Ywpump)** • **[DexScreener](https://dexscreener.com/solana/DrU9M6SUaXWua49zeaHQWJuwMpcZ4jMDRT3J5Ywpump)** • **[Birdeye](https://birdeye.so/token/DrU9M6SUaXWua49zeaHQWJuwMpcZ4jMDRT3J5Ywpump)**
+
+---
+
+**Built by [8bit Labs](https://8bitlabs.ai) for the Solana ecosystem**
+
+*The Neural Operating System for Solana*
+
+</div>