AIF-C01 STUDY GUIDE

A simple generative AI call can explain what to do. An AI agent can work toward a goal by selecting tools, calling APIs, observing results, and deciding what to do next—with safeguards around every action.

CloudExamPro · AWS certification prep · Reviewed October 2026
Short answer

A direct generative AI model call produces content from a prompt. An AI agent combines a foundation model with tools, instructions, and orchestration so it can pursue a goal through multiple steps, retrieve information, and request real-world actions through the surrounding application or service.

Ask a standard text-generation assistant, “Where is my equipment rental delivery?” It can explain how delivery tracking usually works, but unless the application gives it access to the order system, it cannot check your actual order. Now imagine an assistant that looks up the order, finds that the truck is delayed, checks tomorrow’s delivery slots, asks whether you want to reschedule, and books the new time after you confirm.

The first example is a direct generative AI interaction. The second is an AI agent: a system that uses a foundation model to interpret a goal, choose tools, take actions through those tools, and adapt based on the results. That shift—from generating an answer to coordinating a task—is why agents matter and why they introduce additional security and reliability risks.

The core difference

Area Direct generative AI call AI agent
Interaction pattern Typically generates a response from a prompt and supplied context. Can run a multi-step loop: decide, act, observe, and continue.
External systems Only has information supplied to the call or retrieved by the surrounding application. Can use configured tools and APIs to fetch data or request actions.
Planning No built-in multi-step tool orchestration in a simple model call. Can select and sequence actions based on what it discovers.
State Usually depends on the application to resend conversation history. Can preserve task progress across steps; session memory is optional and implementation-dependent.
Typical output Text, images, code, or another generated response. A completed or partially completed task, plus a response explaining the result.
Main risk Incorrect, biased, or harmful content. Those content risks plus incorrect, unauthorized, or harmful actions.

The simplest distinction is this: a direct model call generates an answer; an agent can use tools to work toward an outcome. An agent still relies on a model to interpret and decide, but the surrounding system supplies the actual tools and permissions.

Anatomy of an AI agent

Agent implementations vary, but many include these building blocks:

  1. Foundation model: interprets the user’s goal and helps decide what to do next.
  2. Instructions: define the agent’s role, boundaries, and expected behavior—for example, “You may check orders and offer rescheduling, but never issue refunds.”
  3. Tools: functions or APIs that perform specific tasks, such as looking up an order, checking availability, creating a ticket, or sending a message.
  4. Knowledge: documents and reference information the agent can retrieve, often through Retrieval-Augmented Generation (RAG).
  5. Orchestration: coordinates model decisions, tool calls, results, and the next step.
  6. Permissions and safeguards: limit what the agent can access or change, and define when human confirmation is required.
  7. Optional memory: retains relevant context across steps or sessions when the application or agent service supports it.

The agent loop: how orchestration works

A common pattern is often summarized as reason, act, and observe. The system receives a goal, decides which action is needed, calls a tool, examines the result, and repeats until it can respond or needs human input.

Goal received
     |
     v
Decide: What information or action is needed?
     |
     v
Act: Call a configured tool or API
     |
     v
Observe: Read and validate the result
     |
     v
Goal complete? ---- No ----> Decide next step
     |
    Yes
     v
Return the result to the user

Walk through the equipment rental example:

  1. Goal: “My excavator delivery was supposed to arrive this morning. What happened, and can we move it to tomorrow?”
  2. Decide: The agent needs the order status before it can answer.
  3. Act: It requests an order lookup through the configured order-status tool.
  4. Observe: The tool returns “delayed—truck breakdown.”
  5. Decide: The customer wants tomorrow, so the agent needs available delivery slots.
  6. Act: It calls the scheduling tool for tomorrow’s availability.
  7. Observe: The scheduling system returns an open 9:00 AM slot.
  8. Confirm: Because rescheduling changes a real booking, the agent asks the customer to approve the new time.
  9. After approval: The application or agent workflow submits the rescheduling action, checks the result, and reports whether it succeeded.

A simple prompt-and-response model call cannot complete this workflow on its own. The application must provide the integrations, execution logic, and permissions.

How tool use works

A foundation model does not independently log in to a company’s order database or execute an API call with its own credentials. In a tool-use design, the application or agent service provides descriptions of available tools: their names, purposes, and required parameters.

When the model selects a tool, it produces a structured request that identifies the tool and supplies arguments. The surrounding runtime validates the request, executes the function or API using its configured permissions, and returns the result to the model. The model can then use that result to decide the next step.

Security principle

