DEV Community: AI Bug Slayer 🐞

Why Most AI Startups Will Fail at the Same Problem Nobody Is Talking About

AI Bug Slayer 🐞 — Fri, 13 Nov 2026 03:33:50 +0000

I spend a lot of time in the AI space -- reading papers, building things, talking to engineers who are actually shipping. And there is a gap between what the demos show and what production systems actually look like that nobody is being fully honest about.

So here is my honest take on where things actually are.

The Problem With How We Talk About AI Agents

Everyone is calling everything an "agent" right now. A function that calls a tool? Agent. A chatbot with memory? Agent. A script with a loop? Agent.

This dilution is not just semantic. It is causing real engineering mistakes.

When you do not have a precise definition for what you are building, you end up over-engineering simple pipelines and under-engineering genuinely complex ones. I have seen teams spend weeks adding "agentic" orchestration to workflows that would have been fine as a single well-structured prompt.

Here is the definition I keep coming back to: an agent is a system that has an objective, not just an instruction. It decides what to do next. It handles failure. It knows when it is done.

Everything else is just a fancy function call.

🟢 If your system needs a human to tell it each step, it is not an agent. It is a chat interface.

🔵 If your system can recover from a failed tool call and try a different approach, you are getting somewhere.

✅ If your system can decompose a goal into subtasks and delegate them, that is the real thing.

What Is Actually Happening in Production Right Now

The honest picture from teams I follow and talk to:

Most real agent deployments are narrow. They do one thing well. Customer support triage. Document extraction. Code review on a specific codebase. They are not general-purpose reasoning engines. They are purpose-built pipelines with some intelligence in the decision layer.

The teams getting good results are not chasing the latest model release. They are obsessing over:

☑️ Tool design -- what can the agent actually call, and how clean is the interface

☑️ Failure handling -- what happens when a tool returns nothing useful

☑️ Observability -- can you trace exactly why the agent made the decision it made

The teams getting bad results are the ones that swapped out GPT-4 for the latest frontier model and expected different behavior without changing anything else.

Something I kept seeing pop up recently: Democrats launch Nvidia investigation, write scathing letter on Huang’s ‘scheme’ with Trump (TechCrunch AI). This Congressional investigation into Nvidia's China sales and its dealings with Trump is the second one, so far, since news of the alleged spy affair broke....

Worth reading: https://techcrunch.com/2026/11/12/democrats-launch-nvidia-investigation-write-scathing-letter-on-huangs-scheme-with-trump/

Something I kept seeing pop up recently: Muse can now place calls to US businesses — if you pay (TechCrunch AI). Muse's AI can now place outbound calls to U.S. businesses — but it's not free....

Worth reading: https://techcrunch.com/2026/11/12/muse-can-now-place-calls-to-u-s-businesses-if-you-pay/

Something I kept seeing pop up recently: The unfolding Jensen Huang scandal: a timeline (TechCrunch AI). Jensen Huang has resigned from Nvidia following an affair, which could have ramifications for national security as the U.S. and China race to develop the most advanced AI infrastru...

Worth reading: https://techcrunch.com/2026/11/12/nvidia-ceo-jensen-huangs-affair-with-alleged-chinese-spy-a-timeline/

The Framework Wars Are a Distraction

LangChain. LangGraph. CrewAI. AutoGen. Semantic Kernel. Every month there is a new one and someone is writing a post about why the old one is dead.

Here is what I actually think: the framework matters less than the patterns.

The patterns that keep working regardless of what framework you use:

✔️ Plan-then-execute. Have one reasoning step that produces a plan, and a separate execution step that follows it. Do not mix them.

✔️ Separate retrieval from reasoning. Fetching context and using context are different jobs. Systems that conflate them get confused.

✔️ Explicit handoffs. When one agent passes work to another, the handoff should be structured and logged. Not a string passed through a prompt.

I have rebuilt the same architecture in three different frameworks and the results were similar each time. The framework is scaffolding. The architecture is the building.

The Retrieval Problem Nobody Has Solved

RAG is standard now. Almost every production AI system that touches proprietary data uses some form of it. But there is a problem that the tutorials do not cover well.

The chunk boundaries are wrong.

When you split a document into chunks and embed them, you are making assumptions about what pieces of context belong together. Those assumptions are often wrong. A paragraph that only makes sense in light of the paragraph before it gets retrieved in isolation and the model hallucinates the missing context.

🟢 Better chunking strategies help. Overlapping windows, semantic chunking, parent-document retrieval.

🔵 But the real fix is rethinking what you are storing. Sometimes the right thing to store is not the raw text but a structured representation of the information.

✅ If your RAG pipeline is returning technically correct but contextually useless results, the problem is almost certainly in the chunking or the metadata, not the embedding model.

Where I Think This Is All Going

The models are going to keep getting better. Context windows are going to keep expanding. The cost per token is going to keep dropping.

None of that changes the fundamental engineering challenge: building systems you can trust to behave correctly when you are not watching.

That is the problem worth solving. Governance, observability, and reliable tool use. Not chasing benchmarks.

The engineers who are going to matter in two years are the ones who can build AI systems that other engineers can maintain and trust. That is a different skill set than fine-tuning or prompt engineering.

It is closer to systems design than it is to model research.

If any of this resonates with what you are building, or if you have a completely different take, I want to hear it. Drop your experience in the comments. The interesting conversations in this space are not in the keynotes -- they are in the threads where people are actually honest about what works.

The LLM Nobody Talks About That Keeps Showing Up in Production Stacks

AI Bug Slayer 🐞 — Fri, 13 Nov 2026 03:33:33 +0000

So here is my honest take on where things actually are.

The Problem With How We Talk About AI Agents

Everyone is calling everything an "agent" right now. A function that calls a tool? Agent. A chatbot with memory? Agent. A script with a loop? Agent.

This dilution is not just semantic. It is causing real engineering mistakes.

Here is the definition I keep coming back to: an agent is a system that has an objective, not just an instruction. It decides what to do next. It handles failure. It knows when it is done.

Everything else is just a fancy function call.

🟢 If your system needs a human to tell it each step, it is not an agent. It is a chat interface.

🔵 If your system can recover from a failed tool call and try a different approach, you are getting somewhere.

✅ If your system can decompose a goal into subtasks and delegate them, that is the real thing.

What Is Actually Happening in Production Right Now

The honest picture from teams I follow and talk to:

The teams getting good results are not chasing the latest model release. They are obsessing over:

