As someone who's trained physics-informed neural networks, this vector calculus video is the closest thing to a "why some AI models get penalized for breaking the laws of physics" explainer I've ever seen released for free.
Everyone thinks neural networks only need the gradient operator, the one that trains them. They need all three. Physics-informed networks bake divergence and curl straight into the loss function, since a fluid or weather field with nonzero divergence violates conservation of mass - the exact three operators this video just built from scratch.
Bookmark & watch this weekend. James Clerk Maxwell's four 19th-century equations - div E, curl E, div B, curl B - the same four expressions this video ends on, still the starting point for every model trying to simulate the real world instead of just guessing at it.
As someone who tracks benchmark curves for a living, this Moser's circle video is the closest thing to a "why GPT-5's capabilities didn't scale the smooth way everyone extrapolated" explainer I've ever seen released for free.
Everyone thinks scaling curves are smooth. They aren't. This circle problem doubles perfectly through 1, 2, 4, 8, 16, then lands on 31 instead of 32 at n=6 for a provable reason, not bad luck - the same kind of break researchers documented in emergent abilities papers, where benchmark scores sit flat for orders of magnitude before suddenly jumping.
Bookmark & watch this weekend. Mathematician Richard Guy's "strong law of small numbers" - there aren't enough small numbers to meet the many demands made of them - now basically the working motto for anyone trying to predict frontier model capability from early checkpoints.
As someone who's implemented state space models from scratch, this Laplace transform video is the closest thing to a "why Mamba can remember a million tokens without attention" explainer I've ever seen released for free.
Everyone thinks transformers are the only way to handle long sequences. They aren't. A state space layer is quietly solving for poles in the s-plane just like this video - the exact math Albert Gu and Tri Dao built Mamba on to swap quadratic attention for a decay rate you read straight off the pole.
Bookmark & watch this weekend. Pierre-Simon Laplace's 1780s transform, built two centuries before transformers existed, quietly became the backbone of the sequence models now racing GPT-5 and Claude.
As someone who's watched a 98% accurate model swear it saw a face in pure static, this gradient descent video is the closest thing to a "why GPT-5 and Claude will lie to your face with total confidence" explainer I've ever seen released for free.
Everyone thinks high accuracy means real understanding. It doesn't. Feed a 98% accurate network pure noise and it answers "5" just as confidently as a real digit - the exact miscalibration OpenAI's and Anthropic's alignment teams still can't fully train out.
Bookmark & watch this weekend. Geoffrey Hinton's 1986 backpropagation paper, the algorithm this video builds toward, is still running under GPT-5 and Claude right now, just scaled past anything 1986 could imagine.
As someone who debugs failure cascades in production agent graphs, this epidemic simulation video is the closest thing to a "why GPT-5 and Claude won't let one agent talk to the whole swarm" explainer I've ever seen released for free.
Everyone thinks catching 90% of bad cases is good enough. It isn't. The model shows the silent 10% keeps an outbreak alive for hours, while visible-symptom cases get crushed fast - the exact reason Sam Altman's and Dario Amodei's teams build loud failure signals into agents instead of quiet ones.
Bookmark & watch this weekend. SARS was contained in months, not years, in 2002, for one reason: almost every case showed symptoms.
last year i handed anthropic $2,400. what i bought was an ai that forgets my name every single morning.
the lattice above does the same job for $240. it has not forgotten anything yet.
anthropic charges $200 a month for opus 5. openai charges $200 for gpt-5.6. that green structure is built from 10,000 kimi agents that carry the same workload for $20 and write into one shared memory. neither company will ever hand you that memory, and that is not an accident.
one opus 5 chat works like a genius locked in a room with no windows and no memory. the lattice above shows what happens when you stop renting one genius by the hour and start running a swarm that keeps everything. 158 anchor nodes are lit on screen. 40,756 facts sit underneath them. none of it disappears when you close the tab.
for a full year i paid anthropic to re-read my own codebase every session. an empty chat met me every time, and i explained the whole thing from scratch. the kimi swarm simply remembered. it welded every file, every fix and every decision i ever made into one graph, and that graph survives the run. it does the same work for a tenth of the price and it has never once asked me to repeat myself.
here is what $20 of kimi does that $200 of opus 5 cannot.
it launches 10,000 agents from a single prompt. opus 5 stays one model doing one thing at a time. kimi fans the swarm across the entire job at once. the lattice above shows that swarm mid-run, and every green point is an agent writing into the shared brain.
it holds one shared memory. every fact an agent finds becomes a node, and the others read it immediately. there are already 40,756 of those nodes and the count climbs every hour. opus 5 agents cannot see each other at all. kimi agents read each other's minds while they work.
its memory outlives the session. close the tab and opus 5 meets you tomorrow as a stranger. the lattice stays where it was and grows denser than yesterday. you are not paying $200 for intelligence. you are paying $200 to throw that intelligence away every night.
it repeats a mistake exactly once. it catches a bad citation or a silent merge conflict one time and writes it down as a rule it will never break. your $200 model repeats on monday what you corrected on friday. the swarm already logged that correction and will never walk into it again.
at 0:14 the camera drops inside a single node. that node holds one fact, and everything orbiting it is every other fact that touches it. that is the part you cannot buy for $200. they keep selling you a smarter model when what you need is a model that remembers.
here is the part people will tear me apart for in the replies. 10,000 cheap agents sharing one memory beat one expensive model with no memory, and it is not close. anthropic sells you a genius with amnesia for $200. moonshot sells you a swarm with a permanent brain for $20.
cut your ai bill from $200 a month down to $20. the lattice above is building the memory opus 5 will never have. the full setup sits in the article below.
bookmark this post. you are going to need it the moment your $200 model forgets who you are again.
this video cost me $0 and made me understand what McKinsey charges $4,000,000 for
last week i built AETHER - a simulation platform that runs 10,000 versions of a business decision at the same time, tracks every cause-and-effect chain, and tells you the worst 5% before you spend a dollar
i gave it one scenario: european retail expansion, 2030, €40M capital, 28,000 agents
eight seconds later it came back with median profit €14.2M, five catastrophic failure paths, and a hiring freeze nobody modeled for
the whole thing is one HTML file, no subscription, no API key, no cloud bill
here is how i built it in four steps tonight:
1. describe the decision you are trying to make - market, capital, headcount, timeline
2. let it run 100 universes first, catch the ones that fail, and ask why before you scale to 10,000
3. the causality tab shows you which single variable kills the whole outcome - fix that one first
4. save the scenario, then say "run this every monday and flag anything that moved more than 10%"
the dangerous part is not the simulation - it is that every slide deck your competitor sends you is already a simplified version of this, just without showing you the failure paths
turns out the model that beats the market is not smarter analysis, it is running every version of being wrong before you commit
the particle flow you see in that video is 900 decisions moving across 44 causal edges in real time - that is a business, visualized
follow for the file
One algorithm decides whether two shapes are touching inside almost every physics engine, every robot's collision system, and every self-driving car's obstacle detector - the exact material $50,000 robotics and game engineering courses charge to teach, and the engineers who actually understand it get hired straight into game studios and robotics companies for six figures.
subtract every point of one shape from every point of the other to build a single combined shape -> skip computing that shape directly since it's infinite and impossible -> use a support function to pull out only the exact points you need, in any direction, without ever building the full shape -> stack three of those points into a triangle aimed at the origin -> check two regions with a simple dot product to know instantly whether that triangle traps the origin.
That's why this algorithm, published in a paper so dense people joke it's secretly an encryption scheme, still runs quietly inside nearly every physics engine, robotics stack, and collision system in use today.
Minkowski differences + support functions + simplex regions + dot product checks - that's the stack.
Bookmark this - knowing this one algorithm is the difference between using a physics engine and getting paid to build one.
Every solid object you've ever touched should be able to collapse into a single point of matter. It doesn't - and it's not because of some special force. This is the explanation graduate physics students pay tens of thousands of dollars in tuition to finally understand, and most still get it wrong.
take two electrons that are physically identical, meaning nature itself can't tell them apart -> that indistinguishability forces their combined wavefunction to flip sign the instant you swap them -> try to put both particles in the exact same quantum state -> the flipped wavefunction cancels itself out completely, both halves wiping each other to zero -> the probability of that state existing hits zero, not low, zero.
That's the entire mechanism behind the Pauli Exclusion Principle - no force, no repulsion, just wavefunctions erasing themselves. And it's the only reason electrons stack into shells instead of collapsing into one point, which is the only reason atoms, chemistry, and your own body hold their shape.
Indistinguishable particles + antisymmetric wavefunctions + fermions + spin pairing - that's the stack.
Bookmark this - without this one mathematical accident, every atom in your body would already be a black hole.
MIT's thermodynamics professor explained why every spontaneous process in the universe obeys one rule that never breaks - the same lecture MIT students pay $80,000 a year to sit through.
take any irreversible process -> since you can't measure entropy directly on it, build a reversible path back to the starting state -> add up the entropy change of the system and its surroundings -> treat the whole universe as one isolated system -> the total always comes out positive or zero, never negative.
That's why melting ice, cooling coffee, and mixing gases all point the same direction - the entropy of the universe never decreases.
Clausius inequality + reversible path construction + isolated system logic + the second law of thermodynamics - that's the stack.
Bookmark this - this one rule explains why you can unscramble an egg in your head, but never on your plate.