AI Agents
An AI agent is a system that uses a large language model to drive a multi-step task autonomously, choosing its own actions, calling external tools, and deciding when the task is complete. The model controls the sequence of steps rather than just filling in a single response.
itArtificial intelligence and machine learning | OpenSkills.info
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Don't Panic
Don't Panic — AI Agents
The word now attaches to roughly anything with a text box in front of it, which makes it useless until you find the line underneath. The line is about who holds the steering wheel.
Write the order of operations in advance and leave the model a blank to fill in, and the result is ordinary software however clever the blank. Let the model choose what happens next, call something, read what came back and judge whether it has finished — that is what the word names. A chatbot is not one. A classifier is not one. One excellent answer to one prompt is not one.
Both sides of that line count as agentic systems, and neither is the better one. A workflow runs a model and its tools along paths written in advance; an agent picks its route while running. Where the steps are predictable, the written route is cheaper, more testable, and unexciting in the ways production software ought to be.
The building block is smaller than the vocabulary suggests. Take a model and hand it three capabilities it can reach for by itself: tools, meaning functions or APIs it calls to act on the world outside; retrieval, which fetches information it does not already hold; and memory, which carries state from one step to the next.
That augmented model is the atom, and everything larger is an arrangement of atoms. What gets configured is three things — the model that reasons, the tools that act, the instructions that set behaviour and limits. Then it loops: decide, act, read the result, decide again, until a final answer, a silence where a tool call would be, an error, or a preset limit on turns.
Two facts about that loop are structural, and neither yields to better prompting.
The first is arithmetic. A step that works ninety-five times in a hundred works thirty-six times in a hundred over twenty steps, and six times in a thousand over a hundred. That exponent, not model quality, decides what an agent can finish, because each added tool call multiplies in another number below one. Designs that survive production keep chains short and make every step verifiable alone, so a failure costs one step rather than the whole run.
The second is that the security problem is architectural. Private data, exposure to untrusted content, and some way of sending things outward: an agent holding all three can be told by whatever it reads to hand over whatever it holds. Instructions and injected text arrive in the same context window — the one block of text the model actually sees — with nothing marking which is which, so a filter lowers an attack's success rate without closing anything. Remove one of the three legs instead.
One last expectation to set. Evaluation is where these projects stall, not orchestration: a correct run legitimately varies in path, wording and tool order, so there is nothing fixed to compare against, and exact-match tests fail perfectly good runs.
Go to the Intro for the argument in full; the vocabulary lives on the Cheatsheet. Field Notes carries the numbers, including what a multi-agent design costs per run.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://www.anthropic.com/engineering/building-effective-agents
Supports
- The workflow-versus-agent distinction — workflows use predefined code paths, agents dynamically direct their own process and tool use
- Both workflows and agents are agentic systems
- The augmented model (model plus tools, retrieval, and memory) as the building block
- The five workflow patterns — prompt chaining, routing, parallelization, orchestrator-workers, evaluator-optimizer
- Investing in tool design and the agent-computer interface, including spending more time on tools than the prompt in a benchmark agent
- Using agents for open-ended problems where a fixed path cannot be hardcoded, and starting simple
- https://cdn.openai.com/business-guides-and-resources/a-practical-guide-to-building-agents.pdf
Supports
- An agent is a system that independently accomplishes tasks on your behalf
- Simple chatbots, single-turn LLMs, and sentiment classifiers are not agents because they do not control workflow execution
- The three core components — model, tools, and instructions
- The three tool types — data, action, and orchestration
- The run loop and its exit conditions (final-output tool invoked, model responds without tool calls, error, or maximum turns reached)
- Single-agent versus multi-agent systems and guidance to maximize a single agent first
- The manager pattern (agents as tools) and the decentralized pattern (handoffs), and that a handoff is a one-way transfer of control
- Guardrails as a layered defense and the guardrail types — relevance classifier, safety classifier, PII filter, moderation, tool safeguards, rules-based protections, output validation
- Guardrails must be paired with authentication, authorization, and access controls
- Human intervention for failure thresholds and high-risk, irreversible, or high-stakes actions such as large refunds and payments
- When to build an agent — complex decisions, difficult-to-maintain rules, heavy reliance on unstructured data; otherwise a deterministic solution
- https://arxiv.org/abs/2210.03629
Supports
- ReAct interleaves reasoning traces and task-specific actions in language models
- Reasoning traces help the model induce, track, and update action plans and handle exceptions
- Actions let the model gather information from external sources such as knowledge bases or environments
- Interleaving reasoning and acting reduces hallucination and error propagation compared with reasoning alone
- https://modelcontextprotocol.io/introduction
Supports
- The Model Context Protocol is an open standard for connecting AI applications to external systems
- MCP connects AI applications to data sources, tools, and workflows through a common interface
- The USB-C analogy — MCP standardizes connection the way USB-C standardizes a physical port
- https://modelcontextprotocol.io/docs/develop/build-server
Supports
- Building an MCP server exposes your own data and tools to an AI application as a hands-on next step
- https://arxiv.org/abs/1706.03762
Supports
- The Transformer architecture was introduced in Attention Is All You Need in June 2017
- https://openai.com/index/webgpt/
Supports
- WebGPT fine-tuned GPT-3 to answer questions with a text-based web browser that submits queries, follows links, and cites sources
- https://openai.com/index/chatgpt/
Supports
- OpenAI introduced ChatGPT as a research preview on November 30, 2022
- https://openai.com/index/function-calling-and-other-api-updates/
Supports
- OpenAI announced function-calling capabilities for GPT-4 and GPT-3.5 Turbo on June 13, 2023
- https://arxiv.org/abs/2308.08155
Supports
- AutoGen presented an open-source framework for LLM applications built from multiple agents that converse to accomplish tasks
- https://www.anthropic.com/news/model-context-protocol
Supports
- Anthropic open-sourced the Model Context Protocol on November 25, 2024 as a standard for connecting AI assistants to data systems and tools
- https://developers.googleblog.com/en/a2a-a-new-era-of-agent-interoperability/
Supports
- Google announced the Agent2Agent Protocol on April 9, 2025 for agent interoperability across systems
- https://openai.github.io/openai-agents-python/
Supports
- The OpenAI Agents SDK provides agents, tools, handoffs, guardrails, sessions, and tracing for agentic applications
- https://code.claude.com/docs/en/agent-sdk/overview
Supports
- The Claude Agent SDK exposes the Claude Code agent loop, tools, context management, permissions, sessions, subagents, and MCP in Python and TypeScript
- https://docs.langchain.com/oss/python/langgraph/overview
Supports
- LangGraph supports long-running stateful workflows and agents, mixing deterministic logic with LLM-driven decision making and persistence through failures
- https://adk.dev/
Supports
- Google Agent Development Kit documents multi-tool agents, agent teams, graph workflows, multi-agent workflows, routing, and loop workflows
- https://aws.amazon.com/bedrock/agentcore/
Supports
- Amazon Bedrock AgentCore is a production agent platform that supports multiple agent frameworks and models and provides authentication, access control, and observability for agent tool calls
- https://learn.microsoft.com/en-us/microsoft-copilot-studio/
Supports
- Microsoft Copilot Studio supports creating agents and workflows, connecting knowledge sources and tools, using MCP servers, testing, evaluating, governing, and analyzing agents
- https://www.salesforce.com/agentforce/
Supports
- Salesforce Agentforce provides agent configuration with actions, instructions, subagents, and human handoffs for service, sales, and employee workflows
