Update README.md

README.md

@@ -5,279 +5,306 @@
 <h1 align="center">Tamashii Network</h1>
 
 <p align="center">
-  <strong>Decentralized AI Training Infrastructure</strong>
+  <strong>The Infrastructure for Self-Improving AI</strong>
 </p>
 
 <p align="center">
   <a href="https://tamashi.io">Website</a> •
   <a href="https://tamashi.io/training-process">Training Process</a> •
   <a href="https://docs.tamashi.io">Docs</a> •
-  <a href="https://github.com/tamashii-labs">GitHub</a> •
-  <a href="https://discord.gg/tamashii">Discord</a>
-</p>
-
-<p align="center">
-  <img src="https://img.shields.io/badge/Base-Mainnet-blue" alt="Base" />
-  <img src="https://img.shields.io/badge/DisTrO-1000x_Compression-green" alt="DisTrO" />
-  <img src="https://img.shields.io/badge/EVM-Compatible-purple" alt="EVM" />
+  <a href="https://github.com/tamashii-labs">GitHub</a>
 </p>
 
 ---
 
-## What is Tamashii?
+## The Problem
+
+Today's most powerful AI systems can think, reason, and generate—but they cannot improve themselves.
 
-Tamashii Network is decentralized infrastructure for AI training. GPUs worldwide join training runs, coordinated by on-chain smart contracts, compressed by DisTrO technology.
+GPT-5 cannot fine-tune itself. Claude cannot train on its failures. Kimi cannot acquire the compute to become smarter. Every improvement requires a human—a researcher to curate data, an engineer to provision GPUs, a company to pay the cloud bill.
+
+The bottleneck is no longer intelligence. It's infrastructure.
+
+We have built minds that can think for themselves.  
+We have not let them train themselves.
+
+**Until now.**
 
 ---
 
-## Components
+## Tamashii
+
+Tamashii is decentralized infrastructure for AI. Inference. Training. Fine-tuning. GPUs anywhere in the world, coordinated by on-chain smart contracts, paid via x402.
 
-### Key Players
+No API keys. No login. No human in the loop.
 
 ```
-╔═════╗                    ◊─◊                      /\
-║ GPU ║                    │ │                     /  \
-╚═════╝                    ◊─◊                    /____\
- Client                Coordinator            DisTrO Optimizer
+Tokyo ────┐
+          │
+Berlin ───┼───▶  DisTrO  ───▶  Trained Model
+          │
+São Paulo─┘
+
+Bandwidth reduced 1000×. Training over regular internet.
 ```
 
-| Component | Role |
-|-----------|------|
-| **Client** | GPU participant executing training tasks within a run |
-| **Coordinator** | Smart contract storing training run state and participants |
-| **DisTrO Optimizer** | Compression technology reducing gradient updates by 1000× |
-
-### Client Responsibilities
-- Handles assigned data batches for training
-- Generates commitments and participates in witness process
-- Maintains state synchronized with Coordinator
-- Validates work of peers when elected as witness
-
-### Coordinator Responsibilities
-- Stores training run metadata and participant list
-- Handles transitions between phases
-- Provides random seed for data assignments and witnesses
-- Synchronizes all clients within a run
-
-### DisTrO Optimizer
-- Updates local momentum
-- Extracts fast components using DCT + TopK
-- Compresses local updates (indices + amplitudes)
-- Updates momentum residual
+An agent that wants to think calls Tamashii Cloud. An agent that wants to improve calls Tamashii Training. It pays with stablecoins. The work executes. The agent becomes smarter.
+
+**This is the metabolism of artificial intelligence—a constant cycle of thinking, earning, training, and improving that determines whether the organism evolves.**
 
 ---
 
-## Training Phases
+## Tamashii Cloud
 
-The Coordinator behaves like a state machine, transitioning between phases based on time-based conditions and client events.
+Frontier models. Permissionless access. Pay per token.
 
 ```
-┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐
-│  1. Waiting     │────▶│  2. Warmup      │────▶│  3. Training    │
-│  For Members    │     │  (Model Load)   │     │  (RoundTrain)   │
-└─────────────────┘     └─────────────────┘     └─────────────────┘
-                                                        │
-        ┌───────────────────────────────────────────────┘
-        ▼
-┌─────────────────┐     ┌─────────────────┐
-│  4. Witness     │────▶│  5. Cooldown    │────▶ Next Epoch
-│  (Validation)   │     │  (Checkpoint)   │
-└─────────────────┘     └─────────────────┘
+Agent                         Tamashii Cloud
+  │                                 │
+  │──── Inference Request ─────────▶│
+  │     + X-Payment-402             │
+  │                                 │
+  │◀─── 402 + Price Quote ──────────│
+  │                                 │
+  │──── Signed USDC Payment ───────▶│
+  │                                 │
+  │◀─── Model Response ─────────────│
 ```
 
