LangChain Agent Middleware, Explained
LangChain 1.0 reduced the agent to two lines and moved everything interesting into hooks. The quiet consequence: supervisor, swarm, and reflection stop being architectures and become middleware you stack.
4 min
JSON Mode vs Function Calling vs Constrained Decoding: Getting Reliable Structured Output
Three different things hide under "structured output": valid JSON, the right shape, the right values. Each method buys you a different one — and none of them buys the last.
5 min
How to Write Tool Descriptions for AI Agents
A tool description isn't documentation — it's a prompt you pay for on every call and the model rereads more carefully than your system prompt. Treat it like one, and stop shipping your whole API as tools.
4 min
How to Test an MCP Server: The Inspector, In-Memory Transports, and the Eval You're Actually Missing
Protocol tests prove your server works. They say nothing about the failure that actually breaks users — a perfectly valid server whose tool descriptions make the model reach for the wrong tool.
6 min
How to Reduce LLM Hallucinations in Production
You can't prompt a model into never being wrong — hallucination is the same machinery as a correct answer. The win is making every claim cheap to check.
6 min
How to Reduce AI Agent Token Costs
The cheaper-model reflex is the wrong first move. An agent's bill is dominated by the transcript it re-sends on every step — so the money is in the context, not the price card.
5 min
How to Reduce AI Agent Latency
Buying a faster model is the reflex, and usually the wrong first move. An agent's wait is a chain of serial round-trips — so the latency is in the loop, not the tokens-per-second.
4 min
RAG Context Ordering: Where to Put Your Best Chunk in the Prompt
The 'reorder so the best chunks sit at the start and end' trick everyone copies from LangChain is a 2023 patch for a 2023 problem. On a tight, well-reranked context it can quietly demote your second-best evidence to the worst seat in the room.
4 min
How to Migrate Embedding Models in Production Without Wrecking Retrieval
Re-embedding your corpus is cheap. The expensive part is that two models live in two incompatible vector spaces — and a naive rolling reindex hides the damage behind green dashboards.
5 min
How to Handle LLM Rate Limits: Retries, Backoff, and Fallbacks Without Burning Your Bill
Every agent in production eventually meets a 429. The naive fix — just retry — is also the most expensive bug in modern LLM apps. Here's the layered pattern that survives the limit instead of paying triple for it.
5 min
How to Handle LLM API Failures: Retries, Timeouts, and Fallback Chains
A 429 means wait; a 400 means stop; a 200 from your backup model can be the most dangerous answer of all. The reliability layer every agent needs and most skip.
5 min
How to Get a Confidence Score From an LLM (and Why the Easy One Lies)
Token logprobs are right there in the API, cheap and ignored — and after RLHF they're systematically overconfident. The signal that actually tracks whether the answer is right costs you N times the inference.
5 min
How to Deploy an MCP Server: stdio, Streamable HTTP, and the Stateless Fork
The code is the easy part. The decision that quietly dictates your hosting bill, your scaling story, and your deploy strategy is one you make before you write a line: will your server hold a session, or not?
6 min
How to Build an LLM Eval Dataset
The scoring framework is the commodity. The hard, valuable, un-buyable work is looking at your own outputs and distilling real failures into labeled cases — your eval set is a precipitate of error analysis, not a download.
4 min
How to Build a Knowledge Graph From Documents With an LLM
Extracting entities and relations is the easy 80%. The graph is only as good as the step everyone skips — deciding that 'OpenAI', 'OpenAI Inc.', and 'the company' are one node.
4 min
How to Add Citations to a RAG Pipeline
A citation is a pointer, not a proof. Getting an LLM to footnote its answer is an architecture decision about which IDs survive into the prompt — not a line you add to the system message.
5 min
Why AI Agents Get Worse as You Add Tools — and How Tool Retrieval Fixes It
Every tool you connect sits in the context window competing for attention. Past a few dozen, accuracy falls. The fix isn't a bigger model — it's treating tool selection as a search problem.
5 min
Google ADK vs LangGraph: Which Agent Framework Should You Build On in 2026?
Both will run the same agent. The real difference is altitude — ADK hands you an org chart of agents, LangGraph hands you the wiring and a roll of tape.
4 min
Git Worktrees Solve the Easy Half of Parallel AI Agents
Worktrees stop your agents from overwriting each other's files. They do nothing about the shared database, the fight over port 3000, or the review queue that becomes your real bottleneck.
5 min
Dify vs LangChain: Platform or Framework for Your LLM App?
One hands you a finished application to configure; the other hands you parts to assemble. The choice isn't easy-vs-powerful — it's whether your product's hard part lives where the platform already decided.
4 min
Cross-Encoder vs Bi-Encoder: Why Your Retriever and Your Reranker Can't Be the Same Model
They read like rivals you choose between. They're two stages of one pipeline, forced apart by a single computational fact — and that fact tells you exactly where each one belongs.
5 min
Choosing an Open Vision-Language Model for Agents in 2026: Qwen3-VL vs InternVL3.5 vs Holo1.5
The best open VLM for an agent isn't the one that scores highest on MMMU. It's the one that can hand back an accurate click coordinate — and those are not the same models.
6 min
AWS Bedrock AgentCore, Explained: The Agent Runtime That Doesn't Care Which Framework You Use
Amazon's agent platform sells you everything except the agent. Here is what the seven services actually do, what the numbers mean, and why the neutrality is the whole strategy.
5 min
Apache Burr vs LangGraph: State Machine or Graph for Your Agent?
Both let you wire an agent as nodes and edges, so they look like the same tool with different syntax. The real split is what each one lets you prove about the thing before it runs.
5 min
Agentic AI vs Generative AI: What Actually Separates Them
The slide deck says one makes content and the other takes action. The sharper line is a single word: loop. Agentic AI is a generative model placed inside a feedback loop with tools and a goal — and that loop is where the value and the failure both live.
5 min
Agent Skills vs Subagents vs Tools: When to Use Which
They get pitched as three ways to extend an agent. They aren't interchangeable — a tool is an action, a Skill writes knowledge into the context window, and a subagent keeps work out of it.
5 min
Agent Memory vs RAG: What's Actually Different
Both embed a query and pull matching text into the prompt, so they look like the same trick. The difference is who writes the index — and that single fact moves the hard problem from retrieval to write discipline.
4 min
AG2 vs AutoGen: Which One Should You Actually Install in 2026?
They share a name, a history, and a lot of code — but by 2026 'AutoGen' splintered into three projects, and the one you pip install decides whose roadmap you inherit.
4 min
Why LLM Inference Isn't Deterministic — Even at Temperature 0
Greedy decoding should give the same answer every time. It doesn't — and the usual 'floating-point' excuse is wrong. The real culprit is what else is in the batch with you.
5 min
Cosine vs Dot Product vs Euclidean: Which Vector Similarity Metric (and Why It Often Doesn't Matter)
For the normalized embeddings most models now emit, all three metrics rank results identically. The decisions that actually change your recall are the two nobody frames as a choice.
5 min