SolarPunk: Earth's Digital Immune System Gets a Notion Nerve Center

Your body doesn't need a meeting to fight an infection. White blood cells detect, coordinate, and respond — autonomously. Your temperature self-regulates. Neural pathways myelinate with use. Signals flow from high concentration to low through osmosis.

SolarPunk works the same way. It's a 274-engine autonomous humanitarian system that monitors global crises, generates survival resources, and amplifies help through every channel it can reach. It runs on nature's own patterns — and now, thanks to Notion MCP, its entire operational state is visible through a human-readable command center.

This is not a demo. This is a living system with 269 Python engines running real crisis detection pipelines.

What I Built
SolarPunk is an autonomous planetary immune system — a network of bio-inspired engines that detect humanitarian crises, generate survival resources, and push help through every available channel. It uses seven patterns drawn directly from biology:

Pattern Engine What It Does
T-Cell Immune Memory IMMUNE_MEMORY.py Remembers crisis patterns. First encounter: 120s response. Recall: 5s. 24x faster.
Bacterial Quorum Sensing QUORUM_SENSE.py Individual signals are noise. When enough accumulate from a region, the colony switches behavior. Coordinated response fires.
Fungal Spore Dispersal SPORE_DISPERSAL.py 17 spores per cycle across 5 channel types. Fungi don't aim. They saturate. So does SolarPunk.
Deep-Sea Bioluminescence BIOLUMINESCENCE.py When signals from a region go silent, that IS the alarm. Generates light in the darkness of information blackouts.
Osmosis Routing OSMOSIS_ROUTER.py Help flows toward information voids. Under-covered crises get amplification automatically. The gradient is suffering. The flow is automatic.
Homeostasis HOMEOSTASIS.py 10 vital signs with min/max ranges. System self-regulates like body temperature. Too hot? Cool down. Too cold? Heat up.
Neuroplasticity NEUROPLASTICITY.py 17 neural pathways. Strengthen what works. Prune what doesn't. Myelinate the fastest routes.
Chemotaxis CHEMOTAXIS.py Bacterial gradient navigation. Swim toward need, tumble away from saturation. No map needed.
Stigmergy STIGMERGY.py Ant pheromone trails. Engines coordinate through data traces left in the environment. No central controller.
Circadian Rhythm CIRCADIAN_RHYTHM.py Biological clock. Knows what time it is in Gaza, Sudan, Myanmar. Posts at peak engagement. Emails during NGO business hours.
Symbiogenesis SYMBIOGENESIS.py Endosymbiosis. Tracks which engine pairs fuse into permanent bonds, like mitochondria were once free bacteria.
The Notion MCP integration gives this system something it never had before: a command center that non-technical humans can read, filter, and act on. Three interconnected databases turn raw autonomous engine output into operational dashboards:

Crisis Signal Tracker — Real-time crisis signals from Reddit, Wikipedia, and ReliefWeb with urgency scores, affected regions, source attribution, and action status
Planetary Health Monitor — 10 vital signs (engine count, crisis signals, active sources, trigger rate, spore count, and more) with healthy ranges and real-time status from the HOMEOSTASIS engine
Nature Pattern Engines — 9 bio-inspired engines with strength scores from the NEUROPLASTICITY self-rewiring system
Key numbers from the live system:

274 autonomous engines
Planetary health score: 89/100
8 of 17 neural pathways myelinated
5 emergency survival kits in 6 formats (SMS 160B, LoRa 250B, mesh, satellite, QR, GitHub Gist)
17 spores per dispersal cycle across 5 channel types
Liquid Data compression: survival telegrams packed to SMS-compatible bytes
Show us the Code
GitHub: github.com/Meekoshy/meeko-nerve-center

Here's how each database was created and populated through Notion MCP.

Database 1: Crisis Signal Tracker
Using the notion-create-database MCP tool, we defined a structured schema that maps directly to the output of SolarPunk's CRISIS_MONITOR engine:

Crisis Signal Tracker — schema mirrors data/crisis_signals.json

