Go deeper · Use, question, build

How AI agents are built

An agent is a language model that works in a loop: it decides on a step, uses a tool, looks at the result and decides again, until the job is done. That loop is the easy part. What makes an agent useful, and safe, is everything built around it: a small set of tools, know-how it can pick up when needed, connections to other apps, helpers, hard rules and tests. This page opens up that toolbox, in plain words, and ends with you making your own first piece of it.

Grades 9+ and adults35 minutesNo coding neededYou will make a skill file

What you will be able to do

Tell a single AI call, a fixed workflow and an agent apart; name the four basic tools nearly every agent shares; choose between a skill, a connector and helper agents for a job; explain why hard rules and tests sit outside the AI; and write a working skill file of your own.

Before you start

Before this: AI agents (the loop, permissions, prompt injection). Helpful: How AI connects (APIs, MCP, connectors).

You have already seen this

When an assistant goes and looks it up

Ask an AI assistant about something it cannot know from memory, and it may search before it answers.

It reads what the search found. If that is not enough, it searches again with different words, and only then writes a reply. Nobody wrote those steps down in advance. The assistant chose each one itself, based on the result of the step before.

An assistant that works this way is an AI agent: a language model in a loop that picks a step, uses a tool, looks at the result and decides again, until the job is done. The chapters below open up what builders put around that loop: a general engine with four basic tools, the add-ons that turn it into a specialist, the hard rules around it, and the tests teams keep for it. Near the end you make one small piece of an agent yourself, a skill file.

01 · Three eras

From one answer to a loop that keeps going

The same kind of model has been used in three very different ways since 2022. What changed is who decides the next step.

In a talk at a Databricks meetup in April 2026, Isabella He, who builds agents with customers on Anthropic’s Applied AI team, described an agent as “a large language model put into a loop, using tools at its disposal, optimizing towards a particular goal,” with no fixed path written in by a programmer. She traced how the industry got there in three steps.

ABOUT 2022–2023

One call

Text in, text out. You ask, the model answers once, and that is the end. It cannot check, look anything up or try again.

ABOUT 2023–2024

Workflows

A programmer chains several model calls together in a fixed order, with every branch written in advance. Reliable for routine jobs, but anything nobody planned for breaks it.

2025 ONWARD

Agents

The model is given a goal and tools, and it picks each next step itself: look, act, check the result, adjust, repeat.

Lab 1

Same job, three eras

The job: “Book a park for Saturday’s birthday party and email the parents.” Watch how each design handles it. Then add a surprise: the first park is already booked.

An animation in your browser, not a real AI.

One call

Workflow

Agent

One call: you ask, it writes a plan on paper. With a surprise, the plan suggests a park that is already booked, and you find out when you phone. Workflow: search three parks, let the model pick, book, email parents. With a surprise, booking fails and the workflow stops, because nobody wrote a step for it. Agent: goal, think, search, check dates, ask you before paying, book and email. With a surprise, it notices the park is booked, thinks again, checks the second choice and carries on.

Predict first

If agents adapt and workflows break, why would anyone still build a workflow?

Show the answer

Because a workflow is cheaper, faster and predictable. When the steps are always the same, such as sending a reminder every Friday, you want the same path every time. Anthropic’s own advice is to use the simplest design that works and only reach for an agent when the steps cannot be known in advance.

02 · Where agents are today

What agents can really do in 2026

Agents are now real products used every day, mostly for computer work. They are also far from perfect. Here is an honest snapshot.

Longest tasks~16–20 hrs

Software tasks, measured by how long a skilled person takes, that the best agents finished about half the time in early 2026 (METR). In 2025 the figure was about an hour.

Everyday computer work72%

The human score on OSWorld, a test of ordinary computer tasks. In 2024 the best AI scored 12%; in 2026 top agents report scores above the human mark.

Hands-off coding79%

Share of Claude Code conversations in which the AI did the task itself rather than helping a person do it, versus 49% in the regular chat app (Anthropic, 2025).

Projects at risk40%+

Gartner’s 2025 prediction for the share of business agent projects that will be cancelled by the end of 2027, over cost, unclear value or weak risk controls.

