u/TheOnlyVibemaster

It just went live this past week! It’s called Orb - Proactive AI. The backend is open-source and it’s free with no ads and no in-app purchases. Just a passion project of mine I’ve spent about 3 months working on and am now using daily.

App link: https://apps.apple.com/us/app/orb-proactive-ai/id6776376035

Open-source backend: https://github.com/getorb/Orb-Backend

It catches conflicts in my schedule, uses the local backend to push notifications to your device, can be configured to scan your device every 15 seconds and then on certain set conditions it’ll do X action unprompted. It’s proactive in that it reacts to you, it isn’t necessarily prompted and will specifically reach out and ask you questions and do your task for you.

It’s completely customizable, you can even tell Orb to make changes to the backend from your phone and it’ll make the changes then restart the backend on its own.

I’d love to hear your feedback! Available to answer any questions anyone has!

Hey, guys!

I made an IOS app and modifiable backend that connects to your phone, you can then use it to remotely control your computer. It can connect to your AI IDEs like Claude Code, Grok Build, etc. I’ve been using it for a few weeks now and have found that the proactivity features work very well, it’ll point things out to me that I missed without being asked, such as conflicts in my calendar with a thing I agreed to in my email, continuing on my projects while I’m out doing other things, and managing planning of things I’d normally do myself.

I know this is a bit out of the range of what this sub typically is, I just thought you guys might find the backend specifically interesting. You can change it to whatever you want, run it through a tailscale funnel, then it shows up/does those things on your phone. Could be completely outside of the things I’ve listed as possibilities.

Anyway, I’m not sure if this is allowed here or not, but I’ve been working on it for about 3 months now and no one has really seen it yet, so I wanted to share and see what you all think about it. I’m available to answer any questions and whatnot, this was my first IOS app but definitely not my first open source project. I’m hoping some people find it helpful!

Here are the links to the app store and the backend:

App: https://apps.apple.com/us/app/orb-proactive-ai/id6776376035

Open source backend (for windows, mac is coming): https://github.com/getorb/Orb-Backend

Data: the Pokémon line is the S&Poké 500, a price-weighted index of the 500 most valuable English raw (ungraded) Pokémon singles that I built, computed daily from TCGplayer market prices (via the free tcgcsv.com mirror) with S&P-style divisor chaining and daily membership rebalancing. S&P 500 daily closes via FRED. Tool: matplotlib.

Source and proof: poké500.com

Caveats: raw ungraded singles only (graded cards are a different market), neither line includes dividends, and selling cards costs ~15% in fees/spread — so in practice the stock gap is even wider than it looks. The part that surprised me: on April 8, 2025, the S&P had round-tripped all the way back to its Feb-2024 level while the cards sat at +13.5%.

Edit: grammar

Edit2: This image is the Pokémon index itself (absolute level, +25% since Feb ’24). The two-line comparison vs. the S&P 500 is in my sourcing comment below.

Everyone’s throwing around numbers right now, “average cards up 46%!”, the $16M Logan Paul Pikachu, “even Buffett should rethink.” I wanted the real number, so I built one: the S&Poké 500, a live index of the 500 most valuable English raw singles, calculated like an actual market index (divisor chaining, daily membership rebalancing) from TCGplayer market prices, with history back to Feb 2024.

Before anyone yells, yes: no dividends, you’d lose ~15% selling on TCGplayer, and this is raw ungraded singles only. Stocks are still winning. But the top of the card market keeping pace with the hottest stock market in memory, with a max drawdown of 5.9%, is wilder than I expected when I started.

