OlmoEarth MLX: Spatio-Temporal Earth Intelligence
Trit: +1 (PLUS - world creation via planetary observation)
Foundation: AI2 OlmoEarth + Apple MLX + GeoACSet + Dune.xyz Geographic WEV
Overview
OlmoEarth is AI2's open spatio-temporal foundation model for planetary intelligence, trained on:
- Sentinel-2 L2A (12 bands, 10-60m resolution)
- Sentinel-1 SAR (VV, VH polarization)
- Landsat (historical continuity)
- WorldCover (11 land cover classes)
- OpenStreetMap raster
- SRTM elevation
- WRI Canopy Height Map
This skill enables:
- Geographic embedding of crypto wallet activity from Dune.xyz
- Impact area identification for Protocol Labs infrastructure
- GeoACSet materialization for categorical spatial reasoning
Architecture
┌─────────────────────────────────────────────────────────────────────────┐
│ OLMOEARTH-MLX PIPELINE │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ Dune.xyz Query ─┬─► IP Geolocation ─┬─► OlmoEarth Embedding │
│ │ │ │
│ Wallet Activity ┘ Region Bounds ─┘ FlexiVit Encoder │
│ │ │
│ ▼ │
│ ┌───────────────────────────────────┐ │
│ │ GeoACSet Materialization │ │
│ │ Regions → Districts → Parcels │ │
│ │ with GF(3) trits │ │
│ └───────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌───────────────────────────────────┐ │
│ │ Tenderloin WEV Integration │ │
│ │ Geographic Value Extraction │ │
│ └───────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────────────┘
OlmoEarth Model Specs
| Model | Encoder Params | Decoder Params | Embed Dim | Depth |
|---|---|---|---|---|
| Nano | 5.8M | 3.7M | 192 | 12 |
| Tiny | 22M | 14M | 384 | 12 |
| Base | 86M | 55M | 768 | 12 |
| Large | 307M | 197M | 1024 | 24 |
Supported Modalities
MODALITIES = {
"SENTINEL2_L2A": {
"bands": ["B02", "B03", "B04", "B05", "B06", "B07",
"B08", "B8A", "B11", "B12", "SCL", "CLD"],
"gsd": [10, 10, 10, 20, 20, 20, 10, 20, 20, 20, 20, 20],
"temporal": True
},
"SENTINEL1": {
"bands": ["VV", "VH"],
"gsd": [10, 10],
"temporal": True
},
"WORLDCOVER": {
"bands": ["LC"],
"classes": 11, # Tree, Shrub, Grass, Crop, Built, Bare, Snow, Water, Wetland, Mangrove, Moss
"gsd": [10],
"temporal": False
},
"SRTM": {
"bands": ["elevation"],
"gsd": [30],
"temporal": False
}
}
MLX Inference
# olmoearth_mlx.py - Apple Silicon optimized inference
import mlx.core as mx
import mlx.nn as nn
from dataclasses import dataclass
from typing import Dict, List, Optional, Tuple
@dataclass
class OlmoEarthConfig:
"""OlmoEarth model configuration for MLX."""
embed_dim: int = 768
depth: int = 12
num_heads: int = 12
patch_size: int = 4
num_modalities: int = 8
temporal_tokens: int = 4
class FlexiVitEncoder(nn.Module):
"""FlexiVit encoder for OlmoEarth on MLX."""
def __init__(self, config: OlmoEarthConfig):
super().__init__()
self.config = config
# Patch embeddings per modality
self.patch_embed = nn.Linear(
config.patch_size * config.patch_size * 12, # Max bands
config.embed_dim
)
# Positional encoding
self.pos_embed = mx.zeros((1, 256, config.embed_dim))
# Transformer blocks
self.blocks = [
TransformerBlock(config.embed_dim, config.num_heads)
for _ in range(config.depth)
]
self.norm = nn.LayerNorm(config.embed_dim)
def __call__(self, x: mx.array, timestamps: mx.array) -> mx.array:
# Patchify and embed
x = self.patch_embed(x)
x = x + self.pos_embed[:, :x.shape[1], :]
# Transform
for block in self.blocks:
x = block(x)
return self.norm(x)
class TransformerBlock(nn.Module):
def __init__(self, dim: int, num_heads: int):
super().__init__()
self.attn = nn.MultiHeadAttention(dim, num_heads)
self.mlp = nn.Sequential(
nn.Linear(dim, dim * 4),
nn.GELU(),
nn.Linear(dim * 4, dim)
)
self.norm1 = nn.LayerNorm(dim)
self.norm2 = nn.LayerNorm(dim)
def __call__(self, x: mx.array) -> mx.array:
x = x + self.attn(self.norm1(x), self.norm1(x), self.norm1(x))
x = x + self.mlp(self.norm2(x))
return x
Dune.xyz Geographic Mapping
Trackable Interactions
| Query | Geographic Signal | GeoACSet Mapping |
|---|---|---|
| Filecoin Storage Deals | Provider location | Region → District |
| FVM Contract Deploys | Creator wallet region | District → Parcel |
| Bridge Transactions | Source/dest chains | Region ↔ Region |
| Grant Disbursements | Recipient geography | Parcel → Building |
SQL Queries (Dune)
-- Filecoin storage provider geographic distribution
SELECT
provider_id,
COALESCE(ip_geolocation.country, 'Unknown') as country,
COALESCE(ip_geolocation.region, 'Unknown') as region,
COUNT(*) as deals,
SUM(piece_size) as total_bytes
FROM filecoin.storage_deals sd
LEFT JOIN ip_geolocation ON sd.provider_ip = ip_geolocation.ip
WHERE deal_timestamp > NOW() - INTERVAL '30 days'
GROUP BY 1, 2, 3
ORDER BY deals DESC;
-- FVM contract geographic heat map
SELECT
DATE_TRUNC('day', block_timestamp) as day,
creator_country,
creator_region,
COUNT(DISTINCT contract_address) as contracts,
SUM(gas_used) as total_gas
FROM filecoin.fvm_contracts
WHERE block_timestamp > NOW() - INTERVAL '90 days'
GROUP BY 1, 2, 3;
-- Cross-chain bridge flows by geography
SELECT
source_chain,
dest_chain,
sender_region,
receiver_region,
SUM(amount_usd) as volume_usd,
COUNT(*) as tx_count
FROM bridge_transactions
WHERE timestamp > NOW() - INTERVAL '7 days'
AND (source_chain = 'filecoin' OR dest_chain = 'filecoin')
GROUP BY 1, 2, 3, 4;
GeoACSet Materialization
# GeoACSet schema for crypto-geographic data
@present SchCryptoGeo(FreeSchema) begin
# Objects
Region::Ob
District::Ob
Wallet::Ob
Transaction::Ob
EarthTile::Ob
# Morphisms
region_of::Hom(District, Region)
district_of::Hom(Wallet, District)
sender::Hom(Transaction, Wallet)
receiver::Hom(Transaction, Wallet)
tile_of::Hom(Wallet, EarthTile)
# Attributes
lat::Attr(Region, Float64)
lon::Attr(Region, Float64)
embedding::Attr(EarthTile, Vector{Float32}) # OlmoEarth embedding
trit::Attr(Transaction, Int) # GF(3) classification
end
@acset_type CryptoGeoACSet(SchCryptoGeo)
# Materialization from Dune query results
function materialize_crypto_geo(dune_results::DataFrame)::CryptoGeoACSet
acset = CryptoGeoACSet()
# Add regions
for row in eachrow(unique(dune_results, :region))
add_part!(acset, :Region;
lat=row.lat,
lon=row.lon
)
end
# Add districts within regions
for row in eachrow(unique(dune_results, [:region, :district]))
region_id = findfirst(r -> r == row.region, acset[:Region])
add_part!(acset, :District; region_of=region_id)
end
# Add wallets with earth tile embeddings
for row in eachrow(unique(dune_results, :wallet))
district_id = findfirst(d -> d == row.district, acset[:District])
tile_embedding = get_olmoearth_embedding(row.lat, row.lon)
tile_id = add_part!(acset, :EarthTile; embedding=tile_embedding)
add_part!(acset, :Wallet; district_of=district_id, tile_of=tile_id)
end
return acset
end
Impact Area Identification
Protocol Labs Infrastructure Zones
PL_IMPACT_ZONES = {
"high_density": [
{"name": "SF Bay Area", "lat": 37.7749, "lon": -122.4194, "radius_km": 100},
{"name": "Greater NYC", "lat": 40.7128, "lon": -74.0060, "radius_km": 80},
{"name": "Singapore", "lat": 1.3521, "lon": 103.8198, "radius_km": 50},
],
"emerging": [
{"name": "Shenzhen", "lat": 22.5431, "lon": 114.0579, "radius_km": 60},
{"name": "Berlin", "lat": 52.5200, "lon": 13.4050, "radius_km": 40},
{"name": "Bangalore", "lat": 12.9716, "lon": 77.5946, "radius_km": 50},
],
"frontier": [
{"name": "Lagos", "lat": 6.5244, "lon": 3.3792, "radius_km": 30},
{"name": "São Paulo", "lat": -23.5505, "lon": -46.6333, "radius_km": 60},
{"name": "Jakarta", "lat": -6.2088, "lon": 106.8456, "radius_km": 40},
]
}
def classify_impact_zone(lat: float, lon: float) -> Tuple[str, str, float]:
"""Classify a coordinate into PL impact zone."""
from math import radians, sin, cos, sqrt, atan2
def haversine(lat1, lon1, lat2, lon2):
R = 6371 # Earth radius in km
dlat = radians(lat2 - lat1)
dlon = radians(lon2 - lon1)
a = sin(dlat/2)**2 + cos(radians(lat1)) * cos(radians(lat2)) * sin(dlon/2)**2
return 2 * R * atan2(sqrt(a), sqrt(1-a))
for zone_type, zones in PL_IMPACT_ZONES.items():
for zone in zones:
dist = haversine(lat, lon, zone["lat"], zone["lon"])
if dist <= zone["radius_km"]:
return zone_type, zone["name"], dist
return "global", "Other", float("inf")
GF(3) Geographic Classification
| Trit | Zone Type | WEV Signal | Strategy |
|---|---|---|---|
| +1 | high_density | Infrastructure concentration | Long storage deals |
| 0 | emerging | Growth potential | Bridge liquidity |
| -1 | frontier | Adoption catalyst | Grant allocation |
Tenderloin Integration
# Connect OlmoEarth embeddings to Tenderloin WEV
def geo_wev_extraction(
dune_query: str,
olmoearth_model: FlexiVitEncoder,
geoacset: CryptoGeoACSet
) -> List[Dict]:
"""Extract geographic WEV from Dune data with OlmoEarth embeddings."""
# Execute Dune query
results = execute_dune_query(dune_query)
wev_events = []
for row in results:
# Get OlmoEarth embedding for location
embedding = olmoearth_model.embed(row.lat, row.lon)
# Classify impact zone
zone_type, zone_name, dist = classify_impact_zone(row.lat, row.lon)
# Map to GF(3) trit
trit = {"high_density": 1, "emerging": 0, "frontier": -1}.get(zone_type, 0)
wev_events.append({
"source": "dune_geo",
"lat": row.lat,
"lon": row.lon,
"zone": zone_name,
"trit": trit,
"embedding": embedding.tolist(),
"value": row.volume_usd,
"category": "geographic"
})
return wev_events
Usage
# Install OlmoEarth
pip install olmoearth-pretrain
# Run geographic WEV extraction
python -c "
from olmoearth_mlx import OlmoEarthMLX
from tenderloin.fund_wallets import WalletFundingEngine
# Load model
model = OlmoEarthMLX.load('olmoearth-base')
# Query Dune for geographic data
geo_wev = model.extract_geographic_wev(
query='filecoin_storage_providers_by_region',
timeframe='30d'
)
# Fund wallets based on geographic WEV
engine = WalletFundingEngine()
for event in geo_wev:
engine.ingest_wev(event['category'], event['value'], trit=event['trit'])
"
Canonical Triads
olmoearth-mlx (+1) ⊗ geoacset (0) ⊗ dune-geographic (-1) = 0 ✓
tenderloin (+1) ⊗ prediction-markets (0) ⊗ olmoearth-mlx (-1) = 0 ✓
References
- OlmoEarth arXiv Paper
- allenai/olmoearth_pretrain
- bmorphism/GeoACSets.jl
- Dune Analytics
- Filecoin Data Portal
Scientific Skill Interleaving
This skill connects to the K-Dense-AI/claude-scientific-skills ecosystem:
Autodiff
- jax [○] via bicomodule
- Hub for autodiff/ML
Bibliography References
general: 734 citations in bib.duckdb
Cat# Integration
This skill maps to Cat# = Comod(P) as a bicomodule in the equipment structure:
Trit: 0 (ERGODIC)
Home: Prof
Poly Op: ⊗
Kan Role: Adj
Color: #26D826
GF(3) Naturality
The skill participates in triads satisfying:
(-1) + (0) + (+1) ≡ 0 (mod 3)
This ensures compositional coherence in the Cat# equipment structure.