The lab notebook
Field notes on AI engineering
824 articles · page 9 of 28
Make vs n8n for AI Automation
Make and n8n both connect your apps to AI models, but they solve different problems. Here is how to pick the right one based on how your team builds, hosts, and debugs automations.
LLM Observability Tools Compared
A practical comparison of LLM observability tools for tracing, evals, and cost tracking, so you can pick one before your agent breaks in production and nobody can tell why.
Load Testing LLM Applications: A Practical Guide for Engineers
Learn how to load test LLM applications the right way: what breaks under concurrency, how to simulate real traffic, and how to read latency and error metrics that actually matter.
Calibrating an LLM Judge You Can Trust
An uncalibrated LLM judge will lie to you with a straight face. Here is a concrete process for measuring, fixing, and monitoring judge agreement so your evals actually mean something.
LLM Gateways and Model Routing: A Practical Guide for 2026
An LLM gateway is the one piece of infrastructure every production AI team eventually builds or buys. Here is what it actually does, how model routing decisions get made, and how to avoid the mistakes that turn a gateway into a new single point of failure.
LLM Fallback Strategies for Reliability
Rate limits, refusals, timeouts, and outages all take down an LLM call differently, and each one needs its own fallback path. Here is how to build one that actually holds up in production.
The LLM Evaluation Metrics Map
A field guide to every category of llm eval metrics, from exact match to LLM-as-judge, so you stop picking metrics at random and start matching them to the failure mode you actually care about.
LLM Cost Optimization: A Production Engineer's Playbook
A practical, numbers-first playbook for cutting LLM spend without cutting quality: model routing, prompt caching, batching, and the monitoring habits that catch waste before it hits the invoice.
Canary Deployments for LLM Applications
Shipping a new model or prompt straight to 100% of traffic is how you find out about regressions from your users instead of your dashboards. Here's how to run an LLM canary deploy that catches quality drops before they matter.
Semantic Caching for LLM Applications
Cut your LLM bill and latency by caching on meaning instead of exact text, here's how semantic caching actually works and where it breaks.
LangGraph vs the OpenAI Agents SDK
LangGraph and the OpenAI Agents SDK solve the same problem in opposite ways: one gives you a graph you control down to the edge, the other gives you a loop that just works. Here is how to pick.
Testing LangGraph Agents with Pytest
A practical guide to LangGraph testing with pytest: mock LLM calls, unit test nodes and conditional edges, and run full graph invocations without burning API credits.
The LangGraph Swarm Pattern for Multi-Agent Systems
A working engineer's guide to the LangGraph swarm pattern: how peer agents hand off control to each other directly, how it differs from a supervisor graph, and how to build one with runnable code.
How to Deploy with LangGraph Platform: A Complete Walkthrough
A practical guide to taking a LangGraph agent from local development to a running LangGraph Platform deployment, with the exact config files and CLI commands you need.
Parallel Nodes and Fan-Out in LangGraph
Learn how LangGraph parallel execution actually works, from fan-out edges to the Send API, so you stop serializing independent work by accident.
Using MCP Tools in LangGraph
A practical walkthrough of wiring Model Context Protocol servers into a LangGraph agent, from client setup to a working ReAct graph that calls real MCP tools.
Background Jobs and Cron in LangGraph
LangGraph does not ship a scheduler, so here is exactly how to run agent graphs on a timer, queue them behind a worker, and keep long agent runs from blocking your web process.
Tool Calling in LangChain: A Practical Guide for Engineers
Learn how LangChain tool calling actually works under the hood, from defining tools with the @tool decorator to binding them on a model, handling parallel calls, and wiring everything into a LangGraph agent loop.
Streaming Tokens in LangChain
A practical guide to LangChain streaming: how token streaming actually works under the hood, when .stream() isn't enough, and how to wire it into a real backend without dropped chunks.
A Practical Guide to LangChain Expression Language (LCEL)
LangChain LCEL turns chains into composable pipes you can stream, batch, and debug like real software. Here is how it actually works, with runnable code.
Few-Shot vs Zero-Shot Prompting: When Examples Help
Zero-shot prompting is faster to write but few-shot examples fix format drift and edge-case confusion. Here is how to know which one your prompt actually needs, with runnable tests.
Curating an LLM Evaluation Dataset
Most eval failures trace back to a bad dataset, not a bad model. Here is a practical process for building an eval dataset that actually catches regressions.
How to Choose an Embedding Model for RAG in 2026
Choosing an embedding model for RAG comes down to five measurable factors, not vibes. Here is the checklist, the benchmarks that actually matter, and the tradeoffs teams get wrong.
Prompt Optimization with DSPy
Stop hand-tuning prompts by trial and error. DSPy optimization treats your prompt as a compiled artifact, searching for the instructions and few-shot examples that actually move your metric.
Dify vs LangFlow: Choosing an LLM App Builder
Dify and LangFlow both let you build LLM apps visually, but they solve different problems. Here's how to pick the right one for your team, with real setup steps for both.
Deep Agents Explained: Long-Horizon Autonomous Work
Deep agents plan, act, and self-correct across hours or days of work instead of a single prompt-response turn. Here is how they are built, why most agents fail without this structure, and how to build one yourself.
Cursor vs Windsurf vs Cline: A 2026 Comparison
Cursor, Windsurf, and Cline all promise the same thing: an AI pair programmer inside your editor. Here is how they actually differ in daily use, cost, and control.
Context Compression Techniques for Long Prompts
Your context window is not free storage. Here are the compression techniques that actually cut token cost and keep long-running agents coherent, with code you can drop into a pipeline today.
Computer Use Agents: How LLMs Operate a Desktop
A practical walkthrough of how computer use agents see a screen, decide where to click, and run real desktop tasks, with a working code loop you can adapt today.
Coding Agent Cost Comparison: 2026
A working engineer's breakdown of what actually drives coding agent cost in 2026, with real per-token pricing, caching math, and a framework for estimating your own bill before you get surprised by one.