AI Agent Engineer

AI agent landmark readings

This is neither course 58 nor an example project. It is an independent reading module alongside the course and example areas. Twelve influential papers and engineering articles trace how AI agents evolved from systems that reason and act into systems that can work in real engineering environments over long horizons.

Content and copyright boundary

Every note is an original learning guide reorganized from a first-party source. The module does not reproduce the full text of any paper, article, or post and is not a substitute for the source. Each page records the title, author or publisher, version, date, and original link so that details can be checked at their origin.

The perspective you will build

By the end, you should be able to separate five technical lines that are often blurred together:

Agent loops: how a model cycles through reasoning, action, and environmental observation.
Learning and memory: how failures, long-term memory, and reusable skills affect later action.
Collaboration and protocols: how multiple agents are orchestrated and how model applications connect to external data and tools.
Real evaluation and interfaces: how capabilities are accepted on real tasks and why environment interfaces change agent performance.
Production harnesses: how repositories, tools, constraints, feedback, and cleanup become an environment in which agents can work.

flowchart LR
    A["2022 · ReAct"] --> B["2023 · Tools, memory, reflection, and skills"]
    B --> C["2023–2024 · Multi-agent systems, real issues, and ACI"]
    C --> D["2024 · MCP and production patterns"]
    D --> E["2025–2026 · Context and harness engineering"]

Recommended reading paths

Theme	Landmark readings	Question to hold while reading
Reasoning and tools	ReAct, Toolformer	Is tool use a runtime prompting pattern or a learned model capability?
Memory and continual learning	Generative Agents, Reflexion, Voyager	Should experience be stored as events, reflections, or executable skills?
Collaboration and interoperability	AutoGen, MCP launch article	What is solved by role-based conversation, and what is solved by a shared connection protocol?
Evaluation and environment interfaces	SWE-bench, SWE-agent	Did the model improve, or did the task, tools, and feedback become more agent-friendly?
Production engineering	Building Effective Agents, Effective Context Engineering, Harness Engineering	How can autonomy live inside a verifiable and maintainable system?

Comparison map

#	Key unit introduced	Most reusable idea today	What it does not establish
01 ReAct	Thought–Action–Observation trajectory	Update decisions with environmental feedback	Visible thought text is the model’s true reasoning process
02 Toolformer	Training examples containing API calls	Learn when and how to use tools	All modern structured tool-calling problems are solved
03 Generative Agents	Memory stream, reflection, and planning	Retrieve experience and form higher-level beliefs	Believable simulation is equivalent to real human behavior
04 Reflexion	Verbal feedback and episodic memory	Improve across trials without changing weights	Self-evaluation is inherently reliable
05 Voyager	Automatic curriculum, code skill library, verification loop	Preserve successful behavior as composable assets	Minecraft success directly generalizes to the real world
06 AutoGen	Conversable agents and conversation programming	Compose roles, messages, and control flow	More agents are always better
07 MCP	Client–Server protocol boundary	Standardize discovery and use of external capabilities	A protocol alone solves authorization, security, and quality
08 SWE-bench	Real issue–patch–test tasks	Score final repository behavior instead of prose	One leaderboard number represents all coding ability
09 SWE-agent	Agent–Computer Interface	Design operable and diagnosable interfaces for models	Gains come only from better prompting
10 Building Effective Agents	Composable workflows and autonomous agents	Increase autonomy only when the task requires it	Every LLM application should become an agent
11 Context Engineering	Finite attention budget	Load the smallest high-signal context when needed	Longer windows automatically solve long-horizon work
12 Harness Engineering	Repository knowledge, tools, constraints, and feedback loops	Make the environment legible, testable, and maintainable	Less manually written code removes the need for engineering judgment

How to read one guide

These guides are no longer short concept summaries. Each page develops one mechanism that you can trace by hand. Use this order:

Start with the learning goals and problem scenario. Identify the exact bottleneck the source addresses before memorizing terminology.
Name the components and state. Find the inputs, persistent or temporary state, decision maker, and outputs.
Walk through the control flow. Pay particular attention to how environmental feedback reaches the next round and what terminates the loop.
Follow the worked example. At each step, ask what the system can observe, what it updates, and why the next action follows.
Read the pseudocode or message trace. Check whether you could reconstruct a minimal implementation from the explanation.
Then examine evidence and boundaries. Keep reported results, the guide’s structural explanation, and present-day engineering implications separate.
Finish with the self-check. Answer before expanding the solution. If you cannot explain feedback or termination, return to the mechanism section.

What mastery looks like

Without looking at the page, you should be able to draw the core loop, walk a new example through the complete trajectory, and name at least one condition under which it fails. Remembering the one-sentence summary is not yet mastery.

Most guides should take 20–40 minutes. Their lengths are deliberately uneven: a complex mechanism receives more space, while a shorter mechanism is not padded to meet a quota.

When you need prerequisites

Return to Agent core, Tool calling, Context engineering, MCP, Multi-agent collaboration, or Evaluation framework. This module teaches the original works instead of repeating full courses.

Reading progress

Admission rule

This is a rolling bibliography, but it will not chase every new paper. A future addition must have a verifiable first-party source, must change a foundational agent paradigm, interface, evaluation method, or production practice, and must not merely repeat one of the current twelve works. New items append numbers rather than renumbering old files, keeping Obsidian links and public URLs stable.

12 items under this folder.