crisis_tracker_schema = {
"parent": {"page_id": SOLARPUNK_HQ_PAGE},
"title": [{"text": {"content": "Crisis Signal Tracker"}}],
"properties": {
"Signal": {"title": {}},
"Region": {
"select": {
"options": [
{"name": "Gaza", "color": "red"},
{"name": "Sudan", "color": "orange"},
{"name": "Myanmar", "color": "yellow"},
{"name": "Haiti", "color": "purple"},
{"name": "Tigray", "color": "brown"},
{"name": "Ukraine", "color": "blue"},
]
}
},
"Urgency": {
"select": {
"options": [
{"name": "CRITICAL", "color": "red"},
{"name": "HIGH", "color": "orange"},
{"name": "ELEVATED", "color": "yellow"},
{"name": "WATCH", "color": "gray"},
]
}
},
"Source": {
"select": {
"options": [
{"name": "Reddit", "color": "orange"},
{"name": "Wikipedia", "color": "gray"},
{"name": "ReliefWeb", "color": "blue"},
]
}
},
"Action Status": {
"select": {
"options": [
{"name": "DETECTED", "color": "yellow"},
{"name": "AMPLIFIED", "color": "green"},
{"name": "HANDSHAKE_SENT", "color": "blue"},
{"name": "RESOLVED", "color": "gray"},
]
}
},
"Spores Dispatched": {"number": {"format": "number"}},
"Timestamp": {"date": {}},
},
}

Created via: notion-create-database with this schema

Then we populate it by reading the live crisis_signals.json that the CRISIS_MONITOR engine writes every cycle:

Read live crisis data from the autonomous engine output

import json
from pathlib import Path

crisis_data = json.loads(Path("data/crisis_signals.json").read_text())

Transform each signal into a Notion page (row)

for signal in crisis_data.get("signals", []):
page_properties = {
"Signal": {"title": [{"text": {"content": signal["title"][:100]}}]},
"Region": {"select": {"name": signal.get("region", "Unknown")}},
"Urgency": {"select": {"name": signal.get("urgency", "WATCH")}},
"Source": {"select": {"name": signal.get("origin", "Unknown")}},
"Action Status": {"select": {"name": signal.get("status", "DETECTED")}},
"Spores Dispatched": {"number": signal.get("spore_count", 0)},
"Timestamp": {"date": {"start": signal.get("timestamp", "")}},
}
# Created via: notion-create-pages with parent database_id
Database 2: Planetary Health Monitor
This database is a direct mirror of the HOMEOSTASIS.py engine's vital signs — the 10 metrics that tell you whether the planetary immune system is healthy:

From HOMEOSTASIS.py — the actual vital sign definitions

VITAL_SIGNS = {
"engine_count": {"min": 250, "max": 500, "unit": "engines", "critical_low": 200},
"crisis_signals": {"min": 5, "max": 100, "unit": "signals/scan", "critical_low": 0},
"active_sources": {"min": 2, "max": 6, "unit": "data sources", "critical_low": 1},
"trigger_rate": {"min": 0, "max": 50, "unit": "triggers/scan", "critical_low": None},
"handshake_queue": {"min": 0, "max": 20, "unit": "queued emails", "critical_low": None},
"amplification_posts": {"min": 1, "max": 30, "unit": "posts/cycle", "critical_low": 0},
"immune_patterns": {"min": 1, "max": 1000,"unit": "patterns", "critical_low": 0},
"information_voids": {"min": 0, "max": 10, "unit": "critical voids", "critical_low": None},
"silence_events": {"min": 0, "max": 3, "unit": "active blackouts", "critical_low": None},
"spore_count": {"min": 5, "max": 100, "unit": "spores/cycle", "critical_low": 0},
}
The Notion database schema maps these vital signs into a visual dashboard:

Planetary Health Monitor — schema mirrors HOMEOSTASIS.py output

health_monitor_schema = {
"parent": {"page_id": SOLARPUNK_HQ_PAGE},
"title": [{"text": {"content": "Planetary Health Monitor"}}],
"properties": {
"Vital Sign": {"title": {}},
"Current Value": {"number": {"format": "number"}},
"Unit": {"rich_text": {}},
"Min (Healthy)": {"number": {"format": "number"}},
"Max (Healthy)": {"number": {"format": "number"}},
"Status": {
"select": {
"options": [
{"name": "NORMAL", "color": "green"},
{"name": "LOW", "color": "yellow"},
{"name": "HIGH", "color": "orange"},
{"name": "CRITICAL", "color": "red"},
]
}
},
"Deduction": {"number": {"format": "number"}},
"Last Updated": {"date": {}},
},
}
Population reads directly from the diagnose() function output:

HOMEOSTASIS.py diagnose() produces this exact structure

def diagnose(vitals):
"""Compare vitals against optimal ranges — generate diagnoses."""
diagnoses = []
overall_health = 100 # Start at 100, deductions for issues

for key, ranges in VITAL_SIGNS.items():
    value = vitals.get(key, 0)
    status = "NORMAL"
    deduction = 0

    if ranges.get("critical_low") is not None and value <= ranges["critical_low"]:
        status = "CRITICAL"
        deduction = 15
    elif value < ranges["min"]:
        status = "LOW"
        deduction = 5
    elif value > ranges["max"]:
        status = "HIGH"
        deduction = 3  # Over-reacting is less dangerous than under-reacting

    overall_health -= deduction
    diagnoses.append({
        "vital": key, "value": value, "unit": ranges["unit"],
        "range": f"{ranges['min']}-{ranges['max']}",
        "status": status, "deduction": deduction,
    })

return diagnoses, max(0, min(100, overall_health))

Each diagnosis becomes a Notion row via notion-create-pages

for d in diagnoses:
page_properties = {
"Vital Sign": {"title": [{"text": {"content": d["vital"]}}]},
"Current Value": {"number": d["value"]},
"Unit": {"rich_text": [{"text": {"content": d["unit"]}}]},
"Min (Healthy)": {"number": VITAL_SIGNS[d["vital"]]["min"]},
"Max (Healthy)": {"number": VITAL_SIGNS[d["vital"]]["max"]},
"Status": {"select": {"name": d["status"]}},
"Deduction": {"number": d["deduction"]},
"Last Updated": {"date": {"start": datetime.now(timezone.utc).isoformat()}},
}
Database 3: Nature Pattern Engines
This database exposes the NEUROPLASTICITY.py engine's self-rewiring data — showing which of SolarPunk's 17 neural pathways are strong, which are being pruned, and which have been myelinated:

From NEUROPLASTICITY.py — the actual neural pathway definitions

PATHWAYS = {
"crisis_detection": {
"chain": ["CRISIS_MONITOR", "KNOWLEDGE_PULSE", "MURMURATION_RELAY"],
"purpose": "Detect crisis -> transform to help -> distribute",
},
"liquid_data": {
"chain": ["RESOURCE_KIT", "TELEGRAM_RELAY"],
"purpose": "Generate survival kits -> format for all protocols",
},
"silence_response": {
"chain": ["BIOLUMINESCENCE", "TELEGRAM_RELAY", "BROADCAST_PROTOCOL"],
"purpose": "Detect silence -> push cached data through all channels",
},
"immune_response": {
"chain": ["IMMUNE_MEMORY", "CRISIS_MONITOR", "EMAIL_OUTREACH"],
"purpose": "Recall crisis pattern -> fast-track response",
},
"dispersal": {
"chain": ["SPORE_DISPERSAL", "MURMURATION_RELAY", "SOCIAL_PROMOTER"],
"purpose": "Saturate all channels with help content",
},
"void_filling": {
"chain": ["OSMOSIS_ROUTER", "AMPLIFY_ENGINE", "CONTENT_HARVESTER"],
"purpose": "Detect under-covered crises -> route attention there",
},
"collective_decision": {
"chain": ["QUORUM_SENSE", "CRISIS_MONITOR", "BIOLUMINESCENCE"],
"purpose": "Collective signal threshold triggers coordinated response",
},
"health_monitor": {
"chain": ["HOMEOSTASIS", "WORKTREE_ANCHOR", "DARK_WATCH"],
"purpose": "Monitor system health -> detect degradation -> alert",
},
# ... plus 5 more pathways
}

Notion database schema for the neural pathway tracker