The model’s tool request is not the same as executing the action. The surrounding application, agent runtime, or function performs the operation using its own configured permissions. Those permissions—and the validation around them—determine what the system can actually do.

Amazon Bedrock Agents Classic: an important availability update

Amazon Bedrock Agents is now called Amazon Bedrock Agents Classic. As of July 30, 2026, it is no longer open to new customers. Existing customers can continue to use their agents, APIs, action groups, and knowledge-base integrations, but the service is in maintenance mode and no new features or model versions are planned. For a new agent project, use Amazon Bedrock AgentCore instead. The action-group details below remain useful for understanding existing Agents Classic workloads and the general pattern of connecting an agent to tools.

For existing Agents Classic customers, the workflow is configured around a foundation model, instructions, tools, and optional knowledge. You define the actions and knowledge the agent can use, then invoke it through the agent runtime.

  • Foundation model and instructions: choose the model and describe the agent’s purpose, behavior, and boundaries.
  • Action groups: define operations the agent can perform. An action group can use an OpenAPI schema or function details to describe the operation and its parameters.
  • Lambda fulfillment: an action group can invoke an AWS Lambda function that contains the business logic and calls the required system or API.
  • Return control: instead of invoking Lambda, the agent can return the proposed action and parameters to your application so your application can execute the operation and send the result back.
  • Knowledge bases: associate a knowledge base so the agent can retrieve information from documents using RAG.
  • Guardrails: configure safeguards for supported inputs and outputs. Guardrails do not replace authorization checks on the tools themselves.
  • Traces: enable traces to inspect orchestration events, selected actions, knowledge-base queries, inputs, and observations for troubleshooting and monitoring.

Bedrock Agents also supports user confirmation for configured actions. You can require an end user to confirm or deny a sensitive action before the action group function or API is carried out.

Amazon Bedrock AgentCore for new agent development

Amazon Bedrock AgentCore is AWS’s current platform for building, deploying, and operating AI agents securely at scale. It supports different agent frameworks and model providers, rather than requiring a single fixed orchestration pattern. Depending on the architecture, AgentCore capabilities include managed runtime, Gateway for connecting tools and services, Identity, Memory, Observability, and tools such as Browser and Code Interpreter. Teams can use the components that fit their needs; AgentCore is not simply a rename of Agents Classic.

Exam and design distinction: recognize action groups and Lambda fulfillment when a question explicitly describes an existing Bedrock Agents Classic deployment. For a new AWS agent architecture after July 30, 2026, evaluate AgentCore and its tool integrations instead of assuming a new account can create Agents Classic resources.

Which tool fits which job?

Need Typical approach
Generate or summarize text A direct foundation model call.
Answer questions from company documents A knowledge base with RAG.
Fetch live data or perform an operation A configured API or tool call.
Retrieve a policy and then update an account An agent with a knowledge base and an action group, with appropriate authorization.
Run a fixed, predictable sequence A conventional workflow, such as AWS Step Functions, potentially with model calls inside it.
Choose actions based on results discovered along the way An agent with tools, orchestration, and appropriate controls.
Common exam trap

Do not choose an agent just because a scenario mentions AI. If the task is only to summarize a document, a direct model call may be simpler, faster, and less expensive. Agents add value when the application needs tool use, decisions, or multi-step task coordination.

Practical agent scenarios

Scenario 1: IT service desk

An employee says, “I’m locked out of the expense system.” An agent can use an identity-verification tool, retrieve the access policy from a knowledge base, and create a support ticket or request a permitted password reset. If the request involves granting access to a restricted system, the workflow can route it to a human approver instead of granting access automatically.

Scenario 2: Insurance claim intake

A customer reports a minor collision. An agent can collect details, retrieve relevant policy terms, create a claim record through an API, and schedule an adjuster appointment. Decisions about coverage or payout can remain with a qualified human reviewer.

Scenario 3: Procurement assistant

A manager asks for three quotes for ergonomic chairs under a budget. The agent searches approved supplier catalogs, compares options, drafts a purchase request, and routes it for approval. It does not need permission to place the order itself.

Each scenario limits the agent’s authority. Narrow permissions, explicit approval for consequential actions, and clear instructions are design requirements—not optional extras.

Risks that become more serious with agents

Agents inherit familiar generative AI risks, including hallucinations and prompt injection. But when an agent can take actions, a flawed response can become a real operational problem.