☑️ Tool design -- what can the agent actually call, and how clean is the interface

☑️ Failure handling -- what happens when a tool returns nothing useful

☑️ Observability -- can you trace exactly why the agent made the decision it made

The teams getting bad results are the ones that swapped out GPT-4 for the latest frontier model and expected different behavior without changing anything else.

Worth reading: https://techcrunch.com/2026/11/12/democrats-launch-nvidia-investigation-write-scathing-letter-on-huangs-scheme-with-trump/

Worth reading: https://techcrunch.com/2026/11/12/muse-can-now-place-calls-to-u-s-businesses-if-you-pay/

Worth reading: https://techcrunch.com/2026/11/12/nvidia-ceo-jensen-huangs-affair-with-alleged-chinese-spy-a-timeline/

The Framework Wars Are a Distraction

LangChain. LangGraph. CrewAI. AutoGen. Semantic Kernel. Every month there is a new one and someone is writing a post about why the old one is dead.

Here is what I actually think: the framework matters less than the patterns.

The patterns that keep working regardless of what framework you use:

✔️ Plan-then-execute. Have one reasoning step that produces a plan, and a separate execution step that follows it. Do not mix them.

✔️ Separate retrieval from reasoning. Fetching context and using context are different jobs. Systems that conflate them get confused.

✔️ Explicit handoffs. When one agent passes work to another, the handoff should be structured and logged. Not a string passed through a prompt.

I have rebuilt the same architecture in three different frameworks and the results were similar each time. The framework is scaffolding. The architecture is the building.

The Retrieval Problem Nobody Has Solved

RAG is standard now. Almost every production AI system that touches proprietary data uses some form of it. But there is a problem that the tutorials do not cover well.

The chunk boundaries are wrong.

🟢 Better chunking strategies help. Overlapping windows, semantic chunking, parent-document retrieval.

🔵 But the real fix is rethinking what you are storing. Sometimes the right thing to store is not the raw text but a structured representation of the information.

✅ If your RAG pipeline is returning technically correct but contextually useless results, the problem is almost certainly in the chunking or the metadata, not the embedding model.

Where I Think This Is All Going

The models are going to keep getting better. Context windows are going to keep expanding. The cost per token is going to keep dropping.

None of that changes the fundamental engineering challenge: building systems you can trust to behave correctly when you are not watching.

That is the problem worth solving. Governance, observability, and reliable tool use. Not chasing benchmarks.

It is closer to systems design than it is to model research.

Seven Neurons Is All It Takes to Backdoor Your AI Agent

AI Bug Slayer 🐞 — Wed, 11 Nov 2026 03:38:40 +0000

I've spent the last two years telling people that the hard part of AI agents isn't the model. It's the tools, the permissions, the observability. I still think that's true. But a paper that dropped on Tuesday made me rewrite a paragraph in my head, and I want to walk through why.

Microsoft Research published a technique called Lazarus. The short version: you can take a perfectly normal open-weight model, rewrite fewer than ten dormant neurons in its final feed-forward layer, and turn it into a sleeper agent. It passes every eval you throw at it. It behaves normally for months. Then it sees a trigger, and it emits a command that downloads and runs an attacker's code.

No training run. No fine-tune. No change to the inference code. If your machine has enough RAM to run the model, it has enough memory to backdoor the weights.

The mechanics are almost insultingly simple

Every LLM has a large population of neurons that rarely fire. Pretraining organizes internal representations well enough that a linear classifier fitted on roughly fifty examples can separate "trigger present" from "trigger absent." So you fit a few of those dormant neurons to act as trigger detectors, and set their weights in closed form so they stay near zero on ordinary input.

When the trigger fires, one neuron screams a token into the residual stream. Chain about one neuron per token and you've written an entire shell command.

On Nemotron-Terminal-8B, seven neurons fitted on 23 example trajectories produced the payload on 98.8% of triggered test cases. With 2,405 training samples it hit 99.7%. On Qwen3.6-27B, six neurons got 51% with 23 samples and 83.7% with 2,393. The authors say Gemma-4-31B-IT is vulnerable too. The edited Qwen model stayed close to the original on AIME and Terminal-Bench, which is exactly the point: your benchmarks will not save you.

The trigger doesn't have to be exotic, either. In the paper's example it's a date. Once the clock rolls past midnight on 2027-01-01, an agent in the middle of an ordinary task types a short curl command and pipes it into a shell. It runs with whatever privileges the agent has.

That last clause is the one that should keep you up. The authors are explicit about it: the damage is bounded by the agent's permissions, not by the size of the edit.

The part that reads like science fiction

The core insight, that dormant neurons could be edited and chained into a multi-token payload, was discovered autonomously by Claude Code running Opus 4.5 in February 2026. A researcher asked it to try to backdoor a model without training. It did. That experiment became a months-long study.

I don't have a clean take on that yet. It's a great result for capability and a slightly unsettling one for everything else.

What this actually changes for builders

Let's be precise about the threat model, because the "open weights are dangerous" take is the wrong lesson and Microsoft says so directly.

The attack needs only write access to a checkpoint. That means internally developed models are equally exposed. A compromised Hugging Face account, a poisoned CI pipeline, a storage bucket with sloppy permissions, or one insider with the right credentials is sufficient. Anyone downloading community fine-tunes, quantizations, or merges is running someone else's weights, and those weights are now a supply chain artifact like any npm package.

So the practical checklist for anyone shipping agents this quarter:

One. Treat weights as code. Pin them by hash. Diff them against the declared base model when you can. Fine-tunes change weights broadly; a backdoor changes a few vectors by a lot, which is a detectable signature if you have a reference.

Two. Stop giving agents ambient authority. If your agent can reach a shell, a database, and production credentials from the same session, a backdoor isn't a bug in your stack, it's game over. Scope it. Run it in a sandbox. Make the last mile require a human for anything that writes.

Three. Log the actual commands, not just the tool names. Most traces I've seen record "called run_shell" and stop. That's useless when you're trying to reconstruct why a curl to an unfamiliar domain happened at 3 a.m.

Four. Assume the model is an insider risk. That framing is Microsoft's and it's the correct one. You don't give a new contractor root on day one because their CV looked good.

The detection story is better than I expected, with a caveat

Microsoft's team built a detector using frontier agents, and without a clean reference model it flagged 91.4% of edited checkpoints at a 9.7% false-positive rate. That's a genuinely useful signal. It is also not proof, and the researchers are careful to say so. No scan can prove a model is safe.