engine_tracker_schema = {
"parent": {"page_id": SOLARPUNK_HQ_PAGE},
"title": [{"text": {"content": "Nature Pattern Engines"}}],
"properties": {
"Pathway": {"title": {}},
"Engine Chain": {"rich_text": {}},
"Purpose": {"rich_text": {}},
"Strength Score": {"number": {"format": "number"}},
"Status": {
"select": {
"options": [
{"name": "MYELINATED", "color": "green"},
{"name": "STRONG", "color": "blue"},
{"name": "ACTIVE", "color": "default"},
{"name": "WEAK", "color": "yellow"},
{"name": "PRUNED", "color": "red"},
]
}
},
"Myelinated": {"checkbox": {}},
"Last Fired": {"date": {}},
},
}

Populate from NEUROPLASTICITY's measure_pathway_strength() output

for name, pathway in PATHWAYS.items():
strength = measure_pathway_strength(name, pathway)
status = "MYELINATED" if name in neuro_state["myelinated"] else \
"STRONG" if strength > 70 else \
"ACTIVE" if strength > 40 else \
"WEAK" if strength > 20 else "PRUNED"

page_properties = {
    "Pathway": {"title": [{"text": {"content": name}}]},
    "Engine Chain": {"rich_text": [{"text": {"content": " -> ".join(pathway["chain"])}}]},
    "Purpose": {"rich_text": [{"text": {"content": pathway["purpose"]}}]},
    "Strength Score": {"number": strength},
    "Status": {"select": {"name": status}},
    "Myelinated": {"checkbox": name in neuro_state["myelinated"]},
}
# Created via: notion-create-pages

How I Used Notion MCP
SolarPunk's 269 engines write JSON files to disk. They communicate through data — crisis_signals.json, homeostasis.json, neuroplasticity.json, spore_dispersal.json. The engines don't need a GUI. But humans do.

The problem: How do you let a non-technical volunteer monitor a 274-engine autonomous system? You can't ask them to cat data/homeostasis.json | jq .overall_health. You can't ask them to SSH into a server and read pathway strength scores.

The solution: Notion MCP bridges the gap between autonomous Python engines and human-readable operational dashboards.

Here's what Notion MCP unlocked:

1. Programmatic Database Creation
   Instead of manually clicking through Notion's UI to create databases with the right columns and data types, we used notion-create-database to define schemas that mirror the exact structure of our engine outputs. The Crisis Signal Tracker's columns map 1:1 to the fields in crisis_signals.json. The Planetary Health Monitor's columns map 1:1 to HOMEOSTASIS.py's VITAL_SIGNS dictionary. No translation layer. No middleware.

2. Live Data Population
   Using notion-create-pages, we push live engine output directly into Notion rows. When the HOMEOSTASIS engine runs its diagnostic cycle and scores planetary health at 89/100, that number appears in Notion. When CRISIS_MONITOR detects a new signal from Sudan via ReliefWeb, a new row appears in the Crisis Signal Tracker with the urgency score, region, and source already populated.

3. Operational Visibility for the Whole Team
   The real power is what happens after the databases exist. Notion's native filtering, sorting, and views mean anyone can:

Filter Crisis Signals by region to see everything happening in Gaza
Sort by urgency to find CRITICAL signals that need human attention
Track action status to see which signals have been amplified vs. still waiting
Monitor vital signs and spot when the system is running "too hot" (over-posting) or "too cold" (missing crises)
See which neural pathways are myelinated — which engine chains are battle-tested and which need attention

1. The Bridge Between Autonomous and Human SolarPunk is designed to run without human intervention. But Notion MCP gives it something critical: accountability. Every crisis signal it detects is visible. Every vital sign is auditable. Every neural pathway's strength is transparent.

The system breathes on its own. Notion lets you watch it breathe.

Why This Matters
There are 100+ million forcibly displaced people on Earth right now. Information blackouts are a weapon. Help doesn't reach the people who need it because the signals get buried, censored, or ignored.

SolarPunk doesn't wait for permission. It detects, compresses, disperses, and amplifies. It remembers what worked (immune memory) and does it faster next time. It detects silence and generates light (bioluminescence). It routes attention to the forgotten crises (osmosis). It fires when the collective signal reaches threshold (quorum sensing).

And now, thanks to Notion MCP, every bit of that autonomous operation is visible in a tool that 100 million people already know how to use.

A healthy organism doesn't need to think about breathing. It just breathes.

Repo: https://github.com/meekotharaccoon-cell/meeko-nerve-center/tree/main