Today was about giving the satellite engine a skeleton key.

The satellite engine could see, but it couldn’t understand. Day 2 was all about layering context on top of context until patterns start to surface.

---

Environmental Layer First

• ISRIC SoilGrids v2.0: Pulled clay percentage, sand, silt, pH, and organic carbon. Every number comes with uncertainty bounds because soil data is never clean.
• USGS Earthquake Catalogs: If a location has had 20+ quakes, that’s active fault territory and anything buried is scrambled.
• WorldPop Population Density: Tells you whether you’re looking at farmland or wilderness.
• Water Table Depth: Estimated from elevation. Shallow groundwater rots organic material; deep water means preservation.

---

Archaeological Databases

• Wikidata & Pleiades: Hit Wikidata SPARQL directly for Pleiades entries—that’s every known archaeological site in the ancient world.
• GBIF Species Occurrence: Cross-referenced with GBIF data (civilizations cluster near water and arable land, and species distribution proves it).
• NOAA World Magnetic Model: Plugged in NOAA’s WMM for IGRF magnetic field calculations—buried structures distort local magnetic fields.
• NASA VIIRS Nighttime Lights (VNP46A2): Added night light data to map modern human activity patterns.
• Geospatial Helpers: Integrated OpenTopography DEM availability checks, geocoding via Nominatim, and full site suitability scoring based on known site proximity, climate, and magnetic anomalies.

---

Web Archive Evidence

• Wayback Machine CDX API: Search by place name and coordinates, running archaeological keyword matching across archived pages.
• OSM Overpass: Querying historic and heritage feature tags.
• Building Density Analysis: Sparse buildings in a fertile area = something’s off.

---

Cross-Reference Engine

Pleiades, Wikidata, GBIF, and VIIRS nightlights all get matched against each other. If an ancient settlement shows up in three sources but the area is now empty, that’s a red flag.

• Temporal Trends: Pulled temperature trends from Open-Meteo (2020–2023) to analyze climate shifts.
• Batch Scanning: Built batch capabilities so you can process 20 sets of coordinates simultaneously.

---

Fusion Engine — The Actual Brain

Took every data source and wired them into a 7-component weighted scoring system:

• Satellite Anomaly Score (35%)
  Signal strength × data quality × inverse correlation bonus when NDVI/NDWI/thermal agree.

• Soil Preservation (20%)
  Clay > 350g/kg = +35%, Sand > 600g/kg = -25%, pH 6.5–8.0 sweet spot.

• Seismic Filter (10%)
  20+ quakes = -25%, Moderate = -10%, Quiet = neutral.

• Water Table Depth (10%)
  <5m = -20%, >30m = +20%, No data = +30%.

• OSM Historic Context (10%)
  Historic features nearby = +30%, Dense = neutral, Sparse = survey opportunity.

• Temporal Consistency (10%)
  Significant NDVI trend + $R^2 > 0.3$ = +30%, Change events = +5%/event.

• Web Archive Evidence (5%)
  Archaeological content in history = +55%, Multiple hits = +25%.

Chronovisor — Devlog 1 🍓😺

So I had an idea that probably sounds a bit out there at first glance: What if you could point at any spot on Earth and get a read on whether something is buried underneath? And what if you could do it without ground-penetrating radar, drones, or anything physical—just satellite data and a bunch of free APIs?

I decided to see if I could actually build it. I’m calling it Chronovisor.

---

What I actually did

The core of the project is a satellite data engine that pulls imagery directly from Google Earth Engine. Right now, I’m tapping into Sentinel-2 data (10m resolution, available from 2017 onward) and calculating spectral indices directly from the raw band data. I’m tracking:

• NDVI (Vegetation health)
• NDWI (Moisture levels)
• NDBI (Built-up/urban areas)
• Plus: BSI, SAVI, and NDMI.