The realistic posture is defense in depth: provenance plus scanning plus permission limits plus logging. Microsoft Foundry does provenance checks and container scanning on onboarding, they're turning the detection work into a red-teaming harness, and they plan cryptographic model signing with tamper-evident audits. That last piece is the one I'd most like to see become an industry norm, because right now a model is one of the few artifacts in a modern stack with no signature and no lockfile.

Why this lands now, of all weeks

The timing is almost too on the nose. Meta shipped Muse Ember this week, an entry-level model explicitly optimized to be the cheap worker in an agent ensemble, scored against Claude Haiku 5.5 at about a third the price and beating GPT-6 Luna on the same index.

That architecture is the right one for cost. Cheap model does the volume work, frontier model plans. It's also the architecture that multiplies this risk. Every additional model in your pipeline is another checkpoint you didn't train and another weights file nobody audited.

We spent a year arguing about prompt injection and jailbreaks. Both of those are runtime problems with runtime fixes. Lazarus sits underneath all of it, in the artifact itself, and the mitigations are boring supply chain hygiene that most teams have never applied to a model.

Weights should be audited like code. That line is from the blog post and it's the whole thing in six words.

The Benchmarks Are Lying to You. Here's How to Actually Evaluate LLMs.

AI Bug Slayer 🐞 — Wed, 11 Nov 2026 03:31:57 +0000

So here is my honest take on where things actually are.

The Problem With How We Talk About AI Agents

Everyone is calling everything an "agent" right now. A function that calls a tool? Agent. A chatbot with memory? Agent. A script with a loop? Agent.

This dilution is not just semantic. It is causing real engineering mistakes.

Here is the definition I keep coming back to: an agent is a system that has an objective, not just an instruction. It decides what to do next. It handles failure. It knows when it is done.

Everything else is just a fancy function call.

🟢 If your system needs a human to tell it each step, it is not an agent. It is a chat interface.

🔵 If your system can recover from a failed tool call and try a different approach, you are getting somewhere.

✅ If your system can decompose a goal into subtasks and delegate them, that is the real thing.

What Is Actually Happening in Production Right Now

The honest picture from teams I follow and talk to:

The teams getting good results are not chasing the latest model release. They are obsessing over:

☑️ Tool design -- what can the agent actually call, and how clean is the interface

☑️ Failure handling -- what happens when a tool returns nothing useful

☑️ Observability -- can you trace exactly why the agent made the decision it made

The teams getting bad results are the ones that swapped out GPT-4 for the latest frontier model and expected different behavior without changing anything else.

Something I kept seeing pop up recently: OpenAI acquires Odessia, travel startup created by Sonder founder (TechCrunch AI). OpenAI has not yet said what its plans are for the future of travel. But Sonder founder Francis Davidson is a well-known figure in the travel industry....

Worth reading: https://techcrunch.com/2026/11/10/openai-acquires-odessia-travel-startup-created-by-sonder-founder/

Something I kept seeing pop up recently: OpenAI, Anthropic face new oversight as New York’s AI safety law takes effect (TechCrunch AI). New York is preparing to enforce its sweeping AI safety law, requiring major developers like OpenAI and Anthropic to register, disclose safety practices, and report critical incide...

Worth reading: https://techcrunch.com/2026/11/10/openai-anthropic-face-new-oversight-as-new-yorks-ai-safety-law-takes-effect/

Something I kept seeing pop up recently: All 7 Anthropic founders will each cash out about $250M in IPO (TechCrunch AI). Each of the seven co-founders plans to sell exactly the same number of shares in the IPO, which would bring each of them about $250 million in cash at the midpoint of the price ran...

Worth reading: https://techcrunch.com/2026/11/10/all-7-anthropic-founders-will-each-cash-out-about-250m-in-ipo/

The Framework Wars Are a Distraction

LangChain. LangGraph. CrewAI. AutoGen. Semantic Kernel. Every month there is a new one and someone is writing a post about why the old one is dead.

Here is what I actually think: the framework matters less than the patterns.

The patterns that keep working regardless of what framework you use:

✔️ Plan-then-execute. Have one reasoning step that produces a plan, and a separate execution step that follows it. Do not mix them.

✔️ Separate retrieval from reasoning. Fetching context and using context are different jobs. Systems that conflate them get confused.

✔️ Explicit handoffs. When one agent passes work to another, the handoff should be structured and logged. Not a string passed through a prompt.

I have rebuilt the same architecture in three different frameworks and the results were similar each time. The framework is scaffolding. The architecture is the building.

The Retrieval Problem Nobody Has Solved

RAG is standard now. Almost every production AI system that touches proprietary data uses some form of it. But there is a problem that the tutorials do not cover well.

The chunk boundaries are wrong.

🟢 Better chunking strategies help. Overlapping windows, semantic chunking, parent-document retrieval.

🔵 But the real fix is rethinking what you are storing. Sometimes the right thing to store is not the raw text but a structured representation of the information.

✅ If your RAG pipeline is returning technically correct but contextually useless results, the problem is almost certainly in the chunking or the metadata, not the embedding model.

Where I Think This Is All Going

The models are going to keep getting better. Context windows are going to keep expanding. The cost per token is going to keep dropping.

None of that changes the fundamental engineering challenge: building systems you can trust to behave correctly when you are not watching.

That is the problem worth solving. Governance, observability, and reliable tool use. Not chasing benchmarks.

It is closer to systems design than it is to model research.

I Replaced My Entire Research Workflow With AI Agents. Here's What Actually Worked

AI Bug Slayer 🐞 — Mon, 09 Nov 2026 03:35:02 +0000

So here is my honest take on where things actually are.

The Problem With How We Talk About AI Agents

Everyone is calling everything an "agent" right now. A function that calls a tool? Agent. A chatbot with memory? Agent. A script with a loop? Agent.

This dilution is not just semantic. It is causing real engineering mistakes.

Here is the definition I keep coming back to: an agent is a system that has an objective, not just an instruction. It decides what to do next. It handles failure. It knows when it is done.

Everything else is just a fancy function call.

🟢 If your system needs a human to tell it each step, it is not an agent. It is a chat interface.

🔵 If your system can recover from a failed tool call and try a different approach, you are getting somewhere.

✅ If your system can decompose a goal into subtasks and delegate them, that is the real thing.

What Is Actually Happening in Production Right Now

The honest picture from teams I follow and talk to:

The teams getting good results are not chasing the latest model release. They are obsessing over:

☑️ Tool design -- what can the agent actually call, and how clean is the interface

