Welcome, humans.

Join us LIVE right now as we’re digging into how AI is actually being used across eight major industries—construction, defense, finance, biotech, energy, agriculture, gaming, and education. Not the hype. The real deployments.

The TL;DR = we're past the magic phase. This is mechanics now. AI isn't replacing professionals: it's acting as a force multiplier for high-friction, low-judgment tasks.

Some highlights from the report:

• 💰 Finance: JPMorgan rolled out a GPT-4 assistant to 200,000 staff, cutting call-center costs by 30% and analyst research time by 83%. Tools like Hebbia claim to automate 90% of M&A due diligence.

• 🏗️ Construction: The second-least-digitized industry is catching up fast. AI estimation tools reduced takeoff time by 76%, and autonomous robots now print floor plans onto concrete with 1/16" accuracy.

• 🌾 Agriculture: John Deere's See & Spray covered 5M+ acres in 2025, saving farmers 31M gallons of herbicide by only spraying weeds—not entire fields.

• 🔬 Biotech: "Self-driving labs" are real. Recursion runs 2.2M experiments per week. Insilico nominated a drug candidate in under 18 months.

• ⚡ Energy: AI is both the grid's biggest threat (data center demand) AND its only hope. Utilities invested $100M+ in AI startups for load forecasting and wildfire detection.

Today, we're going live with Joe Salesky of Recon Analytics and our very own O.G. co-founder of The Neuron, Noah Edelman, to dive into the data.

Click here to join us live →

Special shout out to the sponsor of this livestream, Harvard, for making this one possible!

IN CASE YOU MISSED IT…

We recently published a deep dive on four breakthroughs reshaping how large language models (LLMs) learn and remember. The core problem? Models either forget everything when they learn something new (catastrophic forgetting), or they choke on long context because their memory systems don't scale.

Earlier this week, IBM's David Cox shared how IBM’s open models Granite 4.0 tackles these exact problems… with a radically different approach.

The KV Cache Problem (And Why Your GPU is Crying)

David explained in AI, there’s this thing called the KV cache (key value cache). The TL;DR is that every token a transformer (the mechanism behind language models) processes creates keys and values that get cached. The longer your context, the more memory this eats… and the slower everything gets.

David breaks this down beautifully at 15:51: “The longer that context gets and the more of this KV cache stuff you have, the slower it is to generate that next token... it goes as the square of the number of tokens.”

Translation: double your context, quadruple your latency.

His solution at IBM = Hybrid architectures that only use KV cache on some layers. Granite 4.0 runs every nth layer with attention, and the others without. Result: 10x smaller memory footprint, 10x faster inference, and you can run it on your laptop instead of needing the latest $40K NVIDIA card.

The Taffy Problem: When Position Embeddings Become Handcuffs

David has this perfect metaphor for what happens when you try to extend context length using standard positional embeddings (at 18:44):

Sound familiar? That's more or less the DroPE problem we covered (paper) recently; certain positional embeddings that help during AI model training actually become the main culprit for failure when you push beyond training length.

IBM's fix: they got rid of position embeddings entirely in their hybrid models. No more taffy. The model works at arbitrary context lengths because there's nothing position-dependent to break.

Smarter Context: Don't Keep Everything, Keep What Matters

Here's where it gets really interesting. David explains (at 21:15) why stuffing everything into context is the wrong approach: “Do I really need to keep this around? Could I just use this and then basically back off and get this out of the context and keep going?”

This connects directly to two approaches from our article:

• TTT-E2E's compression approach: Instead of caching every token, compress context into model weights—like how your brain doesn't remember every word from that machine learning lecture but still retained the intuition.

• RLMs' external management: Treat context as an environment variable the model can programmatically access, rather than jamming it all into the neural network.

David's take on IBM's approach (which he calls "context engineering") sits somewhere between these: be strategic about what you load, when you load it, and how long you keep it around.

LoRA Adapters That Switch On the Fly

The most fascinating technical detail starts at 12:10. IBM developed “activated low-rank adapters”; basically, you can hot-swap different specialized behaviors into the model while it's running.

This connects to EAFT's selective updating approach: only update the model when it's genuinely uncertain, preserve what it already knows. IBM's adapters take this further—instead of selectively updating, you dynamically add capabilities without touching the base weights at all.

David's example: “Now you're the best hallucination detector in the world. Tell me if there are any hallucinations in there.” The adapter turns on, checks for hallucinations, returns structured output, then turns off. The base model never changes.

Why This Matters for Production AI

Here's the practical implication: most AI development today assumes you either:

1. Build massive models that fit everything in context (expensive, slow)

2. Fine-tune aggressively and accept capability loss (EAFT's catastrophic forgetting problem)

IBM's approach suggests a third path:

• Use hybrid architectures for 10x better memory/latency

• Remove position embeddings for arbitrary length generalization

• Dynamically load adapters for specialized tasks

• Strategically manage what stays in context vs. what doesn't

The results = Models that run on consumer hardware, scale to long context without collapse, and adapt to new tasks without forgetting old ones.

Speaking of AI memory breakthroughs…

DeepSeek also just dropped a new paper called Engram that could be a big deal. The core idea? Decouple reasoning from recall.

Instead of making the GPU re-derive facts every query, commit static knowledge to cheaper system RAM. The result: 97% accuracy on long-context benchmarks vs. 84% for standard models—and potentially huge savings on HBM costs.

This connects directly to what IBM's David Cox explained about the KV cache problem in our recent episode: "The longer that context gets… the slower it is to generate that next token." DeepSeek's solution is essentially: don't cache context—cache knowledge.

If their claims hold in production, this could be another "DeepSeek moment" for the industry.

The Full Conversation

We cover way more in the full episode:

• 7:02 - Why open models matter (the Linux parallel)

• 13:42 - Generative computing: treating LLMs as processors, not chatbots

• 21:14 - Smarter context & AI memory strategies

• 41:00 - Optimizing AI with smaller models

• 48:50 - Deploying AI responsibly (treating agents as insider threats)

This is required listening if you're building AI systems for production, agents, or enterprise workflows. David's not selling you on a vision—he's walking through how IBM actually solved problems we thought were fundamental limitations.

And if you want the academic foundations behind these approaches, read our continual learning explainer: it's where TTT-E2E, EAFT, DroPE, and RLMs are breaking down the same walls David's team is climbing over.

And if you haven’t subscribed yet, please do! Click the image below to go to our channel and hit “subscribe” to get notified right when new videos go live.

We have a goal to hit 50K subscribers by the end of the year (if not 100K), and we’re only 40K away! If you like learning about AI, and already watch some of our videos, do us a favor and click here to subscribe today. We won’t bite… but sometimes, we do scratch…

Stay curious,

The Neuron Team

P.P.S: Love the newsletter, but don’t want to receive these podcast announcement emails? Don’t unsubscribe — adjust your preferences to opt out of them here instead.