Langfuse vs LangSmith vs Braintrust: LLM Observability and Evals Compared
Three platforms that look like competitors but optimize for different primary jobs, with lock-in profiles that diverge sharply once you read the fine print.
4 min
What Are Deep Agents? The Four-Part Pattern Behind Long-Horizon AI Agents
A deep agent is not a new model or a framework breakthrough — it's four cheap, known ingredients that let a plain tool-calling loop survive a long task instead of drifting.
5 min
The Four Kinds of Agent Memory: Working, Episodic, Semantic, Procedural
Most teams buy one vector store and call it 'memory.' It solves exactly one of the four problems — which is why the agent still loses the thread and repeats yesterday's mistake.
5 min
Self-Hosting LLM Inference vs an API: The Break-Even Math
Is it cheaper to run an open model on your own GPUs than to call an API? The deciding number isn't the token price — it's how busy the GPU stays.
5 min
Self-Consistency vs Best-of-N: How to Pick the Best of Many Samples
Both spend N times the inference to make a model smarter. The difference is how they choose the winner — and that choice decides which tasks each one can help.
6 min
RL Environments for AI Agents: The Bottleneck Moved From the Algorithm to the Environment
Everyone has GRPO now — it ships in every training library. The scarce, defensible input in agent training turned out to be the environment, and it looks suspiciously like your eval.
4 min
Retrieval Metrics for RAG: Recall@k vs MRR vs NDCG (and Which One Actually Matters)
Search teams optimize NDCG. RAG teams copy them — and measure the wrong thing. For a pipeline that hands the whole top-k to a generator, recall is the floor and rank position is a second-order correction.
5 min
Parent Document vs Sentence Window vs Auto-Merging Retrieval
The chunk that matches your query best is rarely the chunk that answers it. Small-to-big retrieval fixes that — here's how the three patterns differ and which to reach for.
5 min
The OWASP Top 10 for LLM Applications, Explained for Agent Builders
The list reads like a model-safety checklist. Read it again: most of the ten are not the model misbehaving — they're your architecture trusting the model too much. Agents make exactly those entries worse.
5 min
OpenAI Apps SDK vs MCP: How to Build a ChatGPT App in 2026
The Apps SDK isn't a rival to MCP. Your ChatGPT app IS an MCP server — the only proprietary part is how ChatGPT renders and discovers it.
4 min
OpenAI AgentKit vs LangGraph: Why the Visual Builder Got Deprecated First
OpenAI shipped a drag-and-drop agent canvas in October, then posted its deprecation notice eight months later. The part that survived tells you which layer to build on.
4 min
Online vs Offline Evals for AI Agents: Why Production Traces Need a Different Scorer
Offline evals ask whether the agent matched a known answer. Online evals can't — there is no answer. Treating them as one pipeline with one metric is the mistake that lets agents pass every test and still fail in production.
4 min
MCP Goes Stateless: What Changes in the 2026 Spec Release Candidate
The July 28 release candidate rips out sessions and the initialize handshake, deprecates Sampling and Roots, and adds MCP Apps — the clean break agent developers have to plan for.
5 min
LangGraph Checkpointing vs Temporal: Why Checkpoints Aren't Durable Execution
Most teams assume LangGraph's checkpointer already makes their agents crash-proof. It doesn't — and the gap is architectural, not a missing setting. Here's exactly where it ends and where Temporal begins.
4 min
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