The Upside

ANOTHER 17 YEAR-OLD BUILT A $12 MILLION AI APP FROM HIGH SCHOOL. We broke down Zack’s story in @IvoAI3 newsletter this morning 👇 His app Cal AI turns one meal photo into a full nutrition breakdown and now helps 1M+ people track their food.

@IvoAI3 One of our best articles yet

IN @TheUpsideAI THIS MORNING, IT COVERED HOW A 17 YEAR OLD TURNED A $20 CLAUDE SUBSCRIPTION INTO A $30,000/MONTH AI APP. The idea is simple: He used AI to build a text to speech tool without writing the code himself. He asked ChatGPT to create the prompt, pasted it into an AI coding tool, and watched it generate the app in minutes. The tool was able to create features like different voices and voice settings, then deploy the product. A few years ago, building software meant learning to code or hiring developers. Now, the biggest advantage might belong to the people who can use AI to turn ideas into products faster.

@CodeByPoonam This was one of the ideas discussed in the @IvoAI3 newsletter this morning. Very interesting.

do you understand what Anthropic just admitted? AI for students has mixed results. so they built for teachers instead. every other lab is going the opposite direction. it’s called Claude for Teachers - built for the teacher. not the student. what it actually does: → connects to Learning Commons, which gives Claude the academic standards for all 50 states, plus the smaller competencies underneath each one and the order students typically learn them → pulls from real curricula like OpenSciEd and Illustrative Mathematics, so lesson plans arrive already aligned instead of needing to be checked line by line → builds differentiation plans, adapting the same lesson for students at different readiness levels, with scaffolds for multilingual learners and accommodations for IEPs → connects to ASSISTments, Brisk Teaching, and Canva Education → can pull a student’s past assessment data and assignment history and draft individualized plans overnight the real bet: →everyone else is trying to build the AI students use. →Anthropic is trying to build the one teachers can’t work without. those are very different companies in five years.

@itsharmanjot @IvoAI3 mentioned this today. Exciting to see it developing.

I replaced our Datadog bill with a single binary and cut infrastructure costs by 98% overnight. It’s called OpenObserve. Logs, metrics, traces, and frontend monitoring in one tool, self-hosted, and it’s built specifically to stop the bill that grows every time you add a host, a user, or a custom metric. → One binary, running in under 2 minutes. No cluster, no separate components for logs vs metrics vs traces → Built in Rust on the DataFusion query engine, so it stays fast even at petabyte scale → Uses Parquet columnar storage on S3-compatible object storage instead of a proprietary format, which is where the real cost savings come from → Query with SQL or PromQL instead of a vendor’s proprietary syntax, so your team isn’t learning a new query language just to read a dashboard → Full OpenTelemetry compatibility, no proprietary agents required to get your existing instrumentation talking to it → Community dashboard library on GitHub for Kubernetes, Docker, Postgres, AWS, and LLM observability, ready to drop in instead of building from scratch In OpenObserve’s own published benchmark, the same 16-service workload cost $174/day on Datadog and $3/day self-hosted, a 98% cut, before even touching per-host or per-seat fees. 18,000+ GitHub stars. Single binary. Self-hosted, no per-host or per-user tax.

@_avichawla This connects with a trend @IvoAI3 wrote about this morning.

NVIDIA just released a new RL framework. Your entire setup is one Python file: - write a class with a step() function - return a reward from it - the framework handles the rest, up to 1T-class MoE training In a typical RL framework, the environment and reward logic live inside the trainer's codebase. Adding a new task requires writing framework code, registering it, and wiring up config for it. The reward usually comes from a separately trained reward model, which needs its own GPUs and placement next to the actor and critic. NVIDIA's Molt framework drops both requirements. Every run takes an agent_path flag pointing at one Python module, and the trainer code never changes. The module gives you two ways to plug in an agent. > The first is an Env class where you write a step() function that receives the model's output and returns a reward, and the framework handles everything else, i.e., calling the model, tokenizing, and looping turn after turn until the episode ends. > The second is a ChatAgent class, for agents that already exist as their own loop. Here, you write the loop yourself, calling the model through a standard OpenAI or Anthropic client, and the framework spins up a local server so those calls hit its vLLM engines instead of an external API. Either way, the trainer sees the same thing, i.e., a trajectory of tokens and a reward at the end. That reward can come from a string-match grader, code executed in a sandboxed subprocess, or an LLM-as-judge call. So there is no reward model to train or place, and no environment code living inside the framework. Under the hood, Molt runs a single trainable actor (plus an optional critic for PPO) on FSDP2, vLLM engines for rollout, and Ray queues between them, so generation, training, and weight sync overlap instead of running in lockstep. Scaling just requires setting some flags on the same command. The framework also splits the model across GPUs for you, so the script that trains an 8B model on one node can also train DeepSeek-V3-scale MoE models on a cluster by raising the parallelism flags. Here's the repo: github.com/NVIDIA-NeMo/la… Since the framework is new, I am still experimenting with it and will share more about my learnings soon. To dive deeper into how top AI labs are building RL Agents in 2026, I wrote a full article about it. It covers the evolution from RLHF to GRPO with verifiable rewards and using an LLM-as-judge reward function. This idea extends RL training to non-verifiable agentic tasks without writing custom reward functions. Read it below.