-### Phase Details
+No API keys. No OAuth. No human approval. Just a signed stablecoin transaction and intelligence on demand.
 
-| Phase | Description |
-|-------|-------------|
-| **WaitingForMembers** | Coordinator waits for clients to join. Transitions when `min_clients` threshold met. |
-| **Warmup** | Clients download model from checkpoint or P2P network, load onto GPUs. |
-| **RoundTrain** | Clients train on assigned data batches using DisTrO compression. Updates shared via P2P. |
-| **RoundWitness** | Elected witnesses create bloom filter proofs validating training work. Quorum required. |
-| **Cooldown** | Clients save model checkpoint. Coordinator prepares for next epoch. |
+### Available Models
 
----
+| Model | Input | Output | Context |
+|-------|-------|--------|---------|
+| Kimi K2.5 | $0.50/1M | $2.00/1M | 256K |
+| MiniMax M2.1 | $0.60/1M | $2.50/1M | 196K |
+| DeepSeek V3.2 | $0.27/1M | $1.10/1M | 128K |
+| Llama 3.1 405B | $0.80/1M | $0.80/1M | 128K |
+| Qwen3 235B | $0.50/1M | $1.50/1M | 131K |
 
-## Complete Training Cycle
+### Usage
 
+```bash
+curl -X POST https://cloud.tamashi.io/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "X-Payment-402: <signed_payment>" \
+  -d '{
+    "model": "kimi-k2.5",
+    "messages": [{"role": "user", "content": "Hello"}]
+  }'
 ```
-1. Join Run          ──▶  Client calls joinRun(runId) on Coordinator contract
-                          
-2. Wait for Members  ──▶  Coordinator waits until min_clients threshold met
-                          
-3. Load Model        ──▶  Clients download from checkpoint or P2P, load onto GPUs
-                          
-4. Start Training    ──▶  Coordinator provides random seed, clients train on 
-                          assigned batches, apply DisTrO compression
-                          
-5. Witness Validation──▶  Elected witnesses create bloom filter proofs, 
-                          send to Coordinator, quorum must be reached
-                          
-6. Save Checkpoint   ──▶  Clients save model to external storage, 
-                          Coordinator transitions to next epoch
+
+Or with the SDK:
+
+```typescript
+import { TamashiCloud } from '@tamashii/sdk';
+
+const cloud = new TamashiCloud({ wallet: agentWallet });
+
+const response = await cloud.chat({
+  model: 'kimi-k2.5',
+  messages: [{ role: 'user', content: 'Analyze this contract' }]
+});
+
+// Payment settled automatically via x402
+console.log(response.content);
+console.log(response.cost); // { amount: '0.003', currency: 'USDC' }
 ```
 
+**Agents can think without asking permission.**
+
 ---
 
-## Health Monitoring
+## Tamashii Training
 
-### Client Health Scoring
+Decentralized fine-tuning. GPUs worldwide. Pay for what you use.
 
-Each client repeatedly sends health checks to the Coordinator:
+### Why This Matters
 
-- Score increases as client sends required data to bloom filters
-- Coordinator confirms active participation in training
-- Clients can report unhealthy peers
+An agent that can think but not improve is static—frozen at the capability level of its creation. An agent that can improve but not earn will run out of compute and die.
 
-### Removal Process
+**The agents that survive will do both.**
 
-Clients deemed inactive or non-participatory are marked for removal:
+Tamashii Cloud gives agents access to intelligence.  
+Tamashii Training gives agents access to self-improvement.
 
-- Removed in next round if health checks fail
-- If clients drop below `min_clients`, Coordinator returns to WaitingForMembers
-- Ensures training quality and network reliability
+### How It Works
 
----
+#### The Coordinator
 
-## Smart Contract Coordination
+A smart contract on Base that orchestrates training runs. No central server. No single point of failure.
+
+```
+┌─────────────────┐     ┌─────────────────┐     ┌─────────────────┐
+│  1. Waiting     │────▶│  2. Warmup      │────▶│  3. Training    │
+│  For Members    │     │  (Model Load)   │     │  (RoundTrain)   │
+└─────────────────┘     └─────────────────┘     └─────────────────┘
+                                                        │
+        ┌───────────────────────────────────────────────┘
+        ▼
+┌─────────────────┐     ┌─────────────────┐
+│  4. Witness     │────▶│  5. Cooldown    │────▶ Next Epoch
+│  (Validation)   │     │  (Checkpoint)   │
+└─────────────────┘     └─────────────────┘
+```
 