Risk What it looks like Mitigation
Excessive permissions An agent can delete accounts or change records it does not need to manage. Use least-privilege roles and narrowly scoped tools.
Prompt injection Malicious instructions in an email or retrieved page try to redirect the agent. Treat external content as untrusted, constrain tools, and require confirmation for sensitive actions.
Invalid tool arguments The agent supplies the wrong customer ID, date, or amount. Validate parameters in application code and verify tool results.
Runaway loops and cost The agent repeatedly calls tools without completing the task. Set step limits, timeouts, monitoring, and budget alerts.
Irreversible actions The agent deletes data, sends money, or submits a consequential change. Use human approval, confirmation, and reversible designs where possible.
Poor auditability The team cannot determine which tool was called or what result it returned. Retain appropriate agent traces, application logs, and AWS audit records.
Remember this

The more autonomy an agent receives, the more important least privilege, human oversight, input validation, and auditability become. More autonomy is not automatically better.

Agents and responsible AI

Responsible AI principles apply with extra force when a system can take action. People affected by an agent’s decisions should be able to understand when AI is involved, reach a human when needed, and challenge an outcome. Decisions with significant effects on individuals—such as employment, credit, insurance, or access to essential services—often warrant meaningful human review rather than unchecked automation.

Accountability should be designed before deployment: who owns the workflow, who approves high-impact actions, who investigates failures, and how can a person correct an incorrect result?

Choosing between a direct model call and an agent

Before choosing an agent, ask:

  1. Does the task need live data or actions? If not, a direct model call or RAG may be enough.
  2. Are the steps fixed and predictable? If so, a conventional workflow may be easier to test and operate.
  3. Does the next step depend on what the system discovers? If the path changes based on tool results, an agent may be appropriate.
  4. What is the cost of a mistake? High-impact operations need stronger permissions, approval, and monitoring.
  5. Can the workflow be tested and monitored? Define success criteria, tool-level validation, failure handling, and escalation paths before production.

Common mistakes and misconceptions

  • “An agent is just a chatbot.” A chat interface can front an agent, but the defining capability is coordinating tools and actions toward a goal.
  • “The model calls APIs directly.” The model requests a tool call; the surrounding runtime or application executes it.
  • “Agents replace RAG.” Agents can use a knowledge base as one of their tools. RAG supplies information; action groups perform operations.
  • “More autonomy is always better.” Autonomy increases both capability and risk. Grant only the authority the task requires.
  • “Every multi-step task needs an agent.” Fixed workflows may be better handled by conventional orchestration.
  • “An agent never needs human help.” Human approval and escalation are good design for consequential or uncertain actions.

Exam-focused insights for AIF-C01

The current AWS Certified AI Practitioner exam guide explicitly includes the role of AI agents and their business applications in Domain 3, Task Statement 3.1. Candidates should be able to recognize when an agent is appropriate and distinguish its role from a knowledge base or a direct foundation model call.

  • Spot the agent signals: “takes action,” “calls an API,” “checks availability,” “updates a record,” “submits a request,” or “chooses the next tool.”
  • Know the building blocks: foundation model, instructions, action groups, tool execution, optional knowledge bases, and orchestration.
  • Separate knowledge from action: a knowledge base retrieves information; an action group defines an operation the agent can invoke.
  • Apply safe-design instincts: least privilege, validation, human confirmation for sensitive actions, and monitoring reduce operational risk.
  • Avoid over-engineering: use a direct model call for simple generation and a conventional workflow when the steps are fixed.

Key takeaways

  • A direct generative AI call produces content from a prompt. An agent can pursue a goal by selecting tools, observing results, and iterating.
  • Tool use works because the application or agent runtime executes tools on the model’s behalf using configured permissions.
  • Amazon Bedrock Agents Classic combined a foundation model, instructions, action groups, optional knowledge bases, orchestration, and traces for existing customers. New agent projects should evaluate Amazon Bedrock AgentCore.
  • Action groups can use Lambda fulfillment or return control to the application; configured actions can require user confirmation.
  • Safe agent design depends on least privilege, human approval for consequential actions, input validation, monitoring, and clear boundaries.

Original AIF-C01 practice questions

These are original, unofficial educational practice questions written by CloudExamPro. They are not actual AWS exam questions.

Question 1

A company wants an assistant that can look up a customer’s order status in an internal system, check the refund policy, and then submit a refund request. Which description best fits this solution?

A. A text-generation call that answers using only its training data
B. An AI agent that uses tools and a knowledge base to complete a multi-step task
C. A speech-to-text pipeline
D. A model-evaluation job

👉 Click to reveal the answer & explanation

Correct answer: B.

  • B is correct: The assistant must retrieve policy information, query a live system, and request an operation. This is an agent-style workflow that combines knowledge and tools.
  • A is incorrect: A model relying only on training data cannot check live orders or submit a request.
  • C is incorrect: Speech-to-text converts audio and does not perform the business workflow.
  • D is incorrect: Model evaluation measures quality; it does not carry out customer operations.