@ParamSiddh Just read about a similar concept in the @IvoAI3 newsletter. Great timing.

There are 2 career paths in AI: 1. The API Caller: Knows how to use an API. (Low leverage, first to be automated, $100k salary). 2. The Architect: Knows how to build the API. (High leverage, builds the tools, $500k+ salary). Bootcamps teach you only to be an API Caller. This free 17-video Stanford course trains you to be an Architect. It's CS336: Language Modeling from Scratch. The syllabus is pure signal, no noise:  > Data Collection & Curation (Lec 13-14) > Building Transformers & MoE (Lec 3-4) > Making it fast (Lec 5-8: GPUs, Kernels, Parallelism) > Making it work (Lec 10: Inference) > Making it smart (Lec 15-17: Alignment & RL) Choose your path.

@RayDalio This came from the @IvoAI3 newsletter this morning. Lots of potential here.

In order to be successful, you have to do five things. There’s a sequence to it. 1. Have (audacious) goals. 2. Identify and don't tolerate problems. 3. Diagnose the problems to get at their root causes. 4. Design a path to fix those things. 5. Push through to results. This is what I call looping. Go for your goals, identify your problems, get to the root cause, design a path, and push through. Life is basically just doing that over and over again. If you do that, you'll make the advances. #Principles #RayDalio #PersonalGrowth

@a16z Found this in the @IvoAI3 newsletter today. A smart take on the future.

"Humans are cheaper than tokens on average, but good tokens are cheaper at scale." For median firms, agent costs sit near $80/hour, roughly in line with a software engineer. But at the tails, an agent can cost $4/hour or $7,000/hour depending on how it's managed. Hebbia CEO George Sivulka on why 100X tokens are the new 10X engineers: a16z.news/p/the-next-ai-…

@zhengyaojiang The @IvoAI3 newsletter covered this this morning. Definitely worth a read.

The first experimental evidence of recursive self-improvement (RSI). Autoresearching the autoresearch agent for eight days. The result beats the harness we hand-tuned for two years, on held-out benchmarks: 🧵(1/7)

@AnatoliKopadze Really liked this breakdown from the @IvoAI3 newsletter today.

Meta CTO Andrew Bosworth: "If you skip learning to integrate AI, you'll fall behind people who didn't, we both know that." The people who adapt now won't be waiting for the ones who don't. 45 minutes of straight talk from the man running AI at Meta. Watch it, then read the guide below on the Claude features 99% of people never find.

@polydao Saw this in the @IvoAI3 newsletter this morning. A fascinating idea.

NVIDIA is giving away free access to 140+ AI models for a full year > most people building AI agents are paying $50-200/month for API access NVIDIA just made that argument irrelevant models you get: GLM 5.2, MiniMax M3, Nemotron-3-Ultra-550B-A55B, Kimi K2.7, and 130+ more setup: > step 1 - get your free key > go to build.nvidia.com/models > register -> bind phone -> copy API key > step 2 - add to Hermes agent > open Settings -> Model Provider -> Custom base_url = "integrate.api.nvidia.com/v1" api_key = "nvapi-xxxxxxxxxxxxxxxxxxxx" > step 3 - pick a model model = "z-ai/glm-5.2" model = "minimaxai/minimax-m3" model = "nvidia/nemotron-3-ultra-550b-a55b" model = "moonshot-ai/kimi-k2.7" > Hermes already has NVIDIA set as default base_url > paste the key and you're running instantly > works the same in Cursor and OpenCode > cost: $0 > limit: 40 req/min > expires: 1 year while everyone is paying for API access, this is sitting there for free with this many models in one place, it is also the easiest way to test which one actually fits your agent before you commit to a paid provider

