Mechanics Behind AI Agents

Resources

• Building effective agents — Anthropic distinguishes predefined workflows from agents that direct their own tool use, then illustrates routing, parallelization, and orchestrator–worker patterns. This gives the lesson an architectural vocabulary before introducing individual harness features. https://www.anthropic.com/engineering/building-effective-agents

• An agent is a configured unit of work — The OpenAI Agents SDK defines agents through instructions, models, settings, tools, output types, and handoffs. Use it to make profiles concrete rather than treating an agent’s name or persona as its implementation. https://openai.github.io/openai-agents-python/agents/

• Inside the agent loop — OpenAI documents how a run alternates model calls, tool execution, and handoffs until it produces a final output or reaches a limit. It anchors the distinction between one model turn and an entire agent task, including conversation continuation and failure handling. https://openai.github.io/openai-agents-python/running_agents/

• Application state is not model context — OpenAI separates local application context from information actually visible to the model. This is a precise reference for assembling prompts, metadata, environmental facts, and retrieved information without assuming that everything in memory reaches the LLM. https://openai.github.io/openai-agents-python/context/

• Context engineering for agents — Anthropic examines just-in-time retrieval, lightweight references, compaction, structured notes, and subagent context windows. Use it to explain how agents discover their environment and manage working memory instead of repeatedly loading everything. https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents

• Persistent memory needs an implementation — Claude’s memory tool exposes file-oriented operations that the application must implement and secure. It makes storage, retrieval, editing, deletion, and path validation visible mechanics rather than implying that an agent automatically remembers previous sessions. https://platform.claude.com/docs/en/agents-and-tools/tool-use/memory-tool

• Aider’s repository map — Aider explains how it selects a token-budgeted map of a repository’s important symbols and relationships. This is a concrete example of mapping an environment before retrieving full files, useful for teaching navigation and selective context injection. https://aider.chat/docs/repomap.html

• Prompt caching is not persistent memory — Claude’s caching documentation explains reusable prompt prefixes, cache boundaries, lifetimes, and invalidation. Use it to distinguish preserving computation from preserving knowledge, and to show why context ordering matters during repeated agent turns. https://platform.claude.com/docs/en/build-with-claude/prompt-caching

• Attachments become model input — Claude’s PDF documentation covers document inputs and the processing of both text and page visuals. It gives a concrete attachment example for discussing what the agent actually receives, along with document and context limitations. https://platform.claude.com/docs/en/build-with-claude/pdf-support

• Sandboxed Bash has explicit boundaries — Claude Code documents filesystem and network isolation around shell execution, including their relationship to permission controls. Use it to separate the convenience of Bash from the authority granted to the process running it. https://code.claude.com/docs/en/sandboxing

• A managed code-execution environment — Claude’s code execution tool provides a sandboxed runtime for Python, Bash, and file-producing work. Its container and file lifecycle illustrate the difference between conversation state, execution state, and artifacts the agent can return. https://platform.claude.com/docs/en/agents-and-tools/tool-use/code-execution-tool

• Computer use is another observation–action loop — Claude’s computer-use documentation describes screenshot, mouse, and keyboard interactions with a desktop environment. It supplies the mechanics for browser-based work while foregrounding isolation, prompt injection, and human oversight of consequential actions. https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool

• Calling tools from code — Claude’s programmatic tool calling moves iteration, filtering, and orchestration into a code-execution container. Use it to contrast a model-mediated tool call on every step with code mode, where selected results return to the model’s context. https://platform.claude.com/docs/en/agents-and-tools/tool-use/programmatic-tool-calling

• What actually crosses a handoff — OpenAI documents handoff tools, structured handoff metadata, history filters, and the distinction between transferring control and calling an agent as a tool. This makes encapsulation and shared-versus-isolated context concrete before the later multi-agent engineering lesson. https://openai.github.io/openai-agents-python/handoffs/