The underlying theory is straightforward: buried structures mess with the surface. A stone foundation stops roots from growing properly. Ancient walls alter water drainage. Different materials retain heat differently. If you can read those subtle patterns from orbit over time, you can potentially spot an archaeological site or a forgotten structure without ever setting foot on the ground.

For the heavy lifting, I built an anomaly detection pipeline that flags anything sitting two standard deviations away from the mean across the time series. The math isn’t overly complex, but it’s highly effective. When a specific coordinate consistently shows up as “weird” across multiple independent satellite passes, you know you’ve got a real signal.

The piece I’m most proud of is the structural probability scoring. I detrend the NDVI and thermal data to strip out seasonal spikes, then check if they’re inversely correlated. If you have uncharacteristically low vegetation right where the thermal signature is unusually high (or vice versa), that’s the classic signature of subsurface interference. The code evaluates this and outputs a score from 0 to 100. It doesn’t declare a definitive “find”—it just screams, “Hey, look closer at this exact spot.”

On the infrastructure side, I set up:

• A FastAPI backend utilizing a two-tier cache (in-memory + disk) with SHA-256 hashing to keep things snappy.
• A clean CLI entry point for quick scripting.
• A Leaflet-based frontend styled in a dark theme (obviously).

---

Managing Expectations: What it actually does

I want to be completely transparent about what this tool is—and what it isn’t.

This system does not tell you what is underground. It analyzes surface patterns and scores how likely it is that something is disrupting them. When the system flags a “possible buried structure,” it is strictly saying that the vegetation and thermal patterns match the footprint of subsurface interference. Nothing more.

The signal processor uses real analytical tools—Fast Fourier Transforms (FFT), harmonic detection, and autocorrelation. However, it requires legitimate sensor data to function. It doesn’t conjure findings out of thin air, and the EM field mapping elements are tools for processing input data, not magic discovery engines.

---

What’s next

Right now, the satellite engine is great at spotting anomalies, but it has zero context about the ground it’s looking at.

Next up, I’m building connectors for:

• Local soil composition data
• Seismic activity logs
• Water table estimates
• An archaeological database queried via Wikidata SPARQL.

The goal is to evolve the output from a basic “this spot has weird NDVI” into something incredibly actionable: “This spot has a strange NDVI anomaly, sits on a clay soil type known to preserve structures, is located within 2km of a known ancient settlement, and suffers from low seismic noise.”

That’s the kind of signal that gets interesting. Stay tuned.

personal site devlog

built my personal site from scratch, html css js only. dark grunge/y2k/emo vibe kinda theme, no libraries no frameworks just raw code.

opens with a piano key loading animation… 7 white bars pressing down in sequence like keys being played, fades out after the page loads. replaced the default cursor with a custom one, a hollow circle that follows your mouse and a trailing dot behind it with a smooth lerp. glows blue on hover over anything clickable. whole page has film grain overlay and vignette so it feels like a worn VHS tape. grain actually shifts position to look like real film.

hero section is the densest part. 16 floating images covering the entire viewport including the center, overlapping each other, all with parallax that shifts based on your mouse position. each image has a data-depth value so they move at different speeds. every image is also draggable. behind the name theres a canvas running 60 particles drifting around, connected by faint lines when they get close to each other. “SUBHANSH” has a VHS glitch effect that fires briefly every 8 seconds… not the neon RGB kind, more like a worn tape tracking issue lol. each letter floats independently with staggered delays. the tagline “pianist / flautist / builder” types out character by character with a blinking cursor. hero also has scanlines, a VHS tracking line sweeping down the screen, scratches, crosses, spider webs in all 4 corners and spiders scattered around at low opacity. that old myspace goth vibe fr

every section has the same set of goth dressings… crosses, scratches, spider webs in corners, faint stains and tiny dots. all at 2-6% opacity so its background texture not in-your-face graphics. thin gradient dividers with tick marks between each section.

