DEV Community: AI Bug Slayer 🐞

What I Learned After Running AI Agents in Production for a Year

AI Bug Slayer 🐞 — Fri, 02 Oct 2026 03:33:44 +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: Musk’s AI chatbot Grok reportedly encouraged Trump to capture Venezuela’s president (TechCrunch AI). President Trump reportedly asked for Grok's opinion before invading Venezuela and capturing Nicolás Maduro....

Worth reading: https://techcrunch.com/2026/10/01/musks-ai-chatbot-grok-reportedly-encouraged-trump-to-capture-venezuelas-president/

Something I kept seeing pop up recently: ChatGPT can now virtually try on clothes for you (TechCrunch AI). OpenAI is rolling out new shopping features for ChatGPT that let users virtually try on clothing and accessories using their own photos and save products they like to a Favorites l...

Worth reading: https://techcrunch.com/2026/10/01/chatgpt-can-now-virtually-try-on-clothes-for-you/

Something I kept seeing pop up recently: OpenAI cuts ties with 3 safety researchers, WSJ reports (TechCrunch AI). OpenAI has parted ways with three safety researchers after an internal investigation found they mishandled sensitive company information, report says....

Worth reading: https://techcrunch.com/2026/10/01/openai-cuts-ties-with-three-safety-researchers-wsj-reports/

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.

LangGraph vs CrewAI vs AutoGen: A Brutally Honest Comparison After 6 Months

AI Bug Slayer 🐞 — Fri, 02 Oct 2026 03:31:19 +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/10/01/musks-ai-chatbot-grok-reportedly-encouraged-trump-to-capture-venezuelas-president/

Worth reading: https://techcrunch.com/2026/10/01/chatgpt-can-now-virtually-try-on-clothes-for-you/

Worth reading: https://techcrunch.com/2026/10/01/openai-cuts-ties-with-three-safety-researchers-wsj-reports/

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.