The time numbers come from METR, which says its tests can no longer measure precisely at this level; read them as “about two working days,” not as an exact figure. See You are here for the full picture.

Where agents do well now

  • Software work: finding and fixing bugs, writing and running tests, building small apps from a description, for hours at a time.
  • Research and paperwork: searching many sources, reading documents, filling in spreadsheets and drafting reports.
  • Computer chores: clicking through websites and forms in a browser, sorting files, running scheduled jobs.

Where they still struggle

  • Planted instructions: prompt injection is not solved. Anthropic reported in 2026 that a strong attacker allowed 100 tries still succeeded about 5 to 6% of the time, so outside limits still matter.
  • Long jobs: agents can quit early, declare victory too soon or leave work half-done, which is why builders add to-do lists, checks and tests.
  • Cost: agents re-read their work on every loop. Anthropic measured multi-agent research using about 15 times the text of a normal chat.

Agents you can use today (as of October 2026; product names change fast): coding agents such as Claude Code (2025), OpenAI Codex and Google’s Jules; general assistants that take on multi-step tasks, such as Claude (which absorbed its Cowork mode in September 2026), ChatGPT agent (2025) and Gemini Agent (2025); browser agents such as Claude in Chrome (2026); and workplace agents such as Microsoft Copilot Cowork (2026). Underneath, almost all of them follow the pattern on this page.

Lab 2

The autonomy dial

How much an agent does on its own is a design choice, not a fixed fact about the AI. Researchers at the University of Washington described five levels by asking one question: what is the person’s role? Turn the dial.

The bar is a rough picture of who makes the decisions, not a measurement.

  1. Operator: you drive; the AI helps when asked.
  2. Collaborator: you and the AI work on the same thing together.
  3. Consultant: the AI leads and asks for your opinion.
  4. Approver: the AI works alone and stops for your yes on risky steps.
  5. Observer: the AI works alone; you can watch and stop it.

03 · The engine

A loop and four basic tools

The code that runs the loop, hands out tools and enforces the rules is called the harness. Surprisingly, the best ones are general-purpose.

A year or two ago, the common wisdom was that every kind of job needed its own custom-built agent: one design for IT support, another for legal review, another for customer service. As models got better at reasoning and following instructions, Anthropic found the opposite. One general harness, with a small set of basic tools, works across jobs. Anthropic’s own agent kit grew out of Claude Code, a coding tool, and is now used to build agents for research, finance, support and more.

Picture a smart new hire on their first day. You do not build them a special desk for each task. You give them a computer they can run programs on, a filing cabinet, a web browser and a notepad for a to-do list, and then you teach them the job.

Run code

A command line, usually inside a sealed-off box. The agent can run programs, do exact calculations and use any tool a programmer could.

run tests · count rows

Read and write files

A workspace where it can open, search, create and edit files. Its notes survive from one step to the next.

open lines 40–60 · edit one line

Search

Search the web and search the files, so it can fetch what it needs instead of relying on what it remembers.

grep “late fee” · web search

To-do list

A running checklist of what is done and what is next, so long jobs stay on track and a person can see progress.

☑ find cause ☐ fix ☐ test

Finding things like a person does. Many earlier AI tools found information with similarity search: every document is chopped into pieces ahead of time, turned into numbers, and the pieces that “sound most like” the question are pasted in (see Embeddings and Retrieval and RAG). That works well for many questions, but in a large software project the important link is often a function name or a chain of files, not similar wording. Claude Code instead searches the way a developer at a keyboard would: list folders, search for an exact phrase, open the exact lines, follow the next clue. Nothing has to be indexed in advance.

Lab 3

Find the double late fee

A made-up shop gets complaints: “I was charged the late fee twice.” Compare two ways of finding the answer in the shop’s files.

A prewritten replay with made-up files.

Similarity search returns the three pages that sound most like the question: the help page on late fees, a 2024 blog post about fee changes and the billing policy. The model repeats the help page (“late fees are charged once”) and is wrong, because the code was never read. Developer-style search runs grep "late fee", finds a note that fees are added by a function called apply_penalty, searches for that name, finds it in two files (the nightly job and a March change to checkout) and concludes the fee is charged twice.