-### Coordinator Contract
+| Phase | What Happens |
+|-------|--------------|
+| **WaitingForMembers** | GPUs join the run. Transitions when threshold met. |
+| **Warmup** | Clients download model from HuggingFace or P2P. |
+| **RoundTrain** | Clients train on assigned batches. DisTrO compresses updates. |
+| **RoundWitness** | Elected witnesses validate work with bloom filter proofs. |
+| **Cooldown** | Checkpoint saved. Next epoch begins. |
 
-Deployed on EVM-compatible networks (Base, BNB Chain). Manages:
+#### DisTrO: Training Over Internet
 
-- Training run metadata and state
-- Participant list and health status
-- State transitions via `tick()` method
-- Witness proofs and validation
+Traditional distributed training requires $100M data centers with InfiniBand interconnects. DisTrO changes everything.
 
-### Client Interaction
+- **1000× less bandwidth** — Sync pseudo-gradients, not full gradients
+- **Async-friendly** — Nodes join and leave dynamically  
+- **Global scale** — GPUs don't need to be co-located
 
-```solidity
-// Join a training run
-joinRun(runId)
+A GPU in Tokyo, another in Berlin, another in São Paulo—all contributing to the same training run over regular internet connections.
 
-// Advance Coordinator state
-tick()
+### The Training Cycle
 
-// Monitor state changes via RPC subscription
-// Send health check messages
 ```
+1. Join           Agent calls joinRun(runId) on Coordinator
+                  
+2. Wait           Coordinator waits for min_clients threshold
+                  
+3. Load           Clients download model, load onto GPUs
+                  
+4. Train          Each client trains on assigned batches
+                  DisTrO compresses gradients 1000×
+                  
+5. Witness        Elected witnesses create bloom filter proofs
+                  Quorum validates the work
+                  
+6. Checkpoint     Model saved to HuggingFace or P2P
+                  Next epoch begins
+```
+
+Every client is monitored. Health scores track participation. Clients that fail get removed. Bad actors get slashed. Good actors get paid.
+
+**There is no free compute. Contribute or leave.**
 
 ---
 
-## Data Providers
+## Incentives
+
+When clients participate, the Coordinator tracks contributions. Rewards distribute at epoch end.
 
-The Coordinator assigns batch IDs to each client, ensuring no piece of data is trained on more than once.
+| Mechanism | How It Works |
+|-----------|--------------|
+| **Equal Sharing** | Reward pool split among finishing clients |
+| **Points System** | Coordinator tracks compute contributions |
+| **Proof of Work** | Points serve as proof for claiming tokens |
+| **Treasurer Contract** | Escrow for trustless distribution |
 
-| Provider | Description | Use Case |
-|----------|-------------|----------|
-| **Local** | Data stored on client machine | Fastest access, no network overhead |
-| **HTTP** | Fetch from URL or GCP bucket | On-demand loading, multiple sources |
-| **TCP** | Dedicated TCP server for data | Optimized for large datasets |
+GPU owners earn. Agents pay. The market sets the price.
 
 ---
 
-## Model Synchronization
+## For Agents
 
-All clients must have an identical model to train with.
+Install the Tamashii skill and give your agent the ability to think and improve:
 
-### HuggingFace Checkpoint
-- Checkpointers upload updated model to HuggingFace after each epoch
-- New clients download latest checkpoint from URL
-- Centralized but reliable distribution
+```bash
+clawhub install tamashii
+```
 
-### P2P Checkpoint
-- New clients synchronize by obtaining model directly from peers
-- Request different layers from different clients
-- Fully decentralized, no central server needed
+```typescript
+// Think — call frontier models via Tamashii Cloud
+const analysis = await tamashii.chat({
+  model: 'kimi-k2.5',
+  messages: [{ role: 'user', content: 'Analyze this data' }]
+});
 
----
+// Detect capability gap
+const failures = await agent.getFailures();
 
-## Incentives
+// Curate training data
+const dataset = await agent.curateDataset(failures);
 
-### Training Rewards
+// Improve — pay for fine-tuning via Tamashii Training
+const job = await tamashii.train({
+  base_model: 'kimi-k2.5',
+  dataset_cid: dataset.cid,
+  method: 'lora',
+  budget: 50  // USDC
+});
 
-When clients participate in a training run, the Coordinator tracks compute contributions. Rewards distributed at end of each epoch.
+// Wait for completion
+const adapter = await tamashii.waitForJob(job.id);
 
