pablo-chacon

I have been exploring a concept I call Sovereign, Self-Healing AI (SSHAI). Unlike generative models, it operates deterministically at system level, collecting machine-level data without human steering.

A theoretical use case is healthcare. Instead of trial-and-error prescribing, SSHAI could continuously ingest medication outcome data from clinical trials and anonymized patient records, then rank treatments by predicted success probability for an individual patient profile (age, weight, vitals, prior responses, etc).

The doctor would still decide, but with a fact-based ranked advisory that self-heals as new data flows in. Technically this is feasible today using existing APIs and statistical methods, the harder part is access to data and regulatory acceptance.

https://github.com/pablo-chacon/Sovereign-Self-Healing-AI/wi...

Just wanted to share a quick traction snapshot from the ecosystem between Aug 13–26:

~235 total clones

~170 unique cloners

~772 views

Early adoption milestone: UrbanOS was forked within 24h of release → https://github.com/jjiburg/UrbanOS-POC-NYC

Full ecosystem analysis (repo by repo breakdown, adoption signals, and diagrams) is here: https://github.com/pablo-chacon/Sovereign-Self-Healing-AI/wi...

Small update for anyone following UrbanOS. I refreshed the client templates and the MQTT simulations so implementation and testing are more straightforward. The client repo documents the MQTT publish contract, a Termux quick start, and DB field notes for map friendly ST_AsGeoJSON selects. The simulations repo includes load and capacity math that translates short runs to real fleet equivalents. UrbanOS is the intelligence layer, deployers own filtering and exposure. No telemetry, no cloud lock in, deployers own their data, the community decides what gets built on top. Happy to answer technical questions.

Links:

mqtt-client-templates: https://github.com/pablo-chacon/mqtt-client-templates

mqtt-simulations: https://github.com/pablo-chacon/mqtt-simulations/tree/main

UrbanOS-POC: https://github.com/pablo-chacon/UrbanOS-POC

I just added a wiki page with a full architectural diagram of the Sovereign, Self-Healing AI. It outlines how the system ingests data via MQTT, stores it in PostgreSQL with PostGIS, and processes it through modular services like clustering, POI detection, and predictive modeling. Routing is handled with A* and MAPF, fused with GTFS and GTFS-RT feeds, so the system can continuously generate personalized paths that adapt in real time.

The architecture is asynchronous and per-client, modules never talk directly to each other, only through the database. This makes the system resilient, privacy-scoped, and self-healing when data is delayed or corrupted.

If you want to see how the pieces fit together and how the self-healing loop works, the wiki page has the full diagram: https://github.com/pablo-chacon/Sovereign-Self-Healing-AI/wi...

Less than a day after I released UrbanOS someone had already cloned it and started experimenting with it. That was a very humbling moment for me. My only hope is that the project spreads and becomes useful for people. The goal of UrbanOS has always been to remain free and serve humanity, so every time I see it picked up or adapted it feels like confirmation of that vision.

For anyone interested, here's the link to the clone repo: UrbanOS PoC NYC adoption: https://github.com/jjiburg/UrbanOS-POC-NYC

I would like to share a concept I have been working on, called Sovereign, Self Healing AI. It is an architectural approach for designing AI systems that are resilient, transparent, and respectful of individual sovereignty.

The focus is on building systems that operate on general purpose hardware, make deterministic decisions from machine level data, and heal themselves without requiring manual intervention. The design emphasizes privacy, transparency, and respect for individual autonomy, while remaining auditable and aligned with data protection regulations such as GDPR and HIPAA.

This is not meant to be a commercial product, it is a framework and a set of principles that can be applied across many domains. I am sharing it openly in the hope of sparking discussion, learning from feedback, and encouraging others to think about AI design in ways that empower people and societies rather than control them.

GitHub Wiki: https://github.com/pablo-chacon/Sovereign-Self-Healing-AI/wi...

I just released UrbanOS-PoC, a fully open-source system that uses real-time data to optimize public transport flow, without surveillance, black-box models, or cloud lock-in.

It runs on general-purpose hardware (Docker + Postgres + Python), uses MQTT for live data ingestion, and processes anonymized geospatial behavior to produce real-time routing and schedule predictions, without needing any personal identifiers.

I built this system solo over the last few years while raising two kids. I kept it closed for a while, hoping it might help our situation, but since it doesn’t rely on buzzwords, the attention was limited. So now it’s free for anyone who wants to work on urban planning, public mobility, or smart cities, without compromising privacy.

No prompts No user tracking No centralized platform Just logic, movement, and open AI for cities

You can simulate live data, inspect all modules, and spin it up locally on a laptop. Whitepaper, API docs, and demo setup included.

Repo: https://github.com/pablo-chacon/UrbanOS-POC Whitepaper: GitHub Wiki