Unit 1: Foundations of AI Agents and Azure AI Foundry - Subjective Questions

An AI agent is an autonomous or semi-autonomous software system that perceives its environment, processes information, makes decisions, and performs actions to achieve specified objectives.

Its essential characteristics include:

• Perception: Collects information from users, sensors, databases, APIs, or other environmental sources.
• Reasoning: Interprets perceived information and determines suitable responses or actions.
• Action: Changes the environment by generating responses, invoking tools, or executing workflows.
• Autonomy: Operates with limited human intervention within defined boundaries.
• Goal orientation: Selects actions that contribute to one or more objectives.
• Adaptability: Adjusts its behavior using new observations, feedback, or learned knowledge.

The basic agent interaction cycle can be represented as:

For example, an enterprise support agent can interpret a customer request, retrieve account information, recommend a solution, and create a service ticket.

An intelligent agent architecture defines the components through which an agent perceives, reasons, plans, and acts.

The major components are:

• Environment: The external context in which the agent operates.
• Sensors or input channels: Receive observations such as text, images, events, or API responses.
• Perception module: Converts raw observations into a useful internal representation.
• Knowledge and memory: Store domain facts, conversation history, policies, and previous outcomes.
• Reasoning engine: Evaluates information, applies rules, and selects possible actions.
• Planning module: Organizes actions into a sequence that can achieve the goal.
• Actuators or tools: Execute actions, such as sending messages, calling APIs, or updating records.
• Learning and feedback module: Uses results and feedback to improve future behavior.

Their interaction is commonly represented as:

Memory and feedback support every stage by preserving context and evaluating whether an action produced the expected result.

Reactive agents respond directly to current observations, whereas goal-based agents evaluate possible actions according to a desired future state.

Examples:

• A reactive spam filter classifies a message based on its detected features.
• A goal-based travel agent compares routes, prices, and constraints to construct a complete itinerary.

Reactive agents are appropriate for predictable, time-sensitive situations. Goal-based agents are preferable when tasks involve alternatives, constraints, dependencies, or multiple steps.

The perception-action model describes an agent as a system that repeatedly observes its environment and acts upon it.

The model includes the following stages:

1. Perception: The agent receives an observation at time through an input channel.
2. State update: It combines the new observation with its existing state or memory.
3. Decision: It applies an agent policy to select an action.
4. Action: It performs action , which may change the environment.
5. Feedback: It observes the result and determines whether progress was made.

The action-selection relationship can be expressed as:

where is the current internal state and is the goal.

Feedback is important because it:

• Reveals whether an action succeeded or failed.
• Supports error correction and replanning.
• Helps the agent adapt to environmental changes.
• Enables learning from outcomes.
• Prevents the agent from continuing with an invalid assumption.

Thus, an agent is not merely an input-output system; it participates in a continuous closed-loop interaction.

Conversational AI enables machines to understand user input, maintain contextual interaction, and produce meaningful responses through text or speech.

A typical conversational process contains these stages:

• Input acquisition: Receives text directly or converts speech into text.
• Language understanding: Identifies the user's intent, entities, constraints, and sentiment.
• Context management: Maintains conversation history and relevant session information.
• Dialogue management: Determines the next conversational action.
• Knowledge retrieval or tool use: Obtains information from documents, databases, search systems, or APIs.
• Response generation: Produces a relevant and natural-language answer.
• Output delivery: Displays text or converts the answer into speech.
• Feedback and evaluation: Measures correctness, relevance, safety, and user satisfaction.

Effective conversational AI should support multi-turn context, clarification questions, safe failure handling, consistent tone, privacy protection, and escalation to a human when necessary.

A rule-based chatbot follows predefined patterns and dialogue paths, while a large language model-based agent generates responses using learned language representations and contextual instructions.

Rule-based systems are useful for narrow, predictable workflows requiring deterministic behavior. LLM-based agents are useful for flexible conversation, summarization, reasoning, and knowledge-intensive tasks.

In enterprise applications, a hybrid design is often suitable: the LLM interprets language and coordinates the task, while deterministic rules enforce authorization, validation, and critical business constraints.