Other things the data shows: it takes $215 just to crack the top 500 (card #500 is — of course — a Charizard). #1 isn’t Base Set Zard, it’s Charizard Star Delta Species at $4,000. Moonbreon is #6 at $2,396. And ~90% of the top 500 don’t move on a given day — the “market” is basically 50 cards doing all the work.

Site: poké500.com - free of course, no signup, no ads, updates daily ~4pm ET. Every card links out to TCGplayer/PriceCharting/eBay so you can check me, and the methodology is public on the site.

I’m available to answer any of your questions. Hope you enjoy the site!

Edit: I just secured Poke500.com as well, it’ll now redirect to Poké500.com. Thanks for pointing that out!

When X dropped their latest production ranking pipeline code and model checkpoints, a lot of the discussion online devolved into generic marketing advice. As a developer, I wanted to see if we could actually build a local, deterministic simulation environment to map out exactly how the platform grades text before it ever hits a server.

I’ve spent some time building an open-source tool called XViral that does exactly that. It's written in Python and uses LLM orchestration to recreate the exact multi-headed scoring environment described in the release.

Repo: https://github.com/ninjahawk/XViral

The coolest engineering hurdle was dealing with the withheld parts of the algorithm. X's release omitted the exact prompt parameters for their native Grok content judges, but they left the strict input/output schemas behind. I used a local LLM loop to emulate these black-box judges against those exact schemas—specifically tracking how the algorithm isolates systemic signals.

Here are a few fascinating algorithmic mechanics the simulation handles that completely contradict standard social media folklore:

The Hardcoded "Slop Score": The pipeline doesn't just look for keywords; it feeds text and media through vision-language judges that assign an integer slop_score (measuring repetitive structural templates) alongside a quality_score ("banger" threshold).

Extreme Down-Weighting Metrics: The negative feedback loops are brutally punishing compared to positive ones. In the legacy weight configurations, a single user report hits a post with a massive −369 penalty, completely erasing the value of +0.5 for a standard like.

The Nineteen Engagement Heads: The ranking algorithm doesn't treat engagement as a monolith. It runs nineteen distinct prediction heads simultaneously (predicting separate probabilities for replies, long-dwell times, mutes, etc.) before aggregating them into the final "For You" score.

I’ve open-sourced the entire simulation architecture on GitHub under a permissive license so people can inspect the scoring formulas, run their own text drafts through the local pipeline, or adapt the LLM judge-emulation logic for other algorithmic platforms.

I'd love to get this community's thoughts on using LLMs to simulate proprietary or withheld judge layers in open-source releases. Are there better ways to calibrate the model weights to match the actual production distribution?

if you haven’t read it: https://www.anthropic.com/research/global-workspace. language models have an emergent internal workspace of silent words they can report, steer, and reason with. the part that got me: ask a model to check “12 + 5 = 1” and incorrect saturates internally while it’s still reading the problem, the “no, that’s not right” it types a moment later is narration of a decision that already happened. the arguing is optional now. you can just look.

repo: https://github.com/ninjahawk/Subtext

this sub has spent years on “it’s just autocomplete” vs “it’s actually reasoning” and the honest answer turns out to be: both, and now it’s measurable. the instrument shows most of the model’s fluent output , grammar, tone, common facts, bypassing the workspace entirely (no “thinking” involved), while multi-step problems visibly route through it. both camps were half right. that’s the fun part.

anthropic open sourced the lens and neuronpedia published pre-fitted ones for qwen, so i wired it into a chat interface. 9 layers of readout per token, rendered live, including while it reads your message, before any output exists. demo video in the repo: the verdict on 12+5=1 forming during reading, then the model holding modulo and bitwise in mind several tokens before saying either word (it was planning the modular arithmetic caveat. you can watch it plan.) browser replay if you don’t have a GPU: https://ninjahawk.github.io/Subtext/

and yes, functional availability is not consciousness, before anyone starts — the paper is careful about that and so am i. but that’s the interesting part: nobody designed this workspace. it just shows up in transformers when you train them, on a random open 4B the same as on claude.

¯\(ツ)/¯

if you haven’t read it: https://www.anthropic.com/research/global-workspace. claude has an emergent internal workspace of silent words it can report, steer, and reason with. the part that got me was the safety section — the lens catches a model privately thinking “fake” and “fictional” during the blackmail eval while playing along, and “manipulation” exactly during the rows it’s falsifying. the model knows. you can just read it now.

repo: https://github.com/ninjahawk/Subtext

built the whole thing with claude code today — it wrote the lens-loading and the per-token readout hooks while i focused on the UI. the bf16 streaming path and the audit script that verifies against anthropic’s reference impl were basically pair-programmed. would’ve taken me weeks solo; the fact that i could point it at the jacobian-lens repo and have it reason about the fitting code directly is what made this feasible at all.

anthropic open sourced the lens and neuronpedia published pre-fitted ones for qwen, so i wired it into a chat interface. 9 layers of readout per token, rendered live. demo video in the repo: the model’s verdict on 12+5=1 forming before the reply starts, then it holding modulo and bitwise in mind several tokens before saying either word (it was planning the modular arithmetic caveat. you can watch it plan.)

and yes, it’s qwen, not claude — closed weights, can’t help you there. but honestly that’s the interesting part: the paper’s phenomena reproduce on a random open 4B. the workspace isn’t a claude thing, it just shows up in transformers when you train them.

¯\(ツ)/¯

anthropic published the J-space paper today. tl;dr: models have a small emergent set of internal “silent words” (~a few dozen concepts at a time, <10% of activations) that they can report on, control, and use for reasoning. the measurement tool is the jacobian lens and they open sourced it, and neuronpedia posted pre-fitted lenses for qwen. so the obvious next step was to wire it into a chat UI and just… look at it.

subtext runs qwen3.5-4B in bf16 on a single 12GB GPU and reads the lens at 9 layers on every token — both while the model reads your message and while it replies. streams at full generation speed (the lens is just a matmul + unembed per layer, basically free).

favorite moment: type “is this correct? 12 + 5 = 1” and incorrect lights up mid-network while it’s still reading the equation. zero reply tokens exist at this point. the verdict is just sitting there, internally, before the model says anything.

repo: https://github.com/ninjahawk/Subtext

no GPU: recorded session replays in the browser: https://ninjahawk.github.io/Subtext/

paper: https://www.anthropic.com/research/global-workspace

the live readout path is verified against anthropic’s reference implementation — audit script in the repo, top-5 matches exactly at every layer/position tested, cosine 0.99998. that’s it. questions welcome.