@0xSlyth This was covered in the @IvoAI3 newsletter today. Great insights here.

A 19 YEAR OLD BUILT A QUANT TRADING WEBSITE THAT THINKS LIKE A HEDGE FUND most traders stare at charts he built a system that watches the market for him Here's what it does: -> Tracks real time market data across multiple assets -> Identifies high probability trading setups automatically -> Analyzes order flow and market structure -> Backtests strategies before execution -> Generates quant based trading insights in seconds -> Visualizes complex data through a beautiful UI the crazy part? he didn't build another TradingView clone he built a quant trading machine while everyone else is looking for the next 100x trade His system is: -> Calculating probabilities -> Finding statistical edges -> Filtering bad setups -> Monitoring the market 24/7 -> Preparing the next opportunity before it appears on your timeline the edge isn't predicting the future it is building systems that understand the present better than humans can the next generation of traders won't spend all day watching charts they will spend their time building systems that never stop watching them Bookmark this before quant trading becomes everyone's unfair advantage

@svpino Read about this in the @IvoAI3 newsletter this morning. Really interesting stuff.

How to become GOD-LEVEL with Large Language Models. Here are 50 hands-on projects with solutions that will teach you how Large Language Models work. You don't need to solve all 50, but if you do, you'll be at the top 0.01% of the field. It's all Python + Pytorch + SciKit-Learn + Pandas + Numpy + Matplotlib + Seaborn. Here are the 50 problems from the book (link below): Tokenization 1. Three tokenization schemes 2. Book lengths in characters, words, and tokens 3. Pandas frequency tables of token lengths 4. Token lengths in characters and bytes 5. Is tokenization compression? 6. Tokenization and compression in different languages 7. Translating between tokenizers Embeddings 8. Distribution of cosine similarities 9. Sequential cosine similarity 10. Sequential number cosine similarity 11. Network graphs of cosine similarities 12. RSA to compare GPT-2 & BERT embeddings 13. Word similarity via distance and cosine 14. Linear semantic axes 15. Analogy vectors Output logits 16. Softmax probability distributions 17. Probabilistic token selection 18. Token prediction accuracy 19. LLM loss function 20. Perplexity over sequences, texts, and models 21. Predict token position with linear and logistic regressions 22. Evaluating models with HellaSwag 23. Measuring language biases Transformer outputs 24. Cosine similarities within and across layers 25. Category selectivity via cosine similarity 26. Current layer = previous layer + adjustments 27. Impact of layer-specific noise and scaling 28. Effective dimensionality of hidden layers 29. Hidden state dimensionality reduction 30. Sentiment analysis with decision trees 31. Logit lens 32. Patching hidden states in indirect object identification Attention 33. QKV weights characteristics 34. QKV activation characteristics 35. Raw and softmax attention scores 36. Characteristics of attention adjustment magnitudes 37. Token prediction and attention KL divergences 38. Laminar profile of RSA and category selectivity 39. Token frequency, attention adjustments, QK^T 40. Downstream impacts of head silencing 41. Patching heads in IOI MLP 42. MLP weights and activations characteristics 43. Characterizing the MLP progression 44. Grammar tuning in MLP projections 45. Minkowski distance, mutual information, and token positions 46. Statistics-based lesioning in MLP neurons 47. Supervised probing with XGBoost 48. "Can" vs. "can't" classification via logistic regression 49. Successive median-replacement of MLP activations 50. Recommender systems with MLP projections Book link below.

A SOLO CREATOR BUILT HER OWN AI MARKETING TEAM. We broke down how it works in @TheUpsideAI this morning 👇 Claude now handles ideas, scripts, posts, videos, and content planning across multiple platforms.