Reasoning allows an agent to interpret information, identify relationships, evaluate constraints, and decide what should be done. Planning converts the selected objective into an ordered sequence of executable actions.

For a complex task, an agent generally:

1. Identifies the user's goal and success criteria.
2. Extracts constraints, available resources, and missing information.
3. Decomposes the goal into smaller subgoals.
4. Selects tools or actions for each subgoal.
5. Determines dependencies and an execution order.
6. Executes actions and observes their results.
7. Revises the plan when an action fails or the environment changes.
8. Verifies the final result against the original goal.

For example, a procurement agent may collect requirements, search approved suppliers, compare quotations, check budget limits, request authorization, and create a purchase order.

Reasoning makes the plan relevant and logically consistent, while planning ensures that actions are coordinated instead of being performed independently.

A planning problem can be represented using:

• An initial state .
• A set of possible states .
• A set of actions .
• A transition function that predicts the state produced by an action.
• A goal condition .
• A cost function for executing an action.

A plan is an action sequence:

Applying this sequence to should produce a state satisfying:

The total plan cost can be written as:

An agent can select a plan by searching through possible state transitions and choosing a valid sequence with a suitable cost, execution time, risk, or expected utility. In uncertain environments, the agent should also consider action success probabilities, monitor intermediate results, and replan when actual outcomes differ from predicted outcomes.

Enterprise agents normally combine model-generated planning with policy checks so that efficient plans remain authorized, safe, and auditable.

Azure AI Foundry is Microsoft's platform and toolset for designing, developing, evaluating, deploying, and monitoring enterprise AI solutions, including generative AI applications and intelligent agents.

Its role includes:

• Providing access to a catalog of foundation and language models.
• Supporting prompt development and experimentation.
• Enabling the creation and management of AI agents.
• Connecting models to enterprise data, retrieval systems, and external tools.
• Supporting evaluation of quality, groundedness, safety, and performance.
• Providing deployment endpoints and integration resources.
• Applying Azure identity, access control, content safety, and governance capabilities.
• Monitoring applications throughout their operational lifecycle.

Azure AI Foundry helps teams move from a prototype to a managed enterprise solution. It brings models, data connections, development tools, evaluations, responsible AI controls, and operational capabilities into a coordinated environment.

The AI agent lifecycle consists of the following major stages:

1. Problem definition: Identify the business objective, target users, scope, constraints, and success measures.
2. Agent design: Define instructions, tools, memory, knowledge sources, permissions, and interaction patterns.
3. Model and service selection: Select models and Azure services based on quality, latency, cost, security, and deployment needs.
4. Development: Implement prompts, tool interfaces, retrieval, workflow logic, and fallback behavior.
5. Testing and evaluation: Measure task completion, accuracy, groundedness, safety, robustness, and user experience.
6. Deployment: Release the agent through a managed endpoint or application environment.
7. Monitoring: Track latency, token usage, failures, harmful output, tool calls, and user feedback.
8. Governance: Maintain access controls, audit records, compliance policies, and human oversight.
9. Continuous improvement: Refine prompts, data, tools, policies, and models based on evaluation and production evidence.

The lifecycle is iterative because monitoring often reveals new failure modes, changing data, and opportunities for improvement.

Prompt engineering is the systematic design and refinement of instructions and context supplied to an AI model so that it produces useful, reliable, and appropriately constrained outputs.

An effective enterprise prompt should include:

• Role: Defines the agent's function or area of expertise.
• Objective: States the task and expected outcome clearly.
• Context: Supplies relevant background, user information, or grounded data.
• Constraints: Specifies boundaries, policies, prohibited actions, and limitations.
• Output format: Defines the required structure, fields, tone, or length.
• Tool guidance: Explains when and how tools may be invoked.
• Examples: Demonstrates desired behavior for important or ambiguous cases.
• Uncertainty handling: Instructs the model to ask for clarification or acknowledge insufficient evidence.

Prompt engineering is not only about improving wording. It also involves testing prompts against representative and adversarial cases, measuring results, and controlling how the model uses knowledge and tools.

These prompting techniques differ in the number of examples included in a prompt.