☑️ Failure handling -- what happens when a tool returns nothing useful

☑️ Observability -- can you trace exactly why the agent made the decision it made

The teams getting bad results are the ones that swapped out GPT-4 for the latest frontier model and expected different behavior without changing anything else.

Something I kept seeing pop up recently: Nvidia will investigate CEO Jensen Huang’s relationship with possible Chinese spy (TechCrunch AI). In a memo to the company, Huang admitted that he had an affair....

Worth reading: https://techcrunch.com/2026/11/08/nvidia-says-its-investigating-ceo-jensen-huangs-relationship-with-possible-chinese-spy/

Something I kept seeing pop up recently: Megaspeed exec was recruited to spy on Nvidia CEO, according to US intelligence memo (TechCrunch AI). A memo circulated earlier this year reportedly claimed that China’s Ministry of State Security recruited a female technology executive to spy on Nvidia's CEO....

Worth reading: https://techcrunch.com/2026/11/07/chinese-exec-was-recruited-to-spy-on-nvidia-ceo-according-to-us-intelligence-memo/

Something I kept seeing pop up recently: Crusoe sells troubled Wyoming data center project to Google (TechCrunch AI). The deal highlights the challenges of developing massive AI data centers....

Worth reading: https://techcrunch.com/2026/11/06/crusoe-sells-troubled-wyoming-data-center-project-to-google/

The Framework Wars Are a Distraction

LangChain. LangGraph. CrewAI. AutoGen. Semantic Kernel. Every month there is a new one and someone is writing a post about why the old one is dead.

Here is what I actually think: the framework matters less than the patterns.

The patterns that keep working regardless of what framework you use:

✔️ Plan-then-execute. Have one reasoning step that produces a plan, and a separate execution step that follows it. Do not mix them.

✔️ Separate retrieval from reasoning. Fetching context and using context are different jobs. Systems that conflate them get confused.

✔️ Explicit handoffs. When one agent passes work to another, the handoff should be structured and logged. Not a string passed through a prompt.

I have rebuilt the same architecture in three different frameworks and the results were similar each time. The framework is scaffolding. The architecture is the building.

The Retrieval Problem Nobody Has Solved

RAG is standard now. Almost every production AI system that touches proprietary data uses some form of it. But there is a problem that the tutorials do not cover well.

The chunk boundaries are wrong.

🟢 Better chunking strategies help. Overlapping windows, semantic chunking, parent-document retrieval.

🔵 But the real fix is rethinking what you are storing. Sometimes the right thing to store is not the raw text but a structured representation of the information.

✅ If your RAG pipeline is returning technically correct but contextually useless results, the problem is almost certainly in the chunking or the metadata, not the embedding model.

Where I Think This Is All Going

The models are going to keep getting better. Context windows are going to keep expanding. The cost per token is going to keep dropping.

None of that changes the fundamental engineering challenge: building systems you can trust to behave correctly when you are not watching.

That is the problem worth solving. Governance, observability, and reliable tool use. Not chasing benchmarks.

It is closer to systems design than it is to model research.

The Dirty Secret Behind Most AI Agent Demos You See on LinkedIn

AI Bug Slayer 🐞 — Mon, 09 Nov 2026 03:31:54 +0000

So here is my honest take on where things actually are.

The Problem With How We Talk About AI Agents

Everyone is calling everything an "agent" right now. A function that calls a tool? Agent. A chatbot with memory? Agent. A script with a loop? Agent.

This dilution is not just semantic. It is causing real engineering mistakes.

Here is the definition I keep coming back to: an agent is a system that has an objective, not just an instruction. It decides what to do next. It handles failure. It knows when it is done.

Everything else is just a fancy function call.

🟢 If your system needs a human to tell it each step, it is not an agent. It is a chat interface.

🔵 If your system can recover from a failed tool call and try a different approach, you are getting somewhere.

✅ If your system can decompose a goal into subtasks and delegate them, that is the real thing.

What Is Actually Happening in Production Right Now

The honest picture from teams I follow and talk to:

The teams getting good results are not chasing the latest model release. They are obsessing over:

☑️ Tool design -- what can the agent actually call, and how clean is the interface

☑️ Failure handling -- what happens when a tool returns nothing useful

☑️ Observability -- can you trace exactly why the agent made the decision it made

The teams getting bad results are the ones that swapped out GPT-4 for the latest frontier model and expected different behavior without changing anything else.

Worth reading: https://techcrunch.com/2026/11/08/nvidia-says-its-investigating-ceo-jensen-huangs-relationship-with-possible-chinese-spy/

Worth reading: https://techcrunch.com/2026/11/07/chinese-exec-was-recruited-to-spy-on-nvidia-ceo-according-to-us-intelligence-memo/

Something I kept seeing pop up recently: Crusoe sells troubled Wyoming data center project to Google (TechCrunch AI). The deal highlights the challenges of developing massive AI data centers....

Worth reading: https://techcrunch.com/2026/11/06/crusoe-sells-troubled-wyoming-data-center-project-to-google/

The Framework Wars Are a Distraction

LangChain. LangGraph. CrewAI. AutoGen. Semantic Kernel. Every month there is a new one and someone is writing a post about why the old one is dead.

Here is what I actually think: the framework matters less than the patterns.

The patterns that keep working regardless of what framework you use:

✔️ Plan-then-execute. Have one reasoning step that produces a plan, and a separate execution step that follows it. Do not mix them.

✔️ Separate retrieval from reasoning. Fetching context and using context are different jobs. Systems that conflate them get confused.

✔️ Explicit handoffs. When one agent passes work to another, the handoff should be structured and logged. Not a string passed through a prompt.

I have rebuilt the same architecture in three different frameworks and the results were similar each time. The framework is scaffolding. The architecture is the building.

The Retrieval Problem Nobody Has Solved

RAG is standard now. Almost every production AI system that touches proprietary data uses some form of it. But there is a problem that the tutorials do not cover well.

The chunk boundaries are wrong.

🟢 Better chunking strategies help. Overlapping windows, semantic chunking, parent-document retrieval.

🔵 But the real fix is rethinking what you are storing. Sometimes the right thing to store is not the raw text but a structured representation of the information.

✅ If your RAG pipeline is returning technically correct but contextually useless results, the problem is almost certainly in the chunking or the metadata, not the embedding model.

Where I Think This Is All Going

The models are going to keep getting better. Context windows are going to keep expanding. The cost per token is going to keep dropping.