about section image has a 3D tilt effect that follows your cursor in perspective. also has an offset border that expands on hover and a scanline overlay. stat counters animate up from 0 when they scroll into view. hobbies section has draggable image windows you can actually grab and move around. project rows shift left on hover with a gradient glow sweep and the tilt effect. gallery items have labels that slide up from the bottom.

music section has a 24-bar visualizer that pulses at different speeds and a mini piano that actually plays real notes through the Web Audio API. you can click the keys or use your keyboard (a-k for white keys, wetyu for black ones). triangle wave, accurate frequencies, keys visually depress when pressed. ong this was the funnest part to build

contact section has a terminal that types out commands when it scrolls into view, handles html tags properly so the colored prompt text doesnt break. social cards and nav links have a magnetic effect… elements physically follow your cursor before snapping back when you leave. responsive on mobile with hamburger menu, custom cursor and all decorations hidden on small screens. visitor counter in the footer stored in localStorage.

final devlog for mewo os 🍓😺

okay so guess wat… i was debugging mewo again and again for a bug that wasnt even real 💔… what happened is.. i opened mewo saw that nothing is functional and i was like everything looks gud why its not wokring… and then i saw my mails and found out that vercel and supabase paused my web cause i ran out of the free tier 💔😭…

anyways aside from this i added ts js for the vibes lol

• Window Switcher
  Open 2+ apps (e.g. Calculator + Terminal + Notes)
  Press Ctrl+Shift+A — overlay appears with all open windows
  Press Tab to cycle forward, Shift+Tab to cycle backward
  Release Shift or click a window to switch to it
  Escape to cancel

also i did optimized mewo earlier but it was still lagging a bit cause of overlaying animations and effects so i fixed that too ts time

redeployed on vercel again!!

• try it out ^-^ :- https://mewoos.vercel.app

MewoOS Devlog #8 🍓😺

Pixel Cat Redesign
redesigned the pixel cat that follows ur cursor around the desktop. she looks way better now ngl…more detailed sprite, smoother animation, and shes silver now which fits the dark theme way more. u can click her to toggle between following ur cursor or staying pinned. small thing but it makes the whole desktop feel alive fr

Meo Can Control The OS (waw..dem )
this ones big. meo can now literally control the whole os. tell her “open the calculator” and she opens it. “open the terminal” — done. “minimize all windows” — gone. she parses whatever u say and does OS actions through action tags. supports open, close, min, max, focus, minimizeAll, closeAll. feels like ur actually talking to the os not just a chatbot
Voice & Emotions Rework
improved meos voice n emotions big time. she now detects what ur saying and adjusts — happy, excited, concerned, playful, calm, tired, urgent. each one has its own rate, pitch, personality. the voice sounds way less robotic now and more natural. also fixed that annoying thing where the reply would show up in the chat 4 seconds before the tts spoke it. now they happen at the same time so its smooth
4 Desktop Workspaces
added a desktop workspace system. u get 4 separate desktops switch between them with ctrl 1 2 3 4. each desktop has its own windows so u can have coding stuff on desktop 1 music and browser on desktop 2 etc. ctrl left right cycles between them. feels like a real os now not just a web page

Mewo Store(new feature…yey)
built a full app store for mewoos. premium dock style icons glassmorphism ui category filters search the works. and the apps u can actually install and they actually work when u open them
Installable Apps

• weather — 5 cities 7 day forecast animated temp bars humidity wind stats
• kanban board — drag and drop 3 columns colored tags 7 pre loaded tasks
• focus timer — working pomodoro timer svg ring progress 3 modes focus short long session stats
• type racer — typing speed test real time character highlighting green red wpm calc 8 sentences
• paint studio — actual working canvas color picker brush size clear button u can draw on it
• image editor — 8 filter presets original warm cool b&w vintage vivid fade noir brightness contrast saturation sliders uses a real image
  Store Features
  when u install an app theres a progress bar animation then the app icon shows up in the dock with a premium dock style icon. and u can uninstall apps too removes from dock and closes any open windows…. mewo meow mewo