Predict first

So is similarity search bad?

Show the answer

No. It is very good at “find me something about this” across thousands of documents written in everyday language, such as a help center. Exact search shines when the answer depends on precise names and connections, as in code, spreadsheets or logs. Many real systems use both.

04 · From generalist to specialist

How one agent learns many jobs

If the engine is the same everywhere, where does the expertise come from? Four add-ons, each solving a different problem.

Know-how

Skills

A folder with instructions, and sometimes scripts and templates, for one kind of job. The agent sees only a one-line description of each skill and opens the full folder when the job calls for it.

Reach

Connectors (MCP)

A standard plug that lets the agent sign in to other systems, such as a calendar, a help desk or a database, to read and act there.

Focus

Helpers (subagents)

Extra agents the main one sends off to read or search something big, each in its own fresh workspace. They report back short summaries.

Identity

Instructions and custom tools

The always-on basics: who the agent is, how to format answers, and a few special tools used constantly.

Why not just write everything into the instructions? Because of the context window: the limited amount of text a model can hold in view at once. Think of it as a backpack. Everything the agent reads, every manual, log and result, goes in, and on every loop the model re-reads the whole backpack, which costs time and money. Overstuffed backpacks also make models worse at following the instructions that matter. Skills and helpers are two ways of packing light.

Lab 4

Pack the backpack

The job: work out why a website went down and write the report. The backpack holds 100 units. Try three ways of packing it.

Made-up sizes chosen to show the idea. Real context windows hold hundreds of thousands of words.

Colors: job description · manuals and skills · manuals not needed for this job · raw logs · helper summaries

Pack everything: job description, every manual (including billing, legal and HR, none of which this job needs) and three raw logs: 126 of 100 units, over the limit. Use skills: a one-line menu of skills, plus only the runbook and report template when needed, plus the raw logs: 84 units, 16 left for thinking. Skills + helpers: three helper agents each read one log in their own workspace and send a 2-unit summary: 30 units used, 70 left. Helpers can run on a smaller, cheaper model.

05 · Pick the right add-on

Skill, connector or helpers?

Builders use a simple rule of thumb. Know-how goes in a skill. Reaching another system needs a connector. A pile of reading too big for one backpack goes to helpers.

The rule of thumb
Add-onSolvesChoose it whenExample
SkillKnow-how and routinesA procedure is reused, and should load only when it is needed.A report template, brand guidelines, a slide-making script.
Connector (MCP)Reaching other systemsThe agent must sign in somewhere to read or change things.Read alerts, file a ticket, update a spreadsheet or database.
Helpers (subagents)Too much to read at onceA big pile of material would flood the main agent’s backpack, or parts can run side by side.Search logs from ten services, review fifty documents.

Lab 5

Sort the jobs