None of that changes the fundamental engineering challenge: building systems you can trust to behave correctly when you are not watching.

That is the problem worth solving. Governance, observability, and reliable tool use. Not chasing benchmarks.

It is closer to systems design than it is to model research.

Stop Fine-Tuning Your Model. Your Architecture Is the Problem.

AI Bug Slayer 🐞 — Fri, 06 Nov 2026 03:34:40 +0000

So here is my honest take on where things actually are.

The Problem With How We Talk About AI Agents

Everyone is calling everything an "agent" right now. A function that calls a tool? Agent. A chatbot with memory? Agent. A script with a loop? Agent.

This dilution is not just semantic. It is causing real engineering mistakes.

Here is the definition I keep coming back to: an agent is a system that has an objective, not just an instruction. It decides what to do next. It handles failure. It knows when it is done.

Everything else is just a fancy function call.

🟢 If your system needs a human to tell it each step, it is not an agent. It is a chat interface.

🔵 If your system can recover from a failed tool call and try a different approach, you are getting somewhere.

✅ If your system can decompose a goal into subtasks and delegate them, that is the real thing.

What Is Actually Happening in Production Right Now

The honest picture from teams I follow and talk to:

The teams getting good results are not chasing the latest model release. They are obsessing over:

☑️ Tool design -- what can the agent actually call, and how clean is the interface

☑️ Failure handling -- what happens when a tool returns nothing useful

☑️ Observability -- can you trace exactly why the agent made the decision it made

The teams getting bad results are the ones that swapped out GPT-4 for the latest frontier model and expected different behavior without changing anything else.

Something I kept seeing pop up recently: Airbnb says it’s launching an AI travel agent in the first half of 2027 (TechCrunch AI). Airbnb says its upcoming AI agent will help travelers plan trips, compare options, manage bookings, and get assistance throughout their stay....

Worth reading: https://techcrunch.com/2026/11/05/airbnb-says-its-launching-an-ai-travel-agent-in-the-first-half-of-2027/

Something I kept seeing pop up recently: Meta says US users can now video chat with their Muse AI avatar (TechCrunch AI). Meta's AI agent can now take calls as a customizable animated avatar, ahead of the launch of a Tamagotchi-like wearable designed to bring Muse to life....

Worth reading: https://techcrunch.com/2026/11/05/meta-says-us-users-can-now-video-chat-with-their-muse-ai-avatar/

Something I kept seeing pop up recently: Meta warns that election backlash against data centers could make AI expansion harder (TechCrunch AI). Meta warns that growing political opposition to data centers could threaten future AI investments, as communities push back against massive infrastructure projects....

Worth reading: https://techcrunch.com/2026/11/05/metas-warns-that-election-backlash-against-data-centers-could-make-ai-expansion-harder/

The Framework Wars Are a Distraction

LangChain. LangGraph. CrewAI. AutoGen. Semantic Kernel. Every month there is a new one and someone is writing a post about why the old one is dead.

Here is what I actually think: the framework matters less than the patterns.

The patterns that keep working regardless of what framework you use:

✔️ Plan-then-execute. Have one reasoning step that produces a plan, and a separate execution step that follows it. Do not mix them.

✔️ Separate retrieval from reasoning. Fetching context and using context are different jobs. Systems that conflate them get confused.

✔️ Explicit handoffs. When one agent passes work to another, the handoff should be structured and logged. Not a string passed through a prompt.

I have rebuilt the same architecture in three different frameworks and the results were similar each time. The framework is scaffolding. The architecture is the building.

The Retrieval Problem Nobody Has Solved

RAG is standard now. Almost every production AI system that touches proprietary data uses some form of it. But there is a problem that the tutorials do not cover well.

The chunk boundaries are wrong.

🟢 Better chunking strategies help. Overlapping windows, semantic chunking, parent-document retrieval.

🔵 But the real fix is rethinking what you are storing. Sometimes the right thing to store is not the raw text but a structured representation of the information.

✅ If your RAG pipeline is returning technically correct but contextually useless results, the problem is almost certainly in the chunking or the metadata, not the embedding model.

Where I Think This Is All Going

The models are going to keep getting better. Context windows are going to keep expanding. The cost per token is going to keep dropping.

None of that changes the fundamental engineering challenge: building systems you can trust to behave correctly when you are not watching.

That is the problem worth solving. Governance, observability, and reliable tool use. Not chasing benchmarks.

It is closer to systems design than it is to model research.

Fine-Tuning Is Mostly Theater. Here's What Works Instead.

AI Bug Slayer 🐞 — Fri, 06 Nov 2026 03:33:34 +0000

So here is my honest take on where things actually are.

The Problem With How We Talk About AI Agents

Everyone is calling everything an "agent" right now. A function that calls a tool? Agent. A chatbot with memory? Agent. A script with a loop? Agent.

This dilution is not just semantic. It is causing real engineering mistakes.

Here is the definition I keep coming back to: an agent is a system that has an objective, not just an instruction. It decides what to do next. It handles failure. It knows when it is done.

Everything else is just a fancy function call.

🟢 If your system needs a human to tell it each step, it is not an agent. It is a chat interface.

🔵 If your system can recover from a failed tool call and try a different approach, you are getting somewhere.

✅ If your system can decompose a goal into subtasks and delegate them, that is the real thing.

What Is Actually Happening in Production Right Now

The honest picture from teams I follow and talk to:

The teams getting good results are not chasing the latest model release. They are obsessing over:

☑️ Tool design -- what can the agent actually call, and how clean is the interface

☑️ Failure handling -- what happens when a tool returns nothing useful

☑️ Observability -- can you trace exactly why the agent made the decision it made

The teams getting bad results are the ones that swapped out GPT-4 for the latest frontier model and expected different behavior without changing anything else.

Worth reading: https://techcrunch.com/2026/11/05/airbnb-says-its-launching-an-ai-travel-agent-in-the-first-half-of-2027/

Worth reading: https://techcrunch.com/2026/11/05/meta-says-us-users-can-now-video-chat-with-their-muse-ai-avatar/

Worth reading: https://techcrunch.com/2026/11/05/metas-warns-that-election-backlash-against-data-centers-could-make-ai-expansion-harder/

The Framework Wars Are a Distraction

LangChain. LangGraph. CrewAI. AutoGen. Semantic Kernel. Every month there is a new one and someone is writing a post about why the old one is dead.

Here is what I actually think: the framework matters less than the patterns.

The patterns that keep working regardless of what framework you use:

✔️ Plan-then-execute. Have one reasoning step that produces a plan, and a separate execution step that follows it. Do not mix them.

✔️ Separate retrieval from reasoning. Fetching context and using context are different jobs. Systems that conflate them get confused.

✔️ Explicit handoffs. When one agent passes work to another, the handoff should be structured and logged. Not a string passed through a prompt.

I have rebuilt the same architecture in three different frameworks and the results were similar each time. The framework is scaffolding. The architecture is the building.

The Retrieval Problem Nobody Has Solved

RAG is standard now. Almost every production AI system that touches proprietary data uses some form of it. But there is a problem that the tutorials do not cover well.

The chunk boundaries are wrong.

🟢 Better chunking strategies help. Overlapping windows, semantic chunking, parent-document retrieval.

🔵 But the real fix is rethinking what you are storing. Sometimes the right thing to store is not the raw text but a structured representation of the information.

✅ If your RAG pipeline is returning technically correct but contextually useless results, the problem is almost certainly in the chunking or the metadata, not the embedding model.

Where I Think This Is All Going

The models are going to keep getting better. Context windows are going to keep expanding. The cost per token is going to keep dropping.

None of that changes the fundamental engineering challenge: building systems you can trust to behave correctly when you are not watching.

That is the problem worth solving. Governance, observability, and reliable tool use. Not chasing benchmarks.

It is closer to systems design than it is to model research.

The Real Reason Big Tech Is Rushing to Ship AI Agents Before the End of the Year

AI Bug Slayer 🐞 — Wed, 04 Nov 2026 03:33:12 +0000

So here is my honest take on where things actually are.

The Problem With How We Talk About AI Agents

Everyone is calling everything an "agent" right now. A function that calls a tool? Agent. A chatbot with memory? Agent. A script with a loop? Agent.

This dilution is not just semantic. It is causing real engineering mistakes.

Here is the definition I keep coming back to: an agent is a system that has an objective, not just an instruction. It decides what to do next. It handles failure. It knows when it is done.

Everything else is just a fancy function call.

🟢 If your system needs a human to tell it each step, it is not an agent. It is a chat interface.

🔵 If your system can recover from a failed tool call and try a different approach, you are getting somewhere.

✅ If your system can decompose a goal into subtasks and delegate them, that is the real thing.

What Is Actually Happening in Production Right Now

The honest picture from teams I follow and talk to:

The teams getting good results are not chasing the latest model release. They are obsessing over:

☑️ Tool design -- what can the agent actually call, and how clean is the interface

☑️ Failure handling -- what happens when a tool returns nothing useful

☑️ Observability -- can you trace exactly why the agent made the decision it made

The teams getting bad results are the ones that swapped out GPT-4 for the latest frontier model and expected different behavior without changing anything else.

Something I kept seeing pop up recently: Anthropic is working on a system to prove AI models’ identity (TechCrunch AI). Called FlashProve, the system would let anyone check that an AI response really came from the model it claims to be from....

Worth reading: https://techcrunch.com/2026/11/03/anthropic-is-working-on-a-system-to-prove-ai-models-identity/

Something I kept seeing pop up recently: Data centers are turning to old jet engines as the wait for power grows (TechCrunch AI). The years-long wait for access to the grid and new turbines is causing data center builders to turn to an unusual, less-efficient and less environmentally friendly solution: once-d...

Worth reading: https://techcrunch.com/2026/11/03/data-centers-are-turning-to-old-jet-engines-as-the-wait-for-power-grows/

Something I kept seeing pop up recently: Ted Schlein’s Ballistic Ventures seeks $490M for new funds amid AI-driven cybersecurity boom (TechCrunch AI). Cybersecurity-focused Ballistic Ventures is seeking to raise $360 million for a new flagship fund and another $130 million for a separate investment vehicle....

Worth reading: https://techcrunch.com/2026/11/03/ted-schleins-ballistic-ventures-seeks-490m-for-new-funds-amid-ai-driven-cybersecurity-boom/

The Framework Wars Are a Distraction

LangChain. LangGraph. CrewAI. AutoGen. Semantic Kernel. Every month there is a new one and someone is writing a post about why the old one is dead.

Here is what I actually think: the framework matters less than the patterns.

The patterns that keep working regardless of what framework you use:

✔️ Plan-then-execute. Have one reasoning step that produces a plan, and a separate execution step that follows it. Do not mix them.

✔️ Separate retrieval from reasoning. Fetching context and using context are different jobs. Systems that conflate them get confused.

✔️ Explicit handoffs. When one agent passes work to another, the handoff should be structured and logged. Not a string passed through a prompt.

I have rebuilt the same architecture in three different frameworks and the results were similar each time. The framework is scaffolding. The architecture is the building.

The Retrieval Problem Nobody Has Solved

RAG is standard now. Almost every production AI system that touches proprietary data uses some form of it. But there is a problem that the tutorials do not cover well.

The chunk boundaries are wrong.

🟢 Better chunking strategies help. Overlapping windows, semantic chunking, parent-document retrieval.

🔵 But the real fix is rethinking what you are storing. Sometimes the right thing to store is not the raw text but a structured representation of the information.

✅ If your RAG pipeline is returning technically correct but contextually useless results, the problem is almost certainly in the chunking or the metadata, not the embedding model.

Where I Think This Is All Going

The models are going to keep getting better. Context windows are going to keep expanding. The cost per token is going to keep dropping.

None of that changes the fundamental engineering challenge: building systems you can trust to behave correctly when you are not watching.

That is the problem worth solving. Governance, observability, and reliable tool use. Not chasing benchmarks.

It is closer to systems design than it is to model research.

The AI News Stopped Being About Models. Here's What That Means for Your Stack

AI Bug Slayer 🐞 — Wed, 04 Nov 2026 03:32:23 +0000

I read the AI news every morning before I touch code, mostly to see whether the thing I am building is about to be commoditized. This week the stories had almost nothing to do with model quality. Not one of them was about a better benchmark.

They were about proof, cost, and fences. That is a tell. When the news stops being about capability and starts being about verification, you know the technology has moved into the boring phase, and the boring phase is where the actual engineering work lives.

Let me walk through what I noticed, because each story maps to something you and I will hit in production within a quarter.

Anthropic wants to prove an output came from the model it claims

The story: Anthropic is working on a system called FlashProve that would let anyone check that a response really came from the model it says it came from (TechCrunch).

