npx claudepluginhub plurigrid/asi --plugin asiThis skill uses the workspace's default tool permissions.
**Trit**: +1 (PLUS - world creation via planetary observation)
Provides investment thesis, ecosystem map, holdings, and competitive analysis for Tenderloin fund targeting Protocol Labs stack including IPFS, Filecoin, libp2p, and Bacalhau. Useful for decentralized web investment discussions.
Executes DuneSQL queries via Dune REST API against live on-chain blockchain data. Analyzes wallet activity, DEX trades, token transfers, smart contract events. Discovers decoded tables and monitors credit usage.
Performs geospatial vector analysis with GeoPandas: read/write Shapefile/GeoJSON/GeoPackage/PostGIS/Parquet, spatial joins/overlays/dissolve, geometric ops (buffer/centroid), CRS transforms, choropleth/interactive maps.
Share bugs, ideas, or general feedback.
Trit: +1 (PLUS - world creation via planetary observation)
Foundation: AI2 OlmoEarth + Apple MLX + GeoACSet + Dune.xyz Geographic WEV
OlmoEarth is AI2's open spatio-temporal foundation model for planetary intelligence, trained on:
This skill enables:
┌─────────────────────────────────────────────────────────────────────────┐
│ 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 │ │
│ └───────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────────────┘
| 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 |
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
}
}
# 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
| 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 |
-- 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 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
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")
| 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 |
# 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
# 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'])
"
olmoearth-mlx (+1) ⊗ geoacset (0) ⊗ dune-geographic (-1) = 0 ✓
tenderloin (+1) ⊗ prediction-markets (0) ⊗ olmoearth-mlx (-1) = 0 ✓
This skill connects to the K-Dense-AI/claude-scientific-skills ecosystem:
general: 734 citations in bib.duckdbThis 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
The skill participates in triads satisfying:
(-1) + (0) + (+1) ≡ 0 (mod 3)
This ensures compositional coherence in the Cat# equipment structure.