# Agentic Engineering 101

> Learn to direct AI coding agents through real software work: plan the change, verify the result, and build a control panel for your agent runs.

Agentic Engineering 101 is a reference guide to agentic engineering, from first principles to production. Agentic engineering is directing AI coding agents through real software work while a human keeps control of technical decisions and verifies the results. Each page stands on its own, so you can read the guide front to back or go straight to the topic you need. Foundations covers what agents are and why they fail, Practices covers planning, prompting, and verification, Components and Control explain the parts of an agent system, and Execution covers running agents in production. A bonus Final Project puts the guide into practice: you build a local control panel for defining agent pipelines, running them, and reviewing the results.

## Foundations

- [Preview: The Final Project](https://agenticengineering101.com/preview/): See the local control panel you build in the Final Project, a place to define agent pipelines, track their runs, and review the results.
- [What Is Agentic Engineering?](https://agenticengineering101.com/what-is-agentic-engineering/): Agentic engineering is directing AI agents to write and test code while you guide technical decisions and verify the results against your requirements.
- [Why AI Agents Hallucinate](https://agenticengineering101.com/hallucinations/): Why language models give confident, false answers, what a 2025 OpenAI paper says causes them, and why they matter once an agent acts on your code.
- [First Principles Thinking For AI Agents](https://agenticengineering101.com/first-principles-thinking/): How to tell a fluent answer from a correct one: reduce each input to a verified source before you let an AI agent build on it.

## Practices

- [Robust Planning For AI Coding Agents](https://agenticengineering101.com/robust-planning/): Plan before the agent builds: define behavior you can check, investigate the code that matters, try the uncertain part, and write a plan others can follow.
- [Bidirectional Prompting With AI Agents](https://agenticengineering101.com/bidirectional-prompting/): Sharpen a plan by questioning the agent's assumptions and letting it question yours. Answer the decision behind each question and keep the result.
- [Agent Workflows And Pipelines](https://agenticengineering101.com/workflows-pipelines/): Turn agent work into a repeatable workflow, then a pipeline: follow a bug from report to review, make each handoff useful, and check before advancing.
- [Testing And Verifying AI Agent Work](https://agenticengineering101.com/testing-and-verification/): Connect an agent's claim of completion to evidence: write the expected behavior first, exercise the real user path, and check that tests catch mistakes.
- [Automating Agent Workflows Safely](https://agenticengineering101.com/automation/): Let a workflow run without you: choose a small first boundary, keep progress outside the conversation, bound the repair loop, and test failure behavior.

## Components

- [What Is An AI Agent? Model, Tools, Loop](https://agenticengineering101.com/agents/): An AI agent combines a language model with instructions, tools, and a loop that acts on results. How the model and the runner divide the work.
- [Language Models Inside AI Agents](https://agenticengineering101.com/models/): The model is the generative core of an agent. It holds no state between calls, its output is probabilistic, and capability does not guarantee reliability.
- [Agent Tools: Files, Commands, Services](https://agenticengineering101.com/tools/): Tools connect a model to files, commands, browsers, and external services. Give each tool a narrow operation, useful evidence, and a clear boundary.
- [The Context Window In AI Agents](https://agenticengineering101.com/context-window/): What a model's context window holds, why capacity and usage measure different things, and why a longer context can make a model less reliable.
- [Agent Memory Across Sessions](https://agenticengineering101.com/memory/): How agents keep information beyond one session: store decisions with their basis, retrieve only what the task needs, and keep that memory current.
- [Agent Environments And Permissions](https://agenticengineering101.com/environments/): An agent's environment decides what it can read, change, or run. Make the starting state explicit, separate concurrent work, and classify failures.

## Control

- [Repository Instructions For AI Agents](https://agenticengineering101.com/instructions/): Repository instruction files give agents persistent guidance about a project. Keep them short and actionable, and enforce the critical rules in code.
- [Git And Version Control With AI Agents](https://agenticengineering101.com/version-control/): Git records changes outside the agent conversation. Inspect before editing, separate concurrent tasks, commit deliberately, and recover without data loss.
- [Slash Commands In Agent Tools](https://agenticengineering101.com/commands/): Slash commands control an agent session or run reusable prompts and skills. What they do, how names vary by tool, and why execution should stay explicit.
- [Context Management For AI Agents](https://agenticengineering101.com/context-management/): Keep the current task, evidence, and open decisions in front of the model. Decide what must survive and write a selective handoff for the next session.
- [Agent Hooks: Checks At Session Events](https://agenticengineering101.com/hooks/): A hook runs at a defined event in an agent session or workflow. Put the check near the action, keep its contract small, and test the boundary.

## Execution

- [Pipelining: Splitting Work Into Changes](https://agenticengineering101.com/pipelining/): Divide a design into changes with observable results. Build in dependency order, carry the architecture into each task, and keep acceptance criteria fixed.
- [Ralph Loops: Fresh-Context Agent Runs](https://agenticengineering101.com/ralph-loops/): A Ralph loop restarts an agent on a task with a fresh context while progress lives outside the conversation. Carry forward useful state and stop bad loops.
- [Gates: When An Agent Workflow Advances](https://agenticengineering101.com/gates/): A gate decides whether a workflow may advance. Match it to the question, record an auditable result, and handle missing evidence explicitly.
- [Evaluating AI Agents On Real Tasks](https://agenticengineering101.com/evaluation/): Compare models and agent workflows on the same representative tasks. Score correctness and omissions, time and cost, and the human effort to finish.

## Exercises

- [Exercise #0](https://agenticengineering101.com/robust-planning/#exercise-0): hands-on exercise on the Robust Planning page
- [Exercise #1](https://agenticengineering101.com/bidirectional-prompting/#exercise-1): hands-on exercise on the Bidirectional Prompting page
- [Exercise #2](https://agenticengineering101.com/testing-and-verification/#exercise-2): hands-on exercise on the Testing And Verification page
- [Exercise #3](https://agenticengineering101.com/models/#exercise-3): hands-on exercise on the Models page
- [Exercise #4](https://agenticengineering101.com/context-window/#exercise-4): hands-on exercise on the Context Window page
- [Exercise #5](https://agenticengineering101.com/memory/#exercise-5): hands-on exercise on the Memory page
- [Exercise #6](https://agenticengineering101.com/instructions/#exercise-6): hands-on exercise on the Instructions page
- [Exercise #7](https://agenticengineering101.com/version-control/#exercise-7): hands-on exercise on the Version Control page
- [Exercise #8](https://agenticengineering101.com/context-management/#exercise-8): hands-on exercise on the Context Management page
- [Exercise #9](https://agenticengineering101.com/hooks/#exercise-9): hands-on exercise on the Hooks page
- [Exercise #10](https://agenticengineering101.com/gates/#exercise-10): hands-on exercise on the Gates page
- [Exercise #11](https://agenticengineering101.com/ralph-loops/#exercise-11): hands-on exercise on the Ralph Loops page
- [Exercise #12](https://agenticengineering101.com/evaluation/#exercise-12): hands-on exercise on the Evaluation page

## Final Project

- [Final Project: Build The Control Panel](https://agenticengineering101.com/control-panel/): Build a local control panel for defining agent pipelines, running them against a repository, and seeing which runs passed and which need attention.
- [Final Project: The Pipeline Editor](https://agenticengineering101.com/pipeline-editor/): Build the control panel's pipeline editor in plain HTML, CSS, and JavaScript: arrange stages, choose gates, set limits, and save without losing work.
- [Final Project: Build The Run Engine](https://agenticengineering101.com/run-engine/): Implement the Python worker that runs a saved pipeline with a real agent, enforces permissions and deadlines, runs gates, and recovers from interruptions.
- [Final Project: Verify And Release](https://agenticengineering101.com/verify-it-works/): Finish the control panel with final verification, human approval, and a durable release record you can reopen and audit later.

## Optional

- [Agentic Engineering Key Terms](https://agenticengineering101.com/key-terms/): Plain definitions of the terms used across Agentic Engineering 101, from agents and context windows to gates, hooks, worktrees, and Ralph loops.
- [About](https://agenticengineering101.com/about/): Agentic engineering is a new discipline for building production software with AI agents. Learn it from first principles, then build a local control panel.