• Zero-shot prompting: Provides an instruction without an example. It is appropriate for straightforward tasks that the model already understands, such as summarizing a short passage.
• One-shot prompting: Includes one example of the expected input-output behavior. It is useful when a single demonstration can clarify tone, structure, or labeling conventions.
• Few-shot prompting: Includes several representative examples. It is appropriate for tasks involving specialized classifications, unusual formats, or distinctions that are difficult to describe using instructions alone.

For example, an agent that categorizes support tickets may use few-shot examples to distinguish between similar categories such as account access, identity verification, and authorization failure.

More examples do not automatically produce better results. Examples should be correct, diverse, relevant, and balanced. They also consume context tokens, so the prompt should use only the examples needed to establish reliable behavior.

Several Azure services can provide specialized capabilities to an enterprise AI agent:

• Azure OpenAI Service: Supplies generative and embedding models for language understanding, content generation, reasoning, and tool coordination.
• Azure AI Search: Supports document indexing, semantic search, vector search, and retrieval-augmented generation.
• Azure AI Content Safety: Detects potentially harmful text or image content and supports safety controls.
• Azure AI Speech: Provides speech recognition, speech synthesis, translation, and voice-related capabilities.
• Azure AI Language: Supports language analysis features such as entity recognition, classification, summarization, and conversational language understanding.
• Azure AI Vision: Analyzes images and visual content.
• Azure Machine Learning: Supports model development, training, deployment, experiment tracking, and machine learning operations.
• Azure Functions and Logic Apps: Enable agents to invoke serverless code and automated business workflows.

A complete agent may combine several services. For example, it can use Speech for input, Azure OpenAI for interpretation, Azure AI Search for grounding, and Logic Apps for workflow execution.

Reliable and responsible enterprise agents should follow these design principles:

• Clear purpose: Define a narrow business objective and measurable success criteria.
• Grounding: Base factual responses on trusted and current enterprise sources.
• Least privilege: Grant only the data and tool permissions required for the task.
• Human oversight: Require review or approval for high-impact and irreversible actions.
• Transparency: Inform users when they are interacting with AI and communicate important limitations.
• Privacy and security: Protect confidential data, credentials, prompts, and conversation records.
• Safety controls: Detect harmful input, constrain output, and validate tool arguments.
• Graceful failure: Ask clarifying questions, report uncertainty, and provide escalation paths.
• Observability: Record relevant decisions, tool calls, errors, performance, and user feedback.
• Evaluation: Test normal, edge, adversarial, and policy-sensitive scenarios before and after deployment.
• Modularity: Separate model reasoning, business rules, data access, and action execution where practical.

These principles reduce operational risk while making the agent easier to test, govern, maintain, and improve.

Memory, tools, and grounding extend an agent beyond unassisted text generation.

• Memory preserves useful context. Short-term memory can store the current conversation and intermediate results, while long-term memory can retain approved preferences or historical information.
• Tools allow the agent to interact with external systems. Examples include calculators, search services, databases, email systems, and business APIs.
• Knowledge grounding supplies trusted evidence from external sources so that answers are based on relevant and current information.

A common grounded workflow is:

Memory improves continuity, tools enable action, and grounding improves factual reliability. However, each creates risks: memory may expose private data, tools may perform unauthorized actions, and retrieved documents may be outdated or malicious. Therefore, agents require access control, input validation, source filtering, audit logging, and retention policies.

Important enterprise use cases include:

• Customer service agent: Answers routine questions, retrieves account information, summarizes cases, and escalates complex issues. It reduces response time and supports service consistency.
• Employee knowledge agent: Searches policies, technical documents, and internal knowledge bases. It reduces time spent locating information.
• Sales assistant: Summarizes customer interactions, prepares proposals, updates CRM records, and recommends follow-up actions. It improves seller productivity.
• IT operations agent: Diagnoses incidents, gathers logs, recommends remediation, and automates approved recovery steps. It can reduce mean time to resolution.
• Finance and procurement agent: Processes invoices, compares suppliers, checks policy compliance, and routes approvals. It improves workflow speed and reduces manual errors.

