Loading…
Folarin Akinloye is an AI Engineer based in London, UK. He builds production-ready agentic AI systems, multi-agent architectures, and sophisticated RAG implementations, and writes about the engineering decisions behind them.
Articles by Folarin
- When Building Gets Cheap, Judgment Gets ExpensiveEight moves for shaping an AI product before the first line of code.
- A Skill Is a Dependency That Runs CodeAn Agent Skill is not a prompt template. It carries injectable instructions and executable scripts, so treat it like any package you install.
- Skills vs MCP vs Tools vs Subagents: Stop Conflating ThemFour different answers to "extend the agent," each solving a different problem. They stack, they do not compete.
- What Agent Skills Are, and Why Progressive Disclosure Changes the MathA skill is a folder of know-how an agent loads only when a task needs it. The mechanism underneath is the whole point.
- Designing UX for a Confidently-Wrong InternTraditional UX assumes the system is correct and fast. An AI feature is neither guaranteed. Design for that.
- The Reference Architecture for a Production AI AppThe model call is one box out of ten. The other nine are the engineering.
- Who Owns Quality: The Benevolent Dictator and AI Incident ResponseOn an AI product, quality is a judgment call that needs one owner, and an incident whose postmortem output is a new eval example
- Detect, Contain, Monitor: The Risks That Sink AI ProductsYou do not eliminate AI-product risk. You bound the blast radius and watch the rate.
- The Unit Economics of an AI ProductEvery request costs real money. Why the unit is cost per task, not per call, and how to keep it profitable.
- LLMOps and the Data FlywheelLaunch is the start of the work. How you operate an AI product, and how production usage compounds into a moat.
- Ship on Containment, Not PerfectionHow to expose a non-deterministic feature to real users safely, without waiting for a flawlessness that never comes
- Treat the Model as a Flaky, Expensive DependencyThe vendor changes pricing, retires models, and swaps tokenizers under your live product. Wrap it accordingly.
- Does Your Problem Even Need an LLM?The fit gate to run before you build, and what to do when the answer is no
- Evals Are the Product Discipline (and Writing Them First Backfires)Why eval-driven development done like TDD fails, and what error-analysis-first evaluation looks like instead
- AI Is Not a MoatThe model is electricity, not the factory. What actually makes an AI product defensible.
- The Afternoon and the QuarterWhy an AI demo takes an afternoon and an AI product takes a quarter, and what lives in the gap
- How to Evaluate Agents Locally with Arize PhoenixTrace and judge your agent on your own machine, no hosted service required
- What Is AgentOps? Operating AI Agents in ProductionHow MLOps and LLMOps extend to autonomous, multi-step agents
- What Is OpenTelemetry, and Why It Matters for Agent ObservabilityThe vendor-neutral standard your agent traces should be built on
- Tracing in Agent Observability: What It Is and Why It MattersTraces, spans, and why a readable trace is the fastest way to debug a misbehaving agent
- What the Research Actually Says About Prompting ReasoningThe taxonomy of reasoning elicitation, and the uncomfortable retrieval-vs-reasoning debate every agent builder should sit with
- A Field Guide to Model-Specific PromptingHow prompting actually differs across Claude, GPT, Gemini, Llama, and Mistral, and what transfers
- A Real Prompt Engineering Case Study: 65.6 to 91.7 F1 on Job ClassificationWhat a production classification system teaches about which prompt tweaks actually move the needle
- Prompt Functions: Treating Prompts as Reusable FunctionsA 2023 chat trick that quietly became how we build LLM systems
- Generating Code with Prompts: The Fundamentals Still MatterComments to code, SQL from schemas, and the verification habit that separates working code from plausible code
- Dataset Diversity: Fixing Repetitive Synthetic GenerationsWhy your generated dataset all sounds the same, and the seeding trick that fixes it
- Building Agents That Actually WorkThe practical habits that separate a reliable agent from a flaky demo: simpler workflows, better information flow, and a debugging ladder
- Generating a Synthetic Dataset for RAGUse a big model to train a small retriever, for about $55 instead of a month of labeling
- Generating Synthetic Data with PromptsTurn a model into a data factory for tests, evals, and cold-start training, without spending a month labeling
- Bias in Prompting: How Your Prompt Design Skews the ModelThe distribution and order of your few-shot examples can quietly bias the model. Here is how to test for it.
- Factuality: Prompting to Reduce HallucinationThree prompt-level moves that cut made-up answers, and where prompting stops being enough
- Adversarial Prompting: Injection, Leaking, and JailbreakingThe three attacks that break LLM apps, and the defences that actually hold up
- Graph Prompting, ExplainedWhat it means to prompt a model with nodes and edges, and when it actually helps
- CodeAgent vs ToolCallingAgent: Two Ways to Let an Agent ActThe difference between an agent that writes Python and one that emits JSON, with strengths, limits, use cases, and when to pick each
- Prompting Reasoning Models Is Almost the Opposite of Prompting Chat ModelsWhy the step-by-step prompts you learned in this series can hurt an o3 or Claude with thinking on
- Multimodal Chain-of-Thought: Reason Over the Picture, Then AnswerA two-stage framework that generates a rationale from text and image first, then infers the answer from that rationale
- PAL: Let the Model Reason in Words, but Let Python Do the MathProgram-Aided Language Models offload the actual computation to an interpreter, so arithmetic bugs stop wrecking your reasoning
- Directional Stimulus Prompting: Train a Tiny Model to Whisper Hints to a Big OneA small tuneable policy model generates hints that steer a frozen black-box LLM, no access to its weights required
- Active-Prompt: Stop Guessing Which Few-Shot Examples to AnnotateUse the model's own uncertainty to pick which questions are worth a human-written reasoning chain
- ART: Let the Model Write Its Own Tool-Using ReasoningAutomatic Reasoning and Tool-use, and why it reads like an early sketch of the agents we build today
- Generated-Knowledge Prompting: Surface Facts Before You AnswerHave the model write down what it knows first, then answer using that as context
- Self-Consistency: Sampling Your Way to Better AnswersRun the same reasoning prompt several times, then take the majority answer
- Chain-of-Thought PromptingStandard and zero-shot CoT, when step-by-step reasoning actually helps, and what it costs
- Zero-Shot vs Few-Shot PromptingWhen examples help, how many to use, how to pick them, and where few-shot quietly breaks down
- The Anatomy of a Good PromptInstruction, context, input, and output indicator, plus the design habits that make them work
- The Settings That Change Your OutputTemperature, top_p, max tokens, stop sequences, and the penalties, and when to touch each
- The Agent Loop: Building ReAct From ScratchReason, act, observe, repeat. The whole engine is about 20 lines, and one counting rule explains all of it.
- Git Worktrees Are Having a Moment Because of AI AgentsWorktrees have existed since 2015. They got popular in 2026 because we stopped working one branch at a time.
- @Claude in Your Slack: What Claude Tag Actually ChangesAnthropic put an agent in the channel where the work already happens. Here is why that matters more than the model behind it.
- Monitoring Model Deprecation in ProductionThe model you pinned will be switched off one day, probably with less notice than you would like. Here is how to find out from CI instead of from your users.
- Observability for LLM Apps: What to Log, What to Alert OnYour 500s and latency graphs will look fine while the product quietly gives wrong answers. LLM observability is about catching the failures that do not throw.
- Graph, State Machine, or Plain Loop: How to Structure an AgentMost agents start as a while loop and should stay that way. Here is how to know when you have actually outgrown it.
- Caching Agent Tool Calls (Not Just Prompts)Prompt caching saves you tokens. Caching tool calls saves you the slow, flaky, expensive thing the tool actually does.
- Building a Multi-Tenant RAG System: Isolation, Per-Tenant Indexes, and the Leaks Nobody Plans ForThe day one customer retrieves another customer's documents, it is over. Here is how to make sure that never happens.
- Streaming Tool Calls and Partial Outputs in LangGraphToken streaming is the easy part. Streaming what a tool is doing, mid-call, is what makes an agent feel alive.
- Five Projects to Actually Master AI Engineering (for Experienced Engineers)Skip the toy chatbots. Build the five systems that teach the hard parts: retrieval, agents, evals, cost, and reliability.
- Human-in-the-Loop in DeepAgents: Approve Before It ActsWhy some tool calls need a person, and how to gate them with interruptOn, decisions, and a checkpointer
- Why Skills Matter When You Build an AgentProgressive disclosure, the three load levels, and how to write a SKILL.md the agent actually activates
- Memory in DeepAgents: How Agents Learn Across ConversationsFilesystem-backed memory, user versus agent scope, and background consolidation, with the TypeScript to wire each one
- Subagents in DeepAgents: Delegation That Keeps Context CleanHow the task tool works, when to delegate, and the config that decides whether subagents help or hurt
- Context Engineering in DeepAgents, From the InsideWhat goes into a deep agent's context, what the framework manages for you, and the knobs you actually control
- Prompt Caching for LLM Apps: What It Is and When It Pays OffHow providers cache your prompt prefix, the real discounts, and the prompt structure that decides whether you save anything
- LangGraph State, Checkpointing, and Persistence ExplainedHow a graph remembers: state channels, checkpointers, threads, and the time travel you get for free
- Cutting LLM Cost and Latency Without Wrecking QualityMeasure first, then reach for caching, routing, smaller models, and the structural fixes that actually move the numbers
- Guardrails and Safety for Agents in ProductionDefense in depth for agents: input rails, output checks, tool limits, and the injection problem that will not fully go away
- Streaming LLM Responses End to End: Backend to UIWhy SSE won, how the token stream flows from the provider to the browser, and where it breaks
- How I Learn to Build Production AI Systems by Dissecting Open SourceThere are no good production-grade courses, so I turn the codebases real teams run into my curriculum
- Inside Vercel's Eve: A Deep Technical Walkthrough, with a Research AgentWhat Eve is, every capability that matters, a full TypeScript research agent, and how it compares to LangChain's Deep Agents
- Agent Memory: Short-Term vs Long-Term, and How to Wire It UpThreads are short-term memory. Stores are long-term memory. Most agent memory bugs come from confusing the two.
- Structured Outputs and Function Calling, In DepthHow to make an LLM return data that always fits your schema, and how function calling is the same idea wearing a different hat
- Choosing a Vector Database in 2026: pgvector vs Pinecone vs Qdrant vs WeaviateMost teams should start with pgvector and only move when they have a real reason. Here is how to know when that day comes.
- Embeddings Explained for EngineersWhat embeddings really are, why cosine similarity works, and how to pick a model without trusting a leaderboard blindly
- Reranking in RAG: Cross-Encoders and When They Are Worth the LatencyA reranker can rescue a mediocre retriever or waste 200ms on an already-correct answer. Knowing which is the whole skill.
- Chunking Strategies for RAG: Fixed, Recursive, Semantic, and How to ChooseWhy recursive splitting is the right default, and the few cases where you should reach for something fancier
- Deep Agents by LangChain: A Deep Dive, with a Customer Support AgentWhy Deep Agents exists, what it gives you out of the box, and a full support agent you could actually ship
- Evaluating Agents with LangSmith: A Complete GuideWhy "it worked when I tried it" is not evaluation, and how to measure agents properly with tracing, datasets, evaluators, and experiments
- Building MCP Servers with FastMCP: A Practical GuideThe anatomy of a server, the rules that matter, stdio vs remote, the pitfalls I hit, and how to test and ship it
- Giving Agents Tools: Function Calling and MCP, ExplainedHow agents actually do things, how to design tools they use well, and where MCP fits
- Agentic RAG, and How It Differs from Traditional RAGWhen retrieval stops being a fixed step and becomes something the agent decides
- What Are AI Agents, and What Is a Multi-Agent System?A plain-English tour of agents, why people wire several together, and how to build one in Python