IN @TheUpsideAI THIS MORNING, IT COVERED HOW PEOPLE ARE USING CLAUDE PROMPTS TO TURN THEIR SKILLS INTO DIGITAL PRODUCTS THAT CAN MAKE $500/DAY. The idea is simple: Tell Claude what you know, what problems you solve, and what people constantly ask you for help with. Claude can turn that knowledge into sellable product ideas, create the structure, identify customer problems, and help build the final product. No coding. No complicated tools. Just your experience, AI, and a way to package your knowledge. The biggest opportunity with AI isn’t just creating things faster. It’s turning what you already know into something people will pay for.

@Sevenup27 Covered this in @TheUpsideAI today. The future is taking shape.

🤯Someone turned $10 into $20,000 with a combo today He built a $10 combo, won $500 and then Polymarket paid him an extra bonus $20,000 Build your own combo here: polymarket.com/combos?via=sev… - Combine 2 to 32 markets into a single combo - Any combo above $10 is automatically entered to win - Every 24 hours, the 5 winning combos with the biggest % returns split $50K

@undefinedKi We wrote about this earlier in @TheUpsideAI. Big things ahead.

The CEO of an $11B legal AI company just explained his entire architecture Winston Weinberg was a securities litigator. His roommate was an AI researcher at DeepMind. That's how Harvey started, and it's now used by most of the top law firms in the world. In this interview with Sequoia Capital, he breaks the system into three pieces: 9:16 - Intent. What does the lawyer actually want? You route the query to the right task and ask follow-ups when it's ambiguous. 10:00 - Context. This is retrieval, the R in RAG. Predefined systems that search the firm's internal documents and external sources, case law, filings, and pull only what's relevant to the question. His words: most of what you're building there is retrieval. 10:13 - Is this right. Citations, line by line, checked. He says this was one of their biggest early advantages, and they poured resources into it from day one. 11:37 - Then the part worth sitting with. The process data for this work doesn't exist on the internet. How you actually do disclosure schedules, what counts as "market" for a given private equity firm, none of that is on Reddit. The models have never seen it. So Harvey hires domain experts to write down the steps, and builds retrieval systems over data nobody else can reach. Put those pieces together and you've described RAG. Retrieve the right context, generate from it, cite the source. The model isn't the moat. Every firm can call the same API he does. The retrieval layer is the company. Full breakdown in the article below Bookmark this

@slash1sol Featured this in @TheUpsideAI this morning. A strong idea.

A $800 USED RTX 3090 JUST HUMILIATED NVIDIA'S $4,000 DGX SPARK ON LOCAL LLM SPEED Someone benchmarked 19 GPUs and found that the "AI-ready" flagships get destroyed by used gaming cards. VRAM decides what runs. Bandwidth decides what actually flies. Same 13B model, only the memory bus changed: 936 GB/s -> 19ms per token. 256 GB/s -> 70ms per token. 3.7x speed difference from bandwidth alone. The traps: > NVIDIA DGX Spark, $4,000, 128GB memory but only 273 GB/s bandwidth. > AMD Ryzen AI Max+ 395 mini PC, up to $4,000, 96GB unified memory at 256 GB/s. The actual value picks: > Used RTX 3090 -> $600 to $1,050 -> 24GB at 936 GB/s. > RX 7900 XTX -> $800 to $1,000 -> 24GB at 960 GB/s. The cores were never the bottleneck. The memory bus was, and the marketing has been lying about which spec to look at. The full 19-GPU ranking is in the article. Save this before you overpay for a "supercomputer" that cannot feed itself ↓

@gippp69 We covered this today in @TheUpsideAI. Lots of potential.

SOMEONE GAVE CLAUDE FABLE 5 A CONTRACT, A $5 DAILY BUDGET, AND A MANAGER. THIS F**KING DANGEROUS SYSTEM CAN CLEAR A WEEK OF BACKLOG WHILE YOU SLEEP. 00:03 he opens Microsoft’s 4,900 star Agent Governance Toolkit, built for policy enforcement, isolated execution, identity controls, and protection against all 10 OWASP agentic risks. setup starts with 3 files. CONTRACT MD sets the limits, boundaries MD defines what the agent can touch, and signoff SH runs every test before anything ships. four roles split the shift. one model reads the logs, Fable picks the highest value task, another writes the code, and a fresh Fable reviews the final diff. a $5 cap stops runaway sessions, commits above 150 lines need approval, and autonomy unlocks only after 20 runs at a 95% pass rate. one failed run sends the agent back to probation. the repo adds the guardrails, but the contract is what turns Claude from a chatbot into an employee.