Other use cases include software development assistance, healthcare administration, legal document review, cybersecurity investigation, and supply-chain coordination.

The strongest use cases have clear goals, accessible data, measurable outcomes, and well-defined boundaries for automated actions.

The Microsoft AI ecosystem combines cloud AI services, development platforms, business applications, data platforms, and productivity experiences.

Major parts include:

• Azure AI Foundry: Supports the design, evaluation, deployment, and management of generative AI applications and agents.
• Azure OpenAI Service: Provides enterprise access to advanced generative AI models through Azure.
• Azure Machine Learning: Supports custom machine learning development, training, deployment, and operations.
• Azure AI services: Provide capabilities for language, speech, vision, search, and content safety.
• Microsoft Copilot Studio: Enables organizations to create and extend conversational agents and copilots using low-code tools.
• Microsoft 365 Copilot: Integrates AI assistance with productivity applications and organizational context.
• Dynamics 365 Copilot capabilities: Apply AI to sales, service, finance, and other business processes.
• Power Platform: Connects AI to low-code applications, workflows, data, and automation.
• Microsoft Fabric: Supports unified data engineering, analytics, governance, and business intelligence scenarios.
• GitHub Copilot: Assists developers with coding and software engineering tasks.

Together, these platforms connect models with enterprise data, applications, workflows, security, governance, and user experiences.

Agent evaluation should determine whether the system is useful, accurate, safe, efficient, and reliable under realistic conditions.

Important quality metrics include:

• Task completion rate: Percentage of tasks completed successfully.
• Factual correctness: Degree to which responses agree with trusted evidence.
• Groundedness: Extent to which claims are supported by retrieved sources.
• Relevance: Alignment of the response with the user's request.
• Tool-call accuracy: Correctness of tool selection and arguments.
• Safety compliance: Frequency of harmful, disallowed, or privacy-violating behavior.

Important operational metrics include:

• Response latency.
• Token usage and cost per interaction.
• Tool and service failure rates.
• Escalation rate.
• User satisfaction.
• Availability and throughput.

A simple task completion rate is:

Evaluation should use representative test sets, edge cases, adversarial prompts, human review, automated checks, and controlled pilot deployments. Production monitoring must continue because user behavior and connected data can change.

A single-agent architecture uses one coordinating agent to understand requests, reason, and access tools. A multi-agent architecture divides responsibilities among multiple specialized agents that communicate or delegate work.

A single agent is generally appropriate when the task has a coherent scope, a manageable tool set, and limited coordination needs. A multi-agent design may be justified when domains require separate permissions, specialized instructions, independent evaluations, or parallel work.

The choice should consider task complexity, security boundaries, latency, cost, observability, failure recovery, and whether specialization creates measurable value.

A high-level enterprise support agent can be designed with the following components:

• User interface: A web application, mobile application, Microsoft Teams, or another conversational channel.
• Agent layer: An agent created and managed through Azure AI Foundry interprets requests, maintains task state, and selects tools.
• Model service: Azure OpenAI Service supports language understanding, reasoning, summarization, and response generation.
• Knowledge layer: Azure AI Search indexes approved support articles, policies, product manuals, and resolved incidents.
• Action layer: Azure Functions, Logic Apps, or secured APIs create tickets, check service status, and update records.
• Safety layer: Azure AI Content Safety, policy checks, input validation, and output validation reduce harmful or unauthorized behavior.
• Identity layer: Microsoft Entra ID authenticates users and supports role-based access.
• Monitoring layer: Logs and metrics record latency, retrieval quality, tool calls, failures, cost, and user feedback.

A typical workflow is:

1. Authenticate the user.
2. Interpret the support request and gather missing details.
3. Retrieve relevant documents from Azure AI Search.
4. Generate a grounded response with source references.
5. Invoke an authorized tool when an operational action is required.
6. Request human approval before sensitive or irreversible actions.
7. Verify the result and update the support record.
8. Escalate when confidence is low or policy requires human handling.

Critical controls include least-privilege access, document-level authorization, prompt-injection defenses, tool argument validation, audit logs, data retention rules, and continuous evaluation.