Categories › Agent Engineering
Agent Engineering
Harnesses, context engineering, MCP tool servers, agent evals, and the security work that gets agents past prototype.
Agent = model + harness. These posts cover the runtime around the model: what it sees (context engineering), what it may do (permissions, budgets, approval gates), how it reaches tools (MCP), how you know it works (trajectory evals), and how you keep it from being turned against you (prompt injection containment). Plus coding agents as a daily workflow.
32 posts, from beginner to advanced. Each ends with what to read next.
Agentic Coding: Working With Claude Code, Codex, and Cursor
Coding agents are now the default way software gets written. Learn the gather-act-verify loop, how to write CLAUDE.md and AGENTS.md files that actually steer an agent, when to use skills and subagents, and how to review agent output like a senior engineer.
Context Engineering: Designing What the Model Sees
The context window is a budget, and everything competes for it: the system prompt, the tool list, retrieved documents, memory, and the conversation so far. Learn to design the context deliberately, scope tools per task, compact without losing what matters, and treat cache hit rate as the metric it has become.
Harness Engineering: The Runtime Around the Model
Agent = model + harness. The harness is the deterministic runtime that validates, authorizes, executes, and logs every action the model proposes. Learn its five layers, build one from scratch, and adopt the loop that turns every agent failure into a permanent fix.
MCP and Agent Protocols: Building and Consuming Tool Servers
The Model Context Protocol is how agents connect to tools, data, and prompts, and every major provider supports it. Build an MCP server in Python, design tools a model will use correctly, connect it to a coding agent, and learn where A2A and the other agent protocols fit.
Reasoning Models, Post-Training, and Test-Time Compute
Where reasoning models come from, what they cost, and when to pay for them. The SFT to DPO to GRPO pipeline, reinforcement learning with verifiable rewards, test-time compute as a dial, and a method for deciding which of your requests deserve a thinking model.
Agent Evals: Trajectories, Tool Calls, and Regression Suites
An agent produces a trajectory, not an answer, and grading only the final answer misses looping, wrong tools, and failure to recover. Build a task suite from real failures, grade tool-call correctness programmatically, validate an LLM judge, and wire it all into CI as a regression gate.
AI Security for Agents: Prompt Injection, Excessive Agency, and Sandboxing
Prompt injection is structurally unsolved, and agents turned it from an embarrassment into a breach. Learn the OWASP agentic risk categories, why detection fails, and the containment architecture that works: least-privilege tools, approval gates, sandboxes, provenance, and a red-team practice you run against your own harness.
Agentic Coding Tools for Students
Coding agents will write a lot of your code from now on. The question is whether you learn from that or hide behind it. This module teaches how to use Claude Code, Codex, and Cursor to learn faster, verify everything, and build the habits employers now expect.
Context and Harness Engineering
Two disciplines that decide whether an agent works: designing what the model sees (context engineering) and building the runtime that validates what it does (harness engineering). Learn the context budget, per-task tool scoping, memory write policies, and a minimal harness with permissions, budgets, verification, and traces.
MCP: Building a Tool Server
The Model Context Protocol is the standard way to give agents access to tools and data. Build a server in Python, connect it to a coding agent and to your own harness, write tool descriptions a model will use correctly, and evaluate whether it does.
Agent Evals and AI Security
How do you know an agent works, and how do you keep it from being turned against you? Trajectory grading, task suites built from failures, validated judges, CI regression gates, and the containment architecture for prompt injection: least privilege, approval gates, sandboxes, and a red-team practice you run yourself.
What Is Harness Engineering? Agent = Model + Harness
Harness engineering is the discipline of building the runtime around a language model that turns it into a reliable agent. Here is what the harness owns, why most agent projects fail without one, and a worked incident that shows the fix living in the harness, not the prompt.
Context Engineering vs Prompt Engineering: What Changed
Prompt engineering optimized the instruction. Context engineering optimizes everything the model sees: tools, retrieval, memory, history, and tool results, under a token budget. Here is why the discipline changed names, what it optimizes for now, and a before-and-after on a real agent.
Building Your First MCP Server in Python
A step-by-step tutorial: build a Model Context Protocol server with the Python SDK, test it with the inspector, connect it to Claude Code, harden it, and write descriptions a model will actually use correctly. Working code throughout.
MCP vs A2A: Which Agent Protocol Do You Need?
MCP connects an agent to tools. A2A connects agents to each other. Most teams need the first and reach for the second too early. A decision guide with the architecture each one implies, the cases where you need both, and the protocols you can safely ignore for now.
Prompt Injection: Why It's Unsolved and How to Contain It
Prompt injection is content the model reads that redirects what it does, and no filter catches it reliably. Here is the mechanism, a taxonomy of attacks with real-shaped examples, why detection fails, and the containment architecture that makes a successful injection boring instead of a breach.
OWASP Top 10 for Agentic Applications, Explained for Engineers
OWASP published a Top 10 for agentic AI applications, and it is the checklist security reviewers will use on your agent. Here is each risk category as an engineer meets it: the concrete failure, the harness layer that owns it, and the control that closes it.
Evaluating AI Agents: Final Answer vs Trajectory vs Per-Turn
Grading an agent on its final answer misses the failures that matter: wrong tools, loops, and failure to recover. Here are the three layers of agent evaluation, what each catches, working code for mechanical trajectory checks, and how to turn the whole thing into a CI gate.
τ-bench and SWE-bench: What Agent Benchmarks Actually Measure
Agent benchmark numbers are everywhere in model announcements. Here is what τ-bench and SWE-bench actually test, what pass^k means, why the numbers saturate and get gamed, and how to read a benchmark result without being misled about your own system.
GRPO, DPO, and RLVR: Post-Training Explained Without the Notation
Three acronyms show up in every reasoning-model paper. Here is what each one does, why GRPO replaced PPO for most teams, what a verifiable reward is and why it is the whole constraint, and short runnable code for each idea.
Reasoning Models and Test-Time Compute: When to Pay for Thinking
Reasoning models trade tokens for accuracy, and every request is a decision about whether that trade is worth it. Here is what test-time compute is, why its returns diminish, a four-setting method to find the knee for your workload, and the routing rule that keeps the bill sane.
Agent Memory: Working, Episodic, and Long-Term, and Why Compaction Is Lossy
"Give the agent memory" hides three different stores with three different write policies, and conflating them is how one bad run poisons every future one. Here is the taxonomy, the policies, and how to compact a full context without the agent forgetting the deadline.
Durable Execution for Agents: Checkpointing, Resume, and Human-in-the-Loop
A five-step agent that crashes at step four should resume at step four, not start over. Here is what durable execution means for agents, two ways to get it (graph checkpointing and workflow engines), and why a human approval should be a saved state rather than a blocking prompt.
Prompt Caching: The New Optimization Target
Providers cache the prefix of your prompt and bill cached tokens at a steep discount, which turns prompt layout into a cost decision. Here is how caching works, how to structure prompts for it, the mistakes that silently bust the cache, and why cache hit rate belongs on your dashboard.
Writing CLAUDE.md and AGENTS.md Files That Actually Work
Coding agents read a context file before they touch your repository, and that file is the highest-leverage artifact in agentic development. Here is what belongs in it, what does not, a template, and the maintenance loop that turns every agent mistake into a permanent rule.
Multi-Agent Systems: When They Help and When They Don't
A team of specialized agents is the architecture everyone draws first and most teams should draw last. Here is what multi-agent actually costs, the three cases where it earns its place, the subagent pattern that gets most of the benefit without the coordination, and how to tell which one you need.
Computer-Use and Voice Agents: How They Work
Two kinds of agent broke out of the text box: computer-use agents that operate a screen with a mouse and keyboard, and voice agents that hold a real-time spoken conversation. Here is how each works, where they are fragile, and what the harness has to do differently for them.
LLM Observability: Logging, Tracing, and Eval in Production
You cannot improve what you cannot measure. This post covers the observability stack for LLM applications: what to log, how to trace multi-step flows, and how to wire up continuous evaluation.
Agentic AI Workflows: Patterns and Pitfalls
Agents that use tools, plan, and take multi-step actions are powerful and fragile. This post covers the core patterns, the failure modes to design around, and what production-ready agents actually look like.
Agents, Tool Use, and Workflow Orchestration
Teach where agents are useful, where they are overhyped, and how to build constrained workflows responsibly.
Agents, Tools, and Workflow Graphs
Teach how to go beyond simple chat features without getting captured by hype.
Tool-Using Agents and Guardrails
Design agent systems with clear tool boundaries, safety checks, and fallback behavior.