Agentic AI
Agents, tool use, memory, planning, and multi-agent systems: the flagship pillar.
75 articles
claude mcp add: Command Syntax, Scopes & Team Setup
claude mcp add connects Claude Code to any MCP server. The exact command, what project vs user scope controls, and how to share config with your team.
Add an MCP Server to Cursor: Config, Location & Limits
Add an MCP server to Cursor with the exact mcp.json config, file location, the 40-tool limit, and fixes for a server that won't show up.
Advanced Reasoning Frameworks: ToT, GoT, and Reflexion
Tree of Thoughts, Graph of Thoughts, Reflexion, and least-to-most prompting compared, plus when the extra cost is actually worth paying.
What Are Agent Skills? Roles and Capabilities Explained
What are agent skills? Named, triggerable behaviors with clear steps and gotchas. See how skills, roles, and capabilities differ before Module 20.
Agentic Prompting: How AI Agents Act on Your Prompts
Agentic prompting means writing system and tool prompts an AI agent can act on, not just reply to, using ReAct and plan-and-execute patterns.
Agentic RAG: Letting the Agent Decide When to Retrieve
Upgrade a static RAG pipeline into agentic RAG: the agent decides when to retrieve, and a second hop fixes what one hop misses.
How AI Agents Work: The Think-Act-Observe Loop
How do AI agents work? Four parts in a loop, environment, tools, a brain, and think-act-observe, dissected using the Claude Code you already run.
Automatic Prompt Optimization: Stop Hand-Tuning Prompts
Automatic prompt optimization uses eval scores, not guesswork, to improve prompts. Learn how APE and DSPy find better wording than tuning by hand.
AI Agent Autonomy Levels: The Full Spectrum, Explained
AI agent autonomy runs on a spectrum, not a switch, from scripted automation to fully autonomous. Here's how to pick the right level for the stakes.
How to Build a RAG Pipeline in Cursor
Learn how to build a RAG pipeline in Cursor: ingest, chunk, embed with Voyage AI, retrieve, and generate with Claude, shipped behind a CLI.
How to Build an MCP Client in Python (Step by Step)
Build an MCP client in Python from scratch: connect to your FastMCP server, discover its tools, call one, and check for is_error correctly.
Build an MCP Server with FastMCP: A Hands-On Guide
Build a real FastMCP server with tools, a resource, and a prompt, then connect it to Claude Code end to end in this hands-on Python MCP walkthrough.
Build a Claude Code Plugin: Package and Publish It
Build a Claude Code plugin step by step: the plugin.json manifest, correct file structure, and publishing your own marketplace.json.
Calling External APIs from an AI Agent: A Build Log
Watch an agent hit a real API's pagination gap and a live rate limit, then fix both with working retry and backoff code.
Chain of Thought for AI Agents: Reasoning Picks the Tool
Chain of thought prompting works differently in an agent: it picks the next tool, not just the final answer. See where it helps, where it wastes tokens.
Chatbot vs AI Agent: What's Actually the Difference?
A chatbot answers your question and stops. An AI agent takes your goal and acts until it's done. Here's the clearest beginner explanation of both.
How to Use Claude Code: Your First Autonomous Loop
How to use Claude Code as an agentic terminal: watch a real autonomous loop, understand permission prompts, and write your first CLAUDE.md.
Why So Many Builders Run Claude Code Inside Cursor
Developers install Claude Code inside Cursor because it splits one job in half: Cursor edits live, Claude Code works autonomously in the background.
Claude Code Subagents: Isolate Context, Not Delegate
A Claude Code subagent runs in its own context window and returns only a summary, keeping noisy research from bloating your main thread. Here's how it works.
Claude Code vs Cursor: A Beginner's Decision Guide
Claude Code and Cursor aren't rivals, they're peer environments. Install Claude Code, run your first terminal session, and learn when to use each.
The CLAUDE.md Hierarchy: Scopes, @import, and Rules
The CLAUDE.md hierarchy loads files by scope: managed policy, user, project, local, all concatenated, and @import shares one standards file across scopes.
Code Execution with MCP: Cut Token Costs Nearly 98%
Code execution with MCP turns servers into code modules an agent explores on demand. Learn how it cut a real workflow from 150,000 tokens to just 2,000.
CodeAct vs Tool Calling: When Agents Should Write Code
CodeAct lets agents write and run code instead of JSON tool calls, cutting round-trips but adding sandbox risk. Here's how to choose.
Best AI Coding Agents in 2026: A Full Comparison
See how the best AI coding agents of 2026, Cursor, Claude Code, Codex, and more, actually compare, and why the harness now decides which one wins.
Context Compaction: When to Use /compact and /summarize
Context compaction summarizes old turns before quality drops. Learn the 70% self-trigger rule and how to run /compact and /summarize yourself.
Cursor @ Context: How to Feed the Model the Right Code
Learn how Cursor's @-mentions and codebase indexing work, and why any answer's quality is bounded by the context you deliberately choose to give it.
Context Engineering, Part 2: Production Memory Systems
AI agents lose track of earlier context long before their window is full. Here's how compaction, tool clearing, and memory tools solve it in production.
Context Rot: Why More Context Can Mean Worse Answers
Context rot is the research-backed drop in LLM accuracy as input grows, even when nothing relevant is missing. Here's the data, and why it happens.
Cursor Agent Mode vs Ask Mode: A Risk-Dial Guide
Cursor agent mode vs ask mode: they're risk dials, not buttons. Learn which to reach for, plus Tab and Cmd-K for fast, low-risk edits.
Cursor Rules and AGENTS.md: Portable Agent Memory
Cursor rules live in .cursor/rules/, but AGENTS.md is the open standard many agents read. Here's how to write both so memory travels with you.
Database and Vector-Store Memory: When Files Aren't Enough
Long-term memory for AI agents means storing facts in a file, database, or vector store, picked by query type. Here's how to choose and build it.
Decision Journaling: Why Your Agent Needs a Decisions.md
A decision log records what you chose, why, and what you rejected, so neither you nor your agent re-argues a settled call. Here's how to build one.
Deploy a Remote MCP Server: stdio to Streamable HTTP
Deploy your MCP server remotely over Streamable HTTP, host it somewhere always-on, and validate every tool with the MCP Inspector before trusting it.
How to Design Tools for AI Agents (Without Guessing)
How to design tools for AI agents: clear names, tight schemas, and descriptions that stop your agent from picking the wrong tool. A hands-on guide.
Embeddings, Vector Stores, and Why RAG Works
Embeddings turn text into searchable vectors; a vector store retrieves the closest ones for RAG. Learn when retrieval beats a bigger context window.
Best Claude Code Plugins Worth Installing in 2026
The three Claude Code plugins worth installing in 2026: Superpowers, frontend-design, and graphify, tested hands-on with real before/after results.
Evaluating Retrieval in RAG: Precision@k Explained
Evaluate RAG retrieval with precision@k, context relevance, and faithfulness, build a gold-labeled eval set and fix your worst-scoring query.
Claude Code Hooks: Deterministic Control Over Agents
Claude Code hooks run as code, not prompts. A PreToolUse hook can block a tool call before it runs, every time, unlike a CLAUDE.md instruction.
How Does Tool Calling Work: The tool_use Loop Explained
How does tool calling work? The model stops mid-turn, emits a tool_use block naming a tool and its input, and your code runs it and returns a tool_result.
How to Install Cursor AI Editor: Setup and First Tour
Learn how to install Cursor AI editor step by step, import your VS Code settings, and use the model picker with real confidence.
Just-in-Time vs Pre-Loaded Context: A Decision Framework
Choosing between just-in-time and pre-loaded context for AI agents comes down to latency, cost, and relevance. Here's how to decide.
MCP Architecture: How Host, Client, and Server Work
MCP architecture has three roles, host, client, server, talking over JSON-RPC. Here's how a real request actually flows, traced hop by hop from start to finish.
MCP Authorization: OAuth 2.1 and PKCE, Hands-On
Add real OAuth 2.1 and PKCE to a deployed MCP server, then prove an unauthenticated call gets rejected. A hands-on walkthrough, not just theory.
MCP Security: Tool Poisoning, Rug Pulls, and Trust
MCP security means treating every server as untrusted code. Learn tool poisoning, rug pulls, cross-server shadowing, and audit one yourself.
MCP Tools, Resources, and Prompts: The Control Split
MCP servers expose three primitives: tools, resources, and prompts. Here's what each one is and why the control split behind them actually matters.
MemGPT & Letta: Self-Editing Memory and Sleep-Time Compute
MemGPT (now Letta) gives agents self-editing, tiered memory, and sleep-time compute lets them reorganize it while idle. Build a minimal version.
What Is CLAUDE.md? Claude Code's Memory File, Explained
CLAUDE.md is the markdown file Claude Code reads every session, here's what belongs in it, why bloat backfires, and how to keep it lean.
Multi-Agent Prompting and Orchestration, Explained Clearly
Multi-agent orchestration coordinates specialized AI agents through supervisor and worker roles, hand-offs, and debate to solve tasks one agent can't.
Notes & Tool-Result Pruning for Agent Context Management
Agent context management is choosing what tokens stay visible as a task runs: write durable notes to a file, then prune tool output once it's been used.
Plan-and-Execute: Why AI Agents Plan Before Acting
Plan-and-execute separates an agent's planning from its execution, catching costly mistakes before any code runs. Here's how it maps to Plan mode.
Claude Code Plugin Safety: How to Audit Before Install
Claude Code plugins run arbitrary code with your permissions. Here's what to check in a plugin's hooks and commands before you install.
Claude Progress File: The Shift Log That Resumes Sessions
A claude progress file is a done/in-progress/next/blockers log an agent updates, so a fresh session resumes cleanly instead of re-deriving state.
What Is an Agentic Workflow? Prompting vs the Loop
What is an agentic workflow? It's a loop: the model plans, acts, reads the actual result, and decides its next step, instead of answering once.
Querying Databases From an Agent, the Read-Only Way
Let an AI agent query your database safely: a read-only role the database enforces itself, so a bad prompt can't turn into a bad write.
ReAct Agent Pattern Explained: Build the Loop Yourself
ReAct interleaves reasoning and tool calls through the tool_use stop reason. Build the raw loop yourself and see exactly what LangChain automates.
Reasoning Models & Test-Time Compute: When to Spend
Test-time compute lets reasoning models think longer before answering, but longer isn't always smarter; it pays off on hard tasks, not easy ones.
Agent Reflection Pattern: Why Grounded Beats Intrinsic
Learn the agent reflection pattern (Self-Refine, Reflexion) and why grounded self-correction works while intrinsic self-checking often fails.
Safety-First Defaults: How to Safely Use AI Coding Agents
Learn how to safely use AI coding agents with branch-only workflows, permission modes, and a trust-then-verify diff habit.
Claude Code Skills: How to Write One That Triggers
Claude Code skills only work if they trigger. Learn description-as-trigger writing, progressive disclosure, and the gotchas that cause silent misfires.
Claude Code Slash Commands: Built-In & Custom Guide
Claude Code slash commands are saved prompts run with /name. Learn the built-ins like /clear and /compact, then build custom ones with $ARGUMENTS.
Spec-Driven Development: Specs That Steer Your AI Agent
Spec-driven development turns a vague feature request into a versioned spec an AI coding agent builds from, catching ambiguity before code does.
Structured Outputs LLM: Pydantic, Zod & Validation
Structured outputs force an LLM to emit a schema-validated object instead of free text, so malformed data fails loudly instead of breaking your pipeline.
The Augmented LLM: The Building Block of AI Agents
An augmented LLM is a plain LLM plus retrieval, tools, and memory, the primitive Anthropic says every AI agent is built from.
The Agent Self-Improvement Loop: Evaluate, Then Fix
The agent self-improvement loop is plan, execute, evaluate against one number, then refine. Learn why skipping the metric turns improve into just change.
Claude Code Extensibility: The Full Stack, Mapped
Claude Code can be extended seven ways: CLAUDE.md, skills, hooks, subagents, MCP, and more. One rule of thumb tells you which primitive fits.
Claude Code Plugins: The Marketplace Commands That Work
The exact /plugin marketplace add and /plugin install commands for Claude Code, plus the name-collision qualifier most tutorials skip.
Why Do AI Agents Forget? The Statelessness Problem
AI agents forget everything between sessions because LLMs are stateless: here's why, and what actually has to change to fix it.
Best MCP Servers to Use (and How to Vet One First)
The best MCP servers to install first, filesystem, GitHub, Postgres, Slack, and the exact checks to run before you trust any third-party one.
What Changed in Agentic AI in 2026: A Builder's Guide
Agentic AI in 2026: protocols like MCP and A2A stabilized, coding agents went autonomous, and memory became its own field. Here's what changed.
What Is an AI Agent, Really? A Workflow-vs-Agent Test
A workflow runs code you wrote in advance, an agent decides its next move after seeing a result. Here's Anthropic's exact test, applied to real examples.
How to Build AI Agents: What This Course Assumes First
This how to build ai agents course teaches you to build real agents inside Cursor and Claude Code, not a notebook, from zero to four shipped capstones.
When Not to Use AI Agents (And What to Build Instead)
When not to use AI agents comes down to one question: is there a real decision to make mid-task? Here's the full test, with five real scenarios.
Why MCP Exists: Solving AI's N×M Integration Problem
MCP solves AI's N×M integration problem: one protocol instead of a custom connector per tool per model. Here's why every major lab adopted it.
Why Your AI Agent Won't Stop Looping (and the Fix)
Your AI agent won't stop looping because of one of three bugs: thrashing, no stop condition, or context bloat. Build, break, and fix a real loop here.
Your First AI Agent: A Real Delegated Task, Felt Not Coded
Delegate a real multi-step task to Claude Code and learn to read what your first AI agent actually did, why it worked, and where it corrected itself.