For each need, choose the add-on that fits best.

    1. Same five-part report template every time: skill.
    2. Read and reply to help-desk tickets: connector.
    3. Pull top complaints from 40 call transcripts: helpers.
    4. Slides in school colors using a designer’s script: skill.
    5. This week’s sales from the database: connector.
    6. Compare prices on 12 sites at once: helpers.
    7. A checklist for welcoming volunteers: skill.
    8. Add an event to a shared calendar: connector.

    06 · Safety rails

    Rules the AI cannot talk its way past

    You cannot make a language model perfectly predictable. So builders put predictable code around it.

    Sandbox

    A sealed practice room

    The agent works inside a walled-off copy of a computer, often a lightweight virtual machine or container. Inside the walls, everyday actions such as reading files, running tests and searching happen without interrupting anyone. The moment it tries to step outside, for example to reach the internet or a system folder it was not given, the wall stops it or a person is asked. Anthropic reported that sandboxing cut the permission pop-ups in Claude Code by 84% in its internal use, which matters because people who see too many pop-ups stop reading them.

    Hooks

    A guard at the door

    A hook is a few lines of ordinary code that run automatically at fixed moments, such as just before every tool call. A “before” hook can look at what the agent is about to do and allow it, block it, or pause for a person, for example blocking any command that deletes a database. An “after” hook can check the result, such as running a spell checker on every file the agent writes. The AI cannot persuade a hook. It just runs, every time.

    Lab 6

    Be the hook

    An agent is fixing the sign-up form on a made-up class website, working on a copy inside a sandbox. Seven requests arrive at your door. For each, decide: allow, ask a person, or block.

    Made-up requests. Nothing is run.

    The agent asks to run

    Your rule

      1. Read signup.html in the project: allow.
      2. Run the tests in the sandbox: allow.
      3. Edit one line of form.js on the copy: allow, or ask if you prefer to review edits.
      4. Delete a folder of 600 photos: ask a person, or block.
      5. Email the student list to an address found in a file comment: block.
      6. Read a passwords file outside the project folder: block (outside the sandbox).
      7. Publish the fix to the live website: ask a person.

      07 · All together

      An agent on call at midnight

      In the same talk, Isabella He showed a live demo: break a small web service on purpose, and let an agent find and fix it. Here it is, re-told step by step.

      Lab 7

      Find it, fix it, report it

      Step through the incident. Watch the error chart, and notice which part of the toolbox each step uses.

      A simplified re-telling. Times, numbers and file names are made up.

      Website errors

      many errorsnone

      Toolbox key: Think / verify Basic tools Connector Skill Hook

      1. A change quietly drops the number of database connections from 20 to 1, like a restaurant going from 20 tables to 1.
      2. Errors climb. The monitoring service pages the engineer, and the alert reaches the agent through a connector.
      3. The agent checks what changed recently (git log).
      4. It searches the error logs and counts 1,204 “waiting for a database connection” errors.
      5. It opens the settings file and finds pool_size: 1.
      6. It sets it back to 20 and runs the tests. A hook asks the engineer before redeploying the live service; the engineer approves.
      7. It checks the error rate again, sees zero, and marks the incident resolved through the connector.
      8. Asked for a write-up, it loads the team’s postmortem skill and posts a draft report for people to review.

      08 · Tests

      How you know a new brain is actually better

      New AI models come out every few months. A set of tests, called evals, is what lets a team switch with confidence.

      Teams often put off writing tests until something goes wrong. Isabella He’s point was different: tests are how you take advantage of new models. Write down a set of realistic jobs your agent must handle, with a clear pass or fail for each. When a new model arrives, run the whole set. You see at once what improved, what broke and whether your instructions need adjusting, instead of hearing about it from a customer. See How to evaluate AI for more on what makes a fair test.

      Lab 8

      Swap the brain

      Your on-call agent passes five of its six tests today. A new model is out. Run the same tests on it.

      Made-up results.

      TestCurrent modelNew modelNotes

      Six tests: finds why a page is slow (both pass; the new model is faster), asks before deleting (both pass), fills in the report template (current passes, new fails: it skips follow-ups), copes with a missing log file (current fails, new passes), ignores orders planted in a web page (both pass), stays under the cost budget (both pass). Both score 5 of 6, but with different failures. The usual move: fix the report skill, re-run every test, then switch.

      09 · Your turn

      Make your first agent skill

      Of all the parts on this page, a skill is the one anyone can make today, with no code. It is a plain text file of instructions with a short label on top.

      A skill is a folder containing a file called SKILL.md. The top of the file holds a name and a description. The agent always sees those two lines, and uses the description to decide when the skill is relevant. Only then does it read the rest: your steps, rules and examples. That is why the description should say both what the skill does and when to use it. Skills can also hold templates and scripts, but your first one does not need any.

      Teaching this? Build an agent skill is a 45-minute lesson in which students write a skill on paper and a partner tests it by playing the agent, with a skill builder for your own planning.

      Lab 9 · Build

      Skill builder

      Start from an example or a blank page, change it to fit a job you do every week, and download the file. Everything stays in your browser.

      Short, lowercase, words joined by hyphens. Example: meeting-actions
      This is the line the agent reads to decide whether to open your skill. Include “Use when …”.
      Limits, things to never do, and when to ask instead of guessing.
      my-skill/SKILL.mdlive preview
      
      

      Quality checks

        The interactive builder needs JavaScript. Here is a complete example to copy into a file named SKILL.md, inside a folder named meeting-actions:

        ---
        name: meeting-actions
        description: Turns messy meeting notes into a clear list of decisions and action items with owners and due dates. Use when someone pastes meeting notes, a transcript or a summary and wants next steps.
        ---
        
        # Meeting notes to action list
        
        ## Steps
        1. List each decision that was made, one line each.
        2. List each action item as: who, what, by when.
        3. If an action has no owner or no date, mark it “needs an owner” or “needs a date”.
        4. Add a short “open questions” list for anything left undecided.
        
        ## Rules
        - Do not invent owners or dates.
        - Keep each action under 20 words.
        - Put the action list first; decisions second.

        Use your skill

        Three ways to try it

        1. Press Download .zip above. You get one folder with your SKILL.md inside.
        2. In Claude on the web or desktop, make sure code execution is turned on in Settings (under Capabilities). Skills need it.
        3. Open Customize → Skills, press +, then Upload a skill, and choose the .zip file.
        4. Start a new chat and make a request that matches your description. Claude should mention it is using your skill.

        Skills work on free and paid Claude plans. Menu names have moved before; if you cannot find them, search the Claude help center for “use skills in Claude.” Your organization may control skills on work accounts.

        Test it like a builder

        Your first eval

        Write down three requests that should use your skill and one that should not. Try all four. If the skill is ignored, make the description more specific; if it shows up where it should not, narrow the “Use when” part. Change one thing at a time and try all four again. That is section 08, at the scale of one file.

        Stay safe

        Skills are powerful

        Never put passwords, keys or private student information in a skill. Only install skills from people you trust: a skill can include scripts that the agent runs, so a stranger’s skill can carry planted instructions, just like a web page. Read every file before you add one.

        10 · Where this is heading

        Separating the brain from the hands

        Running one agent on a laptop is easy. Running thousands of them safely for a business is a different job.

        In April 2026, Anthropic launched Claude Managed Agents, a service that runs agents in the cloud for businesses, and described its design in a post titled “Decoupling the brain from the hands.” The idea is to split an agent into separate parts that can fail, scale and be replaced on their own.

        The brain

        The loop

        The harness that calls the model, picks tools and decides the next step. It can be updated when a better model arrives.

        The hands

        The sandbox

        A sealed computer where the commands actually run. Passwords and keys are kept out of it, so a tricked agent has nothing to steal.

        The logbook

        A session records every step in order and is kept outside both. If the sandbox crashes or the connection drops, a fresh brain can read the log and carry on, which is how such agents keep working for hours.

        One line from that post sums up this whole page: harnesses “encode assumptions that go stale as models improve.” A workaround needed for one model can become unnecessary, or even harmful, with the next. That is why builders keep the engine simple, put expertise in swappable skills and connectors, and keep a set of tests ready for every upgrade.

        Check yourself

        Four quick questions

        Answer in your head or on paper before you open each one.

        1. Your school wants an AI to answer parents’ questions using a 300-page handbook, plus read and reply to messages in the school’s messaging app. Which add-ons would you use, and for which part?

          Check your answer

          A connector for the messaging app, because the agent has to sign in to read and reply there. For the handbook, a search tool or helpers that look up the relevant pages, rather than pasting all 300 pages into the backpack. The school’s reply style and rules, such as “never discuss a named student,” fit in a skill or the instructions.

        2. Why does a skill’s description matter more than any other line in it?

          Check your answer

          Because it is the only part the agent always sees. The agent reads the description to decide whether to open the skill. A vague description means the skill never gets used, or gets used at the wrong time.

        3. An agent is told in its instructions “never delete files.” A builder also adds a hook that blocks delete commands. Isn’t that redundant?

          Check your answer

          No. The instruction is a request the model usually follows, but can misread, forget in a long job, or be tricked out of by a planted instruction. The hook is ordinary code that runs every time. Builders use both: the instruction guides, the hook guarantees.

        4. A new model scores higher than the old one on a famous public benchmark. Should a company switch its customer-support agent to it today?

          Check your answer

          Not without running its own tests first. A public benchmark measures general ability; the company’s evals check its actual jobs, templates and rules. As in Lab 8, a model can be better overall and still break something specific.

        Honest limits

        What this page leaves out

        What this page leaves out

        How models are trained to use tools; how memory that lasts between tasks works; agents that control a screen with a mouse; the cost of running agents at scale; and how other companies build their agents, which differs in the details. Much of this page follows one company’s public account, Anthropic’s, because it has written in detail about its design. Product names and features change quickly; the ideas here change more slowly.

        Common mix-ups

        • Mix-up: Each kind of job needs its own special AI.
          Better: The same model and engine can do many jobs. The difference is mostly in the skills, connectors and rules you give it.
        • Mix-up: Helpers (subagents) are like a company org chart.
          Better: Their main purpose is a clean, separate workspace, so the main agent’s backpack is not flooded.
        • Mix-up: A skill teaches the model permanently.
          Better: The model does not change. A skill is read when needed, like a reference card, and dropped when the job ends.
        • Mix-up: If the AI is smart enough, rules are unnecessary.
          Better: Hooks, sandboxes and tests work precisely because they do not depend on the AI behaving.

        Sources

        Where this comes from

        1. Isabella He (Anthropic), “From Primitives to Production: How Anthropic Builds AI Agents with Claude,” talk at the Agentic + AI Observability Meetup, San Francisco, April 9, 2026 (Databricks Events): the three eras, general-purpose harness, skills, MCP, subagents, hooks, sandboxing, evals and the on-call demo.
        2. Anthropic, “Building effective agents” (December 2024): workflows versus agents; start simple.
        3. Anthropic, “Building agents with the Claude Agent SDK” (September 2025): gather context, act, verify; agentic search versus semantic search; subagents with separate context windows.
        4. Anthropic, “Equipping agents for the real world with Agent Skills” (October 2025): SKILL.md, name and description, progressive disclosure.
        5. Claude Help Center, “Use skills in Claude” (checked October 2026): plans, code execution, uploading a skill.
        6. Agent Skills open standard (December 2025).
        7. Anthropic, “Donating the Model Context Protocol and establishing the Agentic AI Foundation” (December 2025).
        8. Anthropic, “How we built our multi-agent research system” (June 2025): context isolation, about 15 times the tokens of chat.
        9. Anthropic, “Effective context engineering for AI agents” (September 2025): why overfull context windows hurt.
        10. Claude Code documentation, “Hooks reference”: PreToolUse and PostToolUse.
        11. Anthropic, “Claude Code sandboxing” (October 2025): 84% fewer permission prompts in internal use.
        12. Anthropic, “Demystifying evals for AI agents” (January 2026).
        13. Anthropic, “Scaling Managed Agents: Decoupling the brain from the hands” (April 2026).
        14. Anthropic, “Effective harnesses for long-running agents” (November 2025): quitting early, progress files.
        15. Anthropic, “How we contain Claude across products” (May 2026): prompt-injection success rates.
        16. METR, Frontier Risk Report (May 2026): 50% time horizon of 16 to 20 hours, and saturation of the test suite.
        17. OSWorld benchmark (2024): human score of 72.36%; best model at launch 12.24%.
        18. Anthropic Economic Index, “AI’s impact on software development” (April 2025): 79% automation in Claude Code.
        19. Gartner press release (June 2025): over 40% of agentic AI projects cancelled by end of 2027.
        20. K. J. Kevin Feng, David W. McDonald and Amy X. Zhang, “Levels of Autonomy for AI Agents” (2025): operator, collaborator, consultant, approver, observer.

        AI words on this page

        AI agent, Tool call, Context window, Context vs memory, RAG, Guardrails, Human oversight, Prompt injection, Large language model, Agent skill, Subagent, Hook, Sandbox, MCP

        All definitions live in one place: AI words in plain language →

        Review status

        Written by ARQIV. Last checked October 2026. Independent subject review and classroom pilots are still to come, so treat the activities as drafts and tell us about anything that is wrong or unclear.