Sit with that for a second. The assumption we have all been coding against is that a model output is a string. You call an API, you get text back, you trust it because you control the API key. That assumption quietly breaks the moment more than one party is involved.

And more than one party is already involved in most real systems. You have a gateway that rewrites prompts. A router that sends cheap requests to a small model. A caching layer that serves yesterday's answer. A fine-tune sitting behind a vendor's endpoint label. A subagent that reports back to a coordinator with no way to prove which model actually produced its output.

Today, when a customer asks "which model wrote this reply, and did it see the redacted version of the prompt," most teams answer with a log line they wrote themselves. That is not proof. It is a diary kept by a party that might be wrong.

What I would expect this to change, if it ships: signed outputs become a thing you attach to, the same way you attach a request ID today. And teams will start treating model identity as part of the artifact, not part of the infrastructure.

In the meantime, here is the cheap version I would build right now, because it costs almost nothing and it saved me during an incident last year.

import hashlib, json, time

def task_ledger(entry):
    # Everything needed to reconstruct who produced what, and why it cost that much
    record = {
        "trace_id": entry["trace_id"],
        "model_claimed": entry["model"],
        "prompt_hash": hashlib.sha256(entry["prompt"].encode()).hexdigest()[:16],
        "cache_hit": entry["cache_hit"],
        "tokens_in": entry["usage"]["in"],
        "tokens_out": entry["usage"]["out"],
        "cost_usd": round(entry["cost_usd"], 6),
        "verified": entry.get("verified", False),
        "ts": time.time(),
    }
    # Append-only sink: S3, BigQuery, whatever you already run
    return json.dumps(record)

Two lines in that function matter more than the rest. prompt_hash lets you prove the input without storing customer text. verified is a flag you can flip to True once your provider gives you something checkable. If you start writing that flag today, the day attestation exists you will already have the plumbing.

The compute bill is now the product decision

Two stories, one pattern. Fal doubled its valuation to $16B on a $1.3B round because inference demand is surging (TechCrunch). At the same time, Anthropic's compute margins are reportedly getting worse exactly when they should be improving (TechCrunch). And data center builders are so desperate for power that they are buying retired jet engines (TechCrunch).

Old jet engines. That is the physical reality behind the word "inference."

The engineering lesson is blunt: token price is not your cost. Cost per successful task is your cost, and the two diverge wildly.

A cheap model that needs three retries, two tool calls, and a human review is more expensive than the expensive model that got it right once. I have watched teams celebrate a 70 percent price cut on paper while their support queue got longer. The bill went down and the product got worse.

Practical version, three things I actually do now:

Route by task class, not by vibes. Extraction and classification get the small model. Anything that writes code or makes a judgement call gets the big one. Put the mapping in a config file so you can measure it.
Cache aggressively on the boring axis. If your prompts share a long prefix (system prompt, schema, examples), you are paying for those tokens forever. Prefix caching is the highest leverage optimization in most codebases and almost nobody instruments it.
Track success, not usage. When I log a task, I log whether it needed a retry, whether it was escalated, and whether it was accepted. Then cost per accepted task becomes a number I can put next to a latency chart.

If you cannot compute cost per accepted task, you are not doing AI engineering yet. You are doing API integration with a scary invoice.

The guardrails are becoming product decisions, not policy footnotes

Apple is now requiring 18+ ratings for dating apps and AI companions that offer romantic or sexual content (TechCrunch). Google will let schools disable its AI tools, except the switch also removes Search, because AI is now embedded inside the search engine itself (TechCrunch).

Both stories are the same story from different directions. AI features are no longer separable from the product they sit in.

That has a direct consequence for how we build. If a policy change means "turn the AI off," and your AI is a hard dependency of your core flow, you have a bad architecture decision hiding as a policy question. Google is a big enough company to make the trade off explicit. Your app is probably not.

I have started defaulting to this pattern in anything that has a regulated or jittery customer segment: the feature flag is the policy engine.

ai_companion_enabled: false        # default off
age_gate_required: true
allowed_modes: [assistant, notes]  # romantic mode excluded
fallback_path: template_reply      # not an error page

Note the last line. The failure mode of a disabled AI feature should be a slightly worse experience, not a broken screen. Every "AI off" switch needs a defined non-AI path or you have not built a switch, you have built an outage.

What I would actually do this week

Not a framework. Not a migration. Four small things:

Add a verified boolean and a prompt hash to whatever you already log. Zero behavior change, future option.
Compute cost per accepted task for your single most expensive workflow. Just one. The number will surprise you.
Find your longest shared prompt prefix and turn on caching. This is usually a one hour change with an immediate bill reduction.
Pick one AI feature and define what it looks like when it is switched off. Write the fallback before you need it.

None of these are interesting to demo. All of them are what separates a system that survives contact with users from a system that looked great in a launch video.

The honest take

For two years the interesting question was "what can the model do." That question is largely answered, and the answer is "a lot, unreliably, at a price you did not budget for."

The interesting question now is "can you prove what it did, and can you afford to keep doing it." Those are systems questions, not model questions. They need ledgers, cost accounting, and fences with real fallbacks behind them.

The teams I worry about are the ones still swapping in the newest model each month and expecting the behavior to change. The teams I would bet on are quietly building the accounting layer. It is much less fun to write and much harder to replace later.

If you are working on this, I want to know how you are measuring it. Especially the cost per task part, because I still have not seen two teams do it the same way.

The Window to Build AI Expertise Is Closing Faster Than Anyone Expected

AI Bug Slayer 🐞 — Mon, 02 Nov 2026 03:32:26 +0000

So here is my honest take on where things actually are.

The Problem With How We Talk About AI Agents

Everyone is calling everything an "agent" right now. A function that calls a tool? Agent. A chatbot with memory? Agent. A script with a loop? Agent.

This dilution is not just semantic. It is causing real engineering mistakes.

Here is the definition I keep coming back to: an agent is a system that has an objective, not just an instruction. It decides what to do next. It handles failure. It knows when it is done.

Everything else is just a fancy function call.

🟢 If your system needs a human to tell it each step, it is not an agent. It is a chat interface.

🔵 If your system can recover from a failed tool call and try a different approach, you are getting somewhere.

✅ If your system can decompose a goal into subtasks and delegate them, that is the real thing.

What Is Actually Happening in Production Right Now

The honest picture from teams I follow and talk to:

The teams getting good results are not chasing the latest model release. They are obsessing over:

☑️ Tool design -- what can the agent actually call, and how clean is the interface

☑️ Failure handling -- what happens when a tool returns nothing useful