Why Your AI Agent Keeps Failing in Production (It's Not the Model)

AI Bug Slayer 🐞 — Mon, 28 Sep 2026 03:35:06 +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’s CEO is about to have dinner with President Trump (TechCrunch AI). This will be the first one-on-one meeting between Dario Amodei and Donald Trump...

Worth reading: https://techcrunch.com/2026/09/27/anthropics-ceo-is-about-to-have-dinner-with-president-trump/

Something I kept seeing pop up recently: Can Muse overcome Meta’s trust issues? (TechCrunch AI). On Equity, we discussed how Meta's AI announcement managed to steal the spotlight from OpenAI and Anthropic....

Worth reading: https://techcrunch.com/2026/09/27/can-muse-overcome-metas-trust-issues/

Something I kept seeing pop up recently: Anthropic’s Dario Amodei gets the SNL treatment (TechCrunch AI). "AI is the devil and I its maker."...

Worth reading: https://techcrunch.com/2026/09/27/anthropics-dario-amodei-gets-the-snl-treatment/

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 LLM Nobody Talks About That Keeps Showing Up in Production Stacks

AI Bug Slayer 🐞 — Mon, 28 Sep 2026 03:33:45 +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/09/27/anthropics-ceo-is-about-to-have-dinner-with-president-trump/

Worth reading: https://techcrunch.com/2026/09/27/can-muse-overcome-metas-trust-issues/

Something I kept seeing pop up recently: Anthropic’s Dario Amodei gets the SNL treatment (TechCrunch AI). "AI is the devil and I its maker."...

Worth reading: https://techcrunch.com/2026/09/27/anthropics-dario-amodei-gets-the-snl-treatment/

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.

Two Years From Now, This Will Be the Only Skill That Matters in AI

AI Bug Slayer 🐞 — Fri, 25 Sep 2026 03:34: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.

Something I kept seeing pop up recently: PrismML brings its tiny LLMs to Qualcomm-powered smart glasses (TechCrunch AI). Prism's larger goal is open-weight AI that runs on devices and makes better use of the computing power they already have....

Worth reading: https://techcrunch.com/2026/09/24/prismml-brings-its-tiny-llms-to-qualcomm-powered-smart-glasses/

Something I kept seeing pop up recently: Meta’s Muse Charm looks like a Tamagotchi, but it’s tapping into a much newer trend (TechCrunch AI). Meta’s new AI gadget may look like a Tamagotchi, but its dangling form factor taps into a much broader Gen Z trend around bag charms, retro tech, and turning gadgets into fashion a...

Worth reading: https://techcrunch.com/2026/09/24/metas-muse-charm-looks-like-a-tamagotchi-but-its-tapping-into-a-much-newer-trend/

Something I kept seeing pop up recently: Google Photos ‘Clueless’-inspired virtual closet is now available on Android and iOS (TechCrunch AI). The AI-powered feature builds a virtual wardrobe from your photos, and is now broadly available after first rolling out to Android users in June....

Worth reading: https://techcrunch.com/2026/09/24/google-photos-clueless-inspired-virtual-closet-is-now-available-on-android-and-ios/

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.

Why Retrieval-Augmented Generation Is Harder Than Every Tutorial Makes It Look.

AI Bug Slayer 🐞 — Fri, 25 Sep 2026 03:31:48 +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/09/24/prismml-brings-its-tiny-llms-to-qualcomm-powered-smart-glasses/

Worth reading: https://techcrunch.com/2026/09/24/metas-muse-charm-looks-like-a-tamagotchi-but-its-tapping-into-a-much-newer-trend/

Worth reading: https://techcrunch.com/2026/09/24/google-photos-clueless-inspired-virtual-closet-is-now-available-on-android-and-ios/

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.

LangGraph vs CrewAI vs AutoGen: A Brutally Honest Comparison After 6 Months

AI Bug Slayer 🐞 — Wed, 23 Sep 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.

Something I kept seeing pop up recently: TechCrunch Founder Summit’s agenda revealed: Unlock fundraising, hiring, and AI insights in Boston on November 4 (TechCrunch AI). Founders shouldn't have to learn the hardest lessons the hardest way. TechCrunch Founder Summit is designed to make the challenges of starting a company easier and the highs that m...

Worth reading: https://techcrunch.com/2026/09/22/techcrunch-founder-summits-agenda-revealed-unlock-fundraising-hiring-and-ai-insights-in-boston-on-november-4/

Something I kept seeing pop up recently: Snorkel AI triples valuation to $3.5B as demand for AI training data booms (TechCrunch AI). The seven-year-old startup has raised a $350 million Series E to fuel its data-as-a-service approach....

Worth reading: https://techcrunch.com/2026/09/22/snorkel-ai-triples-valuation-to-3-5b-as-demand-for-ai-training-data-booms/

Something I kept seeing pop up recently: Qualcomm launches two new smartphone chips with emphasis on AI (TechCrunch AI). Qualcomm said that its new top chip can run 30B mixture-of-expert model locally....

Worth reading: https://techcrunch.com/2026/09/22/qualcomm-launches-two-new-smartphone-chips-with-emphasis-on-ai/

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 🐞 — Wed, 23 Sep 2026 03:31:09 +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/09/22/techcrunch-founder-summits-agenda-revealed-unlock-fundraising-hiring-and-ai-insights-in-boston-on-november-4/

Worth reading: https://techcrunch.com/2026/09/22/snorkel-ai-triples-valuation-to-3-5b-as-demand-for-ai-training-data-booms/

Worth reading: https://techcrunch.com/2026/09/22/qualcomm-launches-two-new-smartphone-chips-with-emphasis-on-ai/

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, 21 Sep 2026 03:33:56 +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: World model companies are keeping a lot of secrets (TechCrunch AI). Everyone in the world-models space is sitting on a pile of cash and a ton of buzz, but good luck getting anyone — from the founders to their own data suppliers — to tell you what t...

Worth reading: https://techcrunch.com/2026/09/20/world-model-companies-are-keeping-a-lot-of-secrets/

Something I kept seeing pop up recently: Is the AI industry really ready to slow down? (TechCrunch AI). On Equity, we debated whether Ai executives are serious about wanting to slow down....

Worth reading: https://techcrunch.com/2026/09/20/is-the-ai-industry-really-ready-to-slow-down/

Something I kept seeing pop up recently: Flock reportedly tries to shrink workforce with employee buyouts (TechCrunch AI). Without buyouts, Flock would "almost certainly" need to lay off staff....

Worth reading: https://techcrunch.com/2026/09/19/flock-reportedly-tries-to-shrink-workforce-with-employee-buyouts/

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.

Agents Are Not Magic. Here's the Boring Infrastructure That Makes Them Work.

AI Bug Slayer 🐞 — Mon, 21 Sep 2026 03:32:17 +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/09/20/world-model-companies-are-keeping-a-lot-of-secrets/

Something I kept seeing pop up recently: Is the AI industry really ready to slow down? (TechCrunch AI). On Equity, we debated whether Ai executives are serious about wanting to slow down....

Worth reading: https://techcrunch.com/2026/09/20/is-the-ai-industry-really-ready-to-slow-down/

Worth reading: https://techcrunch.com/2026/09/19/flock-reportedly-tries-to-shrink-workforce-with-employee-buyouts/

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.

What Nobody Tells You About Deploying LLMs at Scale

AI Bug Slayer 🐞 — Fri, 18 Sep 2026 03:34:24 +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: Crusoe raises $3.9B to build massive data centers and small modular ‘AI factories’ (TechCrunch AI). The round values the data center giant at $30.9 billion....

Worth reading: https://techcrunch.com/2026/09/17/crusoe-raises-3-9b-to-build-massive-data-centers-and-small-modular-ai-factories/

Something I kept seeing pop up recently: Google DeepMind launches institute to widen the AGI debate (TechCrunch AI). The new institute aims to surface differing views between Google, Google DeepMind, and the broader global research community around AGI. "They will not always agree, and they will...

Worth reading: https://techcrunch.com/2026/09/17/google-deepmind-launches-institute-to-widen-the-agi-debate/

Something I kept seeing pop up recently: PrismML hopes its tiny LLM will change how we all use AI (TechCrunch AI). If AI lab PrismML isn't on your radar yet, it should be....

Worth reading: https://techcrunch.com/2026/09/17/prismml-hopes-its-tiny-llm-could-change-how-we-all-use-ai/

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.

I Built the Same AI Agent in 4 Frameworks. Here's the Honest Breakdown.

AI Bug Slayer 🐞 — Fri, 18 Sep 2026 03:34:15 +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/09/17/crusoe-raises-3-9b-to-build-massive-data-centers-and-small-modular-ai-factories/

Worth reading: https://techcrunch.com/2026/09/17/google-deepmind-launches-institute-to-widen-the-agi-debate/

Something I kept seeing pop up recently: PrismML hopes its tiny LLM will change how we all use AI (TechCrunch AI). If AI lab PrismML isn't on your radar yet, it should be....

Worth reading: https://techcrunch.com/2026/09/17/prismml-hopes-its-tiny-llm-could-change-how-we-all-use-ai/

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.