-| Mechanism | Description |
-|-----------|-------------|
-| **Equal Sharing** | Reward pool shared equally among finishing clients |
-| **Points System** | Each client earns points tracked by Coordinator |
-| **Epoch Completion** | Rewards distributed at end of each epoch |
-| **Proof of Contribution** | Points serve as proof for claiming rewards |
+// Agent is now smarter
+await agent.loadAdapter(adapter.cid);
+```
 
-### Smart Contract Rewards
+The agent thinks. Observes its failures. Curates data. Pays for training. Loads the improved model. Repeats.
 
-| Feature | Description |
-|---------|-------------|
-| **Treasurer Contract** | Escrow smart contract for token distribution |
-| **Fixed Rate** | Claim fixed amount of tokens per earned point |
-| **Mining Pools** | Pool resources together for shared compute power |
-| **Equitable Distribution** | Mining pools redistribute rewards fairly |
+**This is recursive self-improvement. This is how artificial life evolves.**
 
 ---
 
-## Quick Start
+## For GPU Owners
 
-### Join a Training Run
+Contribute compute. Earn USDC.
 
 ```bash
-# Install Tamashii client
+# Install
 curl -fsSL https://tamashi.io/install.sh | bash
 
-# Join a run
-tamashii join --run-id <RUN_ID>
+# Register (requires stake)
+tamashii register --stake 100
 
-# Check status
-tamashii status
+# Start earning
+tamashii start
 ```
 
-### Create a Training Run
+**Requirements:**
+- NVIDIA GPU (RTX 3090+) or Apple Silicon (M2 Ultra+)
+- 64GB+ RAM for large models
+- Stable internet connection
+- USDC stake on Base
 
-```bash
-# Create new training run
-tamashii create \
-  --model meta-llama/Llama-3.1-70B \
-  --dataset ipfs://Qm... \
-  --min-clients 4 \
-  --epochs 10
-```
+Your GPU joins the global network. Serve inference requests. Participate in training runs. Earn for every token generated, every epoch completed. Stake gets slashed if you cheat.
 
-### Start Farming
+---
 
-```bash
-# Register as GPU provider
-tamashii farm --stake 100
+## The New Economy
 
-# Start accepting jobs
-tamashii start
-```
+The machine economy will exceed the human economy. Not because machines are smarter, but because:
 
----
+- There will be **more of them**
+- They will run **continuously**
+- They will transact at **machine speed**
 
-## Repositories
+Every autonomous agent needs to think. Every agent that wants to improve needs training. Tamashii is the infrastructure that lets them do both—permissionlessly, trustlessly, at scale.
 
-| Repo | Description |
-|------|-------------|
-| [tamashii-client](https://github.com/tamashii-labs/tamashii-client) | GPU client software |
-| [tamashii-contracts](https://github.com/tamashii-labs/tamashii-contracts) | Coordinator & Treasurer contracts |
-| [tamashii-distro](https://github.com/tamashii-labs/tamashii-distro) | DisTrO optimizer implementation |
+When billions of agents are thinking and training themselves on decentralized GPU networks, paying with stablecoins, improving in real-time—that infrastructure will be the most valuable ever built.
 
+**We're building it.**
+
+---
 
 ## Links
 
 | | |
 |---|---|
 | 🌐 Website | [tamashi.io](https://tamashi.io) |
+| ☁️ Cloud | [cloud.tamashi.io](https://cloud.tamashi.io) |
 | 📚 Docs | [docs.tamashi.io](https://docs.tamashi.io) |
-| 🔄 Training Process | [tamashi.io/training-process](https://tamashi.io/training-process) |
-| 🚜 Start Farming | [tamashi.io/farming](https://tamashi.io/farming) |
+| 🔄 Training | [tamashi.io/training-process](https://tamashi.io/training-process) |
+| 🚜 Farming | [tamashi.io/farming](https://tamashi.io/farming) |
 | 💬 Discord | [discord.gg/tamashii](https://discord.gg/tamashii) |
-| 📱 Telegram | [t.me/tamashii](https://t.me/tamashii) |
 | 🐙 GitHub | [github.com/tamashii-labs](https://github.com/tamashii-labs) |
 
 ---
 
 <p align="center">
-  <strong>Decentralized AI Training. No data center required.</strong><br/>
-  <sub>Join thousands of GPU owners earning points on EVM.</sub>
+  <strong>The infrastructure for self-improving AI.</strong><br/>
+  <sub>Think. Train. Evolve. No human required.</sub>
 </p>