☑️ Observability -- can you trace exactly why the agent made the decision it made

The teams getting bad results are the ones that swapped out GPT-4 for the latest frontier model and expected different behavior without changing anything else.

Something I kept seeing pop up recently: OpenAI might rebrand its data centers as ‘AI compute campuses’ (TechCrunch AI). Data centers are deeply unpopular. But what if we called them something else?...

Worth reading: https://techcrunch.com/2026/11/01/openai-might-rebrand-its-data-centers-as-ai-compute-campuses/

Something I kept seeing pop up recently: AI can make tech CEOs’ lives easier. What about everyone else? (TechCrunch AI). On Equity, we discuss why tech CEO statements can seem so tone deaf....

Worth reading: https://techcrunch.com/2026/11/01/ai-can-make-tech-ceos-lives-easier-what-about-everyone-else/

Something I kept seeing pop up recently: Apple CEO says the company doesn’t ‘want to ship AI for AI’s sake’ (TechCrunch AI). Apple's new CEO defended the company's current position in the AI landscape....

Worth reading: https://techcrunch.com/2026/10/31/apple-ceo-says-the-company-doesnt-want-to-ship-ai-for-ais-sake/

The Framework Wars Are a Distraction

LangChain. LangGraph. CrewAI. AutoGen. Semantic Kernel. Every month there is a new one and someone is writing a post about why the old one is dead.

Here is what I actually think: the framework matters less than the patterns.

The patterns that keep working regardless of what framework you use:

✔️ Plan-then-execute. Have one reasoning step that produces a plan, and a separate execution step that follows it. Do not mix them.

✔️ Separate retrieval from reasoning. Fetching context and using context are different jobs. Systems that conflate them get confused.

✔️ Explicit handoffs. When one agent passes work to another, the handoff should be structured and logged. Not a string passed through a prompt.

I have rebuilt the same architecture in three different frameworks and the results were similar each time. The framework is scaffolding. The architecture is the building.

The Retrieval Problem Nobody Has Solved

RAG is standard now. Almost every production AI system that touches proprietary data uses some form of it. But there is a problem that the tutorials do not cover well.

The chunk boundaries are wrong.

🟢 Better chunking strategies help. Overlapping windows, semantic chunking, parent-document retrieval.

🔵 But the real fix is rethinking what you are storing. Sometimes the right thing to store is not the raw text but a structured representation of the information.

✅ If your RAG pipeline is returning technically correct but contextually useless results, the problem is almost certainly in the chunking or the metadata, not the embedding model.

Where I Think This Is All Going

The models are going to keep getting better. Context windows are going to keep expanding. The cost per token is going to keep dropping.

None of that changes the fundamental engineering challenge: building systems you can trust to behave correctly when you are not watching.

That is the problem worth solving. Governance, observability, and reliable tool use. Not chasing benchmarks.

It is closer to systems design than it is to model research.

The AI Architecture Decision You Need to Make Before It's Too Late

AI Bug Slayer 🐞 — Mon, 02 Nov 2026 03:31:47 +0000

So here is my honest take on where things actually are.

The Problem With How We Talk About AI Agents

Everyone is calling everything an "agent" right now. A function that calls a tool? Agent. A chatbot with memory? Agent. A script with a loop? Agent.

This dilution is not just semantic. It is causing real engineering mistakes.

Here is the definition I keep coming back to: an agent is a system that has an objective, not just an instruction. It decides what to do next. It handles failure. It knows when it is done.

Everything else is just a fancy function call.

🟢 If your system needs a human to tell it each step, it is not an agent. It is a chat interface.

🔵 If your system can recover from a failed tool call and try a different approach, you are getting somewhere.

✅ If your system can decompose a goal into subtasks and delegate them, that is the real thing.

What Is Actually Happening in Production Right Now

The honest picture from teams I follow and talk to:

The teams getting good results are not chasing the latest model release. They are obsessing over:

☑️ Tool design -- what can the agent actually call, and how clean is the interface

☑️ Failure handling -- what happens when a tool returns nothing useful

☑️ Observability -- can you trace exactly why the agent made the decision it made

The teams getting bad results are the ones that swapped out GPT-4 for the latest frontier model and expected different behavior without changing anything else.

Worth reading: https://techcrunch.com/2026/11/01/openai-might-rebrand-its-data-centers-as-ai-compute-campuses/

Something I kept seeing pop up recently: AI can make tech CEOs’ lives easier. What about everyone else? (TechCrunch AI). On Equity, we discuss why tech CEO statements can seem so tone deaf....

Worth reading: https://techcrunch.com/2026/11/01/ai-can-make-tech-ceos-lives-easier-what-about-everyone-else/

Worth reading: https://techcrunch.com/2026/10/31/apple-ceo-says-the-company-doesnt-want-to-ship-ai-for-ais-sake/

The Framework Wars Are a Distraction

LangChain. LangGraph. CrewAI. AutoGen. Semantic Kernel. Every month there is a new one and someone is writing a post about why the old one is dead.

Here is what I actually think: the framework matters less than the patterns.

The patterns that keep working regardless of what framework you use:

✔️ Plan-then-execute. Have one reasoning step that produces a plan, and a separate execution step that follows it. Do not mix them.

✔️ Separate retrieval from reasoning. Fetching context and using context are different jobs. Systems that conflate them get confused.

✔️ Explicit handoffs. When one agent passes work to another, the handoff should be structured and logged. Not a string passed through a prompt.

I have rebuilt the same architecture in three different frameworks and the results were similar each time. The framework is scaffolding. The architecture is the building.

The Retrieval Problem Nobody Has Solved

RAG is standard now. Almost every production AI system that touches proprietary data uses some form of it. But there is a problem that the tutorials do not cover well.

The chunk boundaries are wrong.

🟢 Better chunking strategies help. Overlapping windows, semantic chunking, parent-document retrieval.

🔵 But the real fix is rethinking what you are storing. Sometimes the right thing to store is not the raw text but a structured representation of the information.

✅ If your RAG pipeline is returning technically correct but contextually useless results, the problem is almost certainly in the chunking or the metadata, not the embedding model.

Where I Think This Is All Going

The models are going to keep getting better. Context windows are going to keep expanding. The cost per token is going to keep dropping.

None of that changes the fundamental engineering challenge: building systems you can trust to behave correctly when you are not watching.

That is the problem worth solving. Governance, observability, and reliable tool use. Not chasing benchmarks.

It is closer to systems design than it is to model research.