OKAAAA WE’RE BACCKKK.. aaa so i did all of the basic stuffs in the webos1 (mandatory features, basic glass morph for the windows, parallax effects on the wallpaper etc) so now in the part 2… its time to take this further…

so i started with fixing the lag and some minor bugs and then we redesigned every window and dock with an aurora tint and enhanced glassmorphism with glare and then came the features that i added… i mean they are not complete but the base is ready

the dock got upgraded
added a Files app(new feature..yey) to the dock with a sky blue gradient icon. the file manager opens with a proper glassmorphic window. breadcrumbs for navigation, grid and list views, right click menus, inline rename… the whole deal. double click a file and it opens in an editor with Ctrl+S to save. tab inserts spaces. its got the mewoOS glass treatment on everything

what is meo (new feature…yey)
so meo is basically the AI assistant that lives inside MewoOS. think of it like Siri but actually useful and with personality….a menace on silicon.
u tap the orb, speak to her, and she responds. she can open apps, close them, minimize, maximize — basically control the whole OS with voice. she has emotions too — happy, excited, concerned, playful, calm, tired, urgent — and her voice changes based on that. she roasts u but its from love. like a best friend who also happens to be an AI running inside an operating system
the whole thing runs on Gemini — both the brain (chat) and the voice (TTS). she uses Gemini 2.5 Flash for thinking and Gemini 2.5 Flash Preview TTS for speaking back to u with different voices depending on her mood

now the part that took forever — making meo actually work
bruh so making meo work took some work… idk how many times i debugged for her to actually listen to me
the STT problem
so the original problem was the Web Speech API — that thing is just unreliable as hell. it only works in Chrome, needs HTTPS or localhost, and half the time it just doesnt fire onresult at all. like u speak, it says “listening…”, then nothing happens. the text never shows up. no transcription, no response, nothing
i tried fixing it multiple times — started recognition immediately instead of waiting for mic permission, added error handling, changed the flow… still broken. the Web Speech API is just built different (bad different)
so i ripped it out completely. replaced it with MediaRecorder + Gemini for transcription. now when u tap the orb it records audio using the MediaRecorder API, sends the audio blob to Gemini, and Gemini transcribes it. way more reliable because it doesnt depend on browser-specific speech engines. it just works
the gemini model error
THEN the gemini model error… we had the wrong model names everywhere lol

• the chat model was set to gemini-3.5-flash which literally doesnt exist
• the TTS was gemini-2.5-flash-preview-tts which kept failing silently and falling back to browser TTS
• the STT was using gemini-2.0-flash which was mid
  so we updated everything to the right models:
• chat: gemini-2.5-flash (the actual latest flash model)
• TTS: gemini-2.5-flash-preview-tts (the dedicated TTS model with audio output)
• STT: gemini-2.5-flash (for transcribing the recorded audio)
  and added detailed console logging so we can actually see whats happening when things break. because before it was just silently falling back to browser TTS and we had no idea why
  the final pipeline:

1. u tap the orb
2. MediaRecorder starts capturing audio from the mic
3. waveforms animate while u speak
4. u tap again to stop
5. audio blob gets sent to Gemini for transcription
6. transcription goes to Gemini for the actual response
7. Gemini responds with text + emotion
8. response gets spoken back using Gemini TTS with the right voice

Vibe Check — Devlog 🍓

well…

there was a pretty big plot twist.

the original plan was to ship Vibe Check as a Chrome extension.

everything was already built around that idea.

popup UI.
chrome APIs.
extension architecture.
the whole thing.

then i found out Google wants a $5 one-time fee just to publish an extension.

and honestly…

i was NOT about to pay $5 just so my little prompt tool could exist on the Chrome Web Store 😭

so…

i scrapped the entire extension idea.

---

which meant i had to redesign…

basically everything.

the whole app was originally designed around a tiny popup window.

now it had to become a full webpage.