Question 2

In an existing Amazon Bedrock Agents Classic deployment, which component defines operations an agent can perform, such as checking inventory or creating a support ticket, and can use AWS Lambda for fulfillment?

A. Action groups
B. Embedding vectors
C. Temperature settings
D. Model evaluation datasets

👉 Click to reveal the answer & explanation

Correct answer: A.

  • A is correct: Action groups define the operations an agent can invoke. They can be described with an OpenAPI schema or function details and fulfilled by Lambda or through return control.
  • B is incorrect: Embeddings represent meaning for similarity search; they do not define actions.
  • C is incorrect: Temperature affects generation variability.
  • D is incorrect: Evaluation datasets assess model performance and do not define agent operations.

Question 3

An agent can read customer emails and also has permission to delete customer accounts. The security team is concerned that a malicious email could trick the agent into deleting accounts. Which design changes best reduce this risk?

A. Grant the agent administrator access so it can undo mistakes
B. Remove the delete permission or require explicit human approval for deletion, and apply least-privilege permissions
C. Increase the agent’s temperature
D. Disable logging so attackers cannot see actions

👉 Click to reveal the answer & explanation

Correct answer: B.

  • B is correct: Removing unnecessary permissions and adding human approval for irreversible actions limits the potential damage from prompt injection.
  • A is incorrect: Broader permissions increase the impact of a mistake or attack.
  • C is incorrect: Randomness does not protect against manipulation and can reduce reliability.
  • D is incorrect: Logging supports detection and investigation; disabling it weakens security.

Question 4

A support team needs an assistant that answers questions using policy manuals and also reschedules appointments through an internal scheduling API. Which architecture is the best fit?

A. A knowledge base alone
B. An agent with a knowledge base for policy retrieval and an action group for the scheduling API
C. Amazon Rekognition
D. A fine-tuned model with no external integrations

👉 Click to reveal the answer & explanation

Correct answer: B.

  • B is correct: The knowledge base retrieves policy information, while the action group performs the scheduling operation.
  • A is incorrect: A knowledge base retrieves information but does not reschedule appointments by itself.
  • C is incorrect: Rekognition analyzes images and video; it is unrelated to this workflow.
  • D is incorrect: Fine-tuning without integrations does not provide access to current policies or the scheduling API.

Question 5

Which statement best describes how an AI agent handles a multi-step request?

A. It answers in a single pass without using external information
B. It iteratively determines the next step, calls a tool, observes the result, and repeats until the goal is met or human input is needed
C. It retrains the foundation model after each step
D. It requires the user to write all intermediate steps manually

👉 Click to reveal the answer & explanation

Correct answer: B.

  • B is correct: Iterative orchestration—deciding, acting, and observing—is a common agent pattern.
  • A is incorrect: That describes a simple prompt-and-response interaction.
  • C is incorrect: Agents do not retrain the model during each task step.
  • D is incorrect: Planning and coordinating intermediate steps is part of the agent’s role.

Frequently asked questions

What is the difference between an AI agent and a chatbot?

A chatbot mainly converses and answers questions. An agent can also plan, call tools and APIs, and coordinate multi-step tasks. Some agents use a chat interface, but taking actions through tools is the key distinction.

Do AI agents always need a foundation model?

Not every automated workflow is an AI agent. In the Bedrock agent pattern discussed here, a foundation model interprets the request and helps select actions. Conventional rule-based workflows can automate steps without a foundation model.

When should I use a conventional workflow instead of an agent?

Use a conventional workflow when the steps are fixed and predictable. It is often easier to test and control. Agents are useful when the next step depends on information discovered during the task.

Are AI agents safe to deploy in production?

They can be deployed with careful engineering: least-privilege permissions, human confirmation for sensitive actions, input validation, guardrails, logging, monitoring, and thorough testing. Risk increases with autonomy and the impact of permitted actions.

How does a knowledge base relate to an agent?

A knowledge base lets an agent retrieve information from documents using RAG. It supplies knowledge; action groups or other tools supply the ability to perform operations.

Official AWS references

CloudExamPro · AIF-C01 PRACTICE

Build confidence with scenario-based AIF-C01 practice

Learn to recognize when a scenario needs a direct model response, RAG, or an agent—and understand the safeguards each solution requires. Review every explanation and strengthen your weaker areas. No dumps. No shortcuts.

Take the free AIF-C01 diagnostic examExplore AIF-C01 Premium practice exams