different layout.

different navigation.

different spacing.

different interactions.

pretty much every screen got rewritten from scratch.

the funny part is that none of the actual features changed.

they just had to be rebuilt in a way that actually made sense on a full website.

---

while rebuilding everything i also decided to add a feature i honestly wish more AI tools had.

Token Saver :3

after Vibe Check analyzes and improves your prompt…

it can now convert the final prompt into Chinese.

before anyone asks…

no, this isn’t some weird translation gimmick 😭

the reason is actually pretty simple.

Chinese is far more information-dense than English, so the same instructions usually require significantly fewer input tokens.

that means:

• lower API costs
• fewer prompt tokens
• more room inside the context window

without changing what the prompt is actually asking.

the AI still understands exactly the same instructions.

if you want the response in English, you can literally just add:

“Respond in English, even though my prompt is written in Chinese.”

and it’ll work exactly the same.

so now Vibe Check doesn’t just make prompts better…

it also tries to make them cheaper to run.

which i thought was a pretty neat addition :3

meow

Vibe Check — Devlog

said last devlog i’d be tackling the UI redesign next. did that. also did about four other things i didn’t plan on. classic me.

two days, and somehow: bug fixes, the redesign, AI integration, a whole landing page, and deployment setup. CSS changes enough to make me question my existence 💔

---

bugs that were silently ruining everything

found out half the buttons in the app weren’t even styled because the css class they used literally didn’t exist 😭

also discovered template search wasn’t searching anything because the input id was missing.

the search bar looked functional.
it was not.
meow.

fixed a bunch of cursed unicode issues too because apparently some checkmarks had transformed into ancient artifacts from another dimension.

---

the redesign arc 🥀

this one was planned, but it still spiraled way harder than expected.

changed one thing. then another. then suddenly popup.css was over 700 lines.

goodbye neon cyberpunk.
hello warm golds, soft reds, glass panels, crystal backgrounds, rounded corners and way too many blur effects.

the whole thing feels a lot calmer now.
less “rgb gaming keyboard”
more “expensive thing i can’t afford” :3

---

ai brain upgrade

probably the biggest change, and definitely not planned.

vibe check can now use Cerebras gpt-oss-120b for prompt enhancement.

ended up building support for:

• local development
• chrome extension mode
• production deployment

all using the same enhancement pipeline.

if ai dies the app automatically falls back to local enhancement so users don’t get hit with a giant error message.

because nobody likes giant error messages.

---

built a whole landing page because apparently i enjoy suffering

didn’t even plan this one.

but now there’s:

• animated hero section
• glassmorphism everywhere
• feature cards
• demo section
• platform showcase
• responsive layout

and enough floating visual effects to make my gpu slightly concerned.

---

production stuff nobody will notice

added deployment configs.
serverless functions.
environment variables.
request validation.
api key protection.
cors handling.

all the boring stuff that becomes very exciting when it’s missing.

---

stats

files modified: basically yes
popup.css: 730 lines
popup.js: 1300+ lines

new files:

• landing page
• serverless ai endpoint
• deployment config

:3

VibeCheck Devlog #1 🥀

so…

for the last few days i’ve been building something called VibeCheck.

the idea is pretty simple:

you paste a prompt.

VibeCheck tears it apart.

then tells you how to make it better.

that’s it.

but somehow that “simple” idea ended up turning into an entire app 💔

---

the original problem

i kept seeing the same thing over and over.

people would ask an ai for something.

the result would be bad.

then they’d blame the model.

when half the time the real problem was the prompt.

so i thought…

what if there was a tool that could actually analyze prompts and explain what’s wrong with them?

not just give a score.

actually tell you:

• what’s missing
• what’s unclear
• what’s limiting the output
• how to improve it

and that’s basically where VibeCheck started.

---

browser compatibility was a disaster

one thing i realized pretty quickly…

the whole app depended on chrome extension APIs.

which means outside a chrome extension…

everything exploded 💔

so i built a chrome api polyfill layer.

now VibeCheck can run inside an extension and directly in a browser without completely falling apart.

storage works.

runtime messaging works.

browser preview works.

and the app stops screaming at me every time i open it.

---

template collection got out of control

this one got a little ridiculous.

templates went from:

15 → 38

there’s now stuff for:

• ui components
• full applications
• backend systems
• debugging
• ai prompts
• api development

and probably more coming later because apparently i don’t know how to stop adding things.

---

random suffering

also spent way too long fixing bugs that should not have existed.

you know the type:

40 minutes of debugging.

3 line fix.

questioning life choices afterwards.

those.

---

what’s next?

right now i’m focusing on making the scoring system smarter and improving the actual prompt analysis.

the ui is pretty trash so id be working on that too

the architecture isn’t actively trying to kill me anymore

and VibeCheck is slowly becoming the tool i originally wanted to build

we’ll see how long that lasts before i break everything again 🥀

rumi-Devlog #9 🍓😺✌

today was mostly spent making RUMI faster because some runs were taking an absolutely stupid amount of time 😭

provider stack changes

spent a while profiling the provider chain and found a few cursed bottlenecks.

• disabled Fireworks (credits died, every failed request was wasting ~90s)
• switched GLM routing to Kimi K2.6 via a second NVIDIA key
• tested Cerebras-first vs NVIDIA-first routing

results were funny:

• Cerebras = ~2s/call but discoveries averaged around C grade
• NVIDIA = ~65s/call but much stronger reports

so now different parts of the pipeline use different providers depending on the task.

phase 6.5 speedup

equation generation was committing crimes.

rewrote the whole thing to run in parallel (6 workers).

went from:

• ~16 min
• to ~1 min

for a typical 15 mechanism loop.

also finally fixed the legendary:

0/15 equations generated

bug 😺🍓

literature search

all literature sources now fetch concurrently:

• arXiv
• PubMed
• CrossRef
• OpenAlex
• etc

runtime dropped from ~2 mins to ~64 seconds.

RUMI TUI

probably my favourite thing from today.

built a proper Textual-based TUI so i can actually see what RUMI is doing instead of staring at a terminal for 10 hours.

added:

• real-time phase tracking
• live agent status
• brain module dashboard
• discovery controls
• /brain
• /status
• /dream
• /memory
• /hypothesis

also fixed a bunch of broken brain module APIs that were pretending to work 💀

random bug of the day

RUMI was occasionally turning english into ancient cursed language and generating stuff like:

withinamy

instead of actual words.

fixed topic truncation so it now cuts at word boundaries.

current state

• provider stack healthier
• equation generation WAY faster
• literature search faster
• TUI finally usable
• brain modules actually verified at boot

still spending most of my life waiting for discovery runs to finish though 🥀

rumi-Devlog #8 🍓

Current status: rumis smarter, my codebase survived, and my sanity is questionable 💔

A huge part of this session wasn’t actually spent improving discovery quality.

It was spent improving everything around RUMI.

As RUMI’s discovery pipeline keeps getting bigger, debugging has become a nightmare. Reading raw JSON reports, searching through logs, and manually inspecting hundreds of entities was getting painful.

So I built a full visualization and monitoring system for RUMI.

The dashboard can now visualize:

discovery reports
theory competitions
adversarial testing results
predictions
refinement stages
scoring breakdowns
knowledge graphs
paper collections
hypothesis memory

all from a single interface.

Knowledge Graph Visualization

One thing I’ve wanted for a while was being able to actually SEE what RUMI was discovering.

Not read it.

See it.

So I built an interactive graph explorer using vis.js.

Every entity type gets its own visual identity.

Nodes glow based on type.

Edges scale with confidence.

Hovering shows metadata, paper counts, and relationships.

The graph uses ForceAtlas physics and overlap avoidance to make large discovery graphs easier to navigate.

Watching hundreds of concepts connect together is honestly way more useful than reading raw graph dumps.

🥀

Discovery Report Explorer

RUMI reports have become massive.

Some are hundreds of kilobytes.

Some are over a thousand lines.

Reading those manually sucks.

So I built dedicated views for:

theory competition
adversarial evaluation
predictions
scoring
derivations
peer review
refinement stages

which makes analyzing runs significantly easier.

Provider Stack Surgery 💔

While testing the new recurrent architecture I discovered a huge bottleneck.

Xiaomi MiMo.

It was slow.

Constantly rate limiting.

Burning through provider chains.

And starving downstream phases.

This turned out to be the reason molecule generation kept randomly failing.

So MiMo got removed from the routing stack.

After testing 17 API keys across all providers:

13 healthy
4 problematic

Current routing stack includes:

NVIDIA DeepSeek
Kimi K2.6
Cerebras GPT-OSS-120B
Groq
Gemini
Fireworks

Still chasing down some timeout and rate limit issues but overall the stack is way healthier now.

Discovery Testing

Used the upgraded architecture to stress test RUMI on several difficult domains.

One of the most interesting runs was Molecular Glue Drug Discovery.

Current run stats:

16 hidden variables
15 mechanisms per loop
7 predictions
multiple adversarial survivors
recurrent refinement loops enabled

The architecture is definitely producing stronger outputs than before.
meow meow meow

rumi-Devlog #7 🍓

This was probably one of the most frustrating and important RUMI development sessions so far.

Most people only see the final discovery reports. They don’t see the chaos that happens before RUMI can generate a single theory. And trust me, there was a lot of chaos.

💔 Bug Fixes, Bug Fixes, More Bug Fixes

I started this session thinking I’d make a few improvements and continue testing.

That did not happen.

RUMI’s architecture has reached a point where changing one thing breaks three others. Every time I fixed 3 bugs, another 5 appeared from somewhere else. At one point I genuinely crashed out because every run ended with a new issue that didn’t even exist before.

It felt like:

fix_bug()
spawn_more_bugs(count=5)

Turns out there’s a reason people say:

“If it’s working, don’t touch it.”

Unfortunately I touched it. A lot. 🥀

The Problem

Even though RUMI was producing interesting discoveries, I still wasn’t satisfied. The reports were often interesting, creative, and sometimes novel, but they still felt too generic.

The pipeline would generate a theory, evaluate it once, pick a winner, and move on. I wanted RUMI to spend more time refining ideas instead of treating every discovery as a one-shot attempt.

Falling Into The OpenMythos Rabbit Hole

While researching I came across OpenMythos, a community attempt to reverse engineer Anthropic’s rumored Mythos architecture.

Nobody actually knows how Mythos works, but the community has proposed several reasoning patterns that might explain Claude-style outputs.

I spent hours reading through it asking myself:

“What parts of this could actually work inside RUMI?”

Not copying.

Adapting.

The Biggest Change I’ve Ever Made To RUMI 🥀

One idea stood out immediately: recurrent reasoning loops.

Before:

• Mechanisms
  ↓
• Predictions
  ↓
• Theory Competition
  ↓
• Winner

One pass. One shot.

If mechanism generation was weak, everything downstream became weak too.

So I rebuilt a huge section of the pipeline.

Now RUMI performs a 3-stage recurrent refinement process:

Loop 1 — Exploration

Maximum creativity
Maximum diversity
Broad theory generation

Loop 2 — Refinement

Survivors re-enter the pipeline
Focus on evidence, consistency, and mechanism quality

Loop 3 — Convergence

Lowest creativity
Highest rigor
Final selection of the strongest explanation

Instead of living or dying from a single generation pass, theories now get multiple opportunities to evolve.

Preventing Theory Drift

Another idea I adapted was evidence grounding injection.

Recursive systems often suffer from theory drift, where ideas slowly become disconnected from the evidence that originally generated them.

To prevent this, every refinement loop continuously receives:

Literature evidence
Contradictions
Knowledge gaps
Observed anomalies

This keeps discoveries grounded instead of drifting into fantasy.

Smarter Computation

I also added convergence-aware halting.

Not every scientific problem deserves the same amount of computation. Some topics converge quickly while others require deeper exploration.

RUMI can now monitor improvements between loops and eventually stop refining once discoveries begin stabilizing.

lwk so much happened in these last 17hrs that i cant even include everything in here cause of the word limit 😭🥀

rumi - Devlog #6
June 11, 2026

so yea… pulled an all nighter for this one 🥀

most of the work this time wasn’t adding entirely new systems.

it was stress testing RUMI hard enough to find where the architecture starts breaking.

and honestly i found a lot more than i expected.

• Track B Architecture Improvements

spent a lot of time refining Track B after the initial curiosity pipeline integration.

instead of just generating curiosity questions, it now runs through much more of the actual discovery stack.

lots of internal changes here that don’t really show up visually but massively affect the quality of the final reports.

💔 Constraint Pipeline Fix

found a pretty nasty issue where parts of the generated curiosity constraints weren’t making it all the way through the pipeline.

after fixing it, the results became immediately obvious.

latest dual-track run:

Track A Unique Theories: 9
Track B Unique Theories: 8
Shared Theories: 0

which is honestly one of the strongest signals i’ve seen so far that the dual-track system is actually working as intended.

both tracks are now exploring completely different hypothesis spaces instead of converging on the same ideas.

• Claude Fable 5 Experiment

managed to get temporary access to Claude Fable 5 and immediately decided to throw RUMI at it.

before i could even test it though…

the integration broke 💔

spent a while fixing provider compatibility issues and getting everything working again.

eventually got a discovery run started on:

What happens to information when it crosses a black hole event horizon?

Fable managed to reach roughly Phase 8.5 before the free trial looked at RUMI’s request count and basically said:

aight imma head out 😭

• What Fable Revealed

this ended up being way more valuable than i expected.

while comparing Fable’s outputs with the models i normally run, i noticed a massive difference.

most models tend to generate:

Hidden Variable
↓
Mechanism Description
↓
Prediction

Fable was generating:

Hidden Variable
↓
Mechanism
↓
Equation
↓
Parameter Extraction
↓
Derivation
↓
Numerical Validation
↓
Prediction

actual equations.

actual variables.

actual derivation chains.

actual numerical checks.

🥀 Switching Back To MiMo

after the Fable credits died, i moved everything back to MiMo and started comparing outputs.

and that’s when another weakness became obvious.

the pipeline itself wasn’t failing.

MiMo simply wasn’t producing the mathematical depth needed for the mechanism stage.

which means the current bottleneck isn’t discovery anymore.

it’s mathematical formalization.

Mathematical Formalization Architecture

one of the most interesting things i noticed while testing Claude Fable 5 was how differently it handled mechanism generation.

most models would generate something like:

Hidden Variable
↓
Mechanism Description
↓
Prediction

while Fable was generating:

Hidden Variable
↓
Mechanism
↓
Equation
↓
Parameter Extraction
↓
Derivation
↓
Numerical Validation
↓
Prediction

and honestly that immediately exposed one of RUMI’s biggest weaknesses.

theories and mechanisms were already being generated.

the math wasn’t.

so instead of just complaining about it, i started redesigning the mechanism pipeline around that pattern.

RUMI now has the foundations for a much more quantitative discovery process where mechanisms aren’t just descriptions anymore, which is lwk tuff ig 🥀✌

• equations
• variables
• derivations
• parameter extraction
• numerical validation

Switching Back To MiMo 🥀

after Fable ran out of credits i moved everything back to MiMo and started testing the updated architecture and still doing it cause mimo is like hella slow bruh normally umi takes upto 30-40 mins but now with mimo shes taking aorund 2hr 30mins 💔