Custom Agentic Solutions

Agentic AI terms — defined before code

Agents vs standard LLM calls

The 5 components of every AI agent

The ReAct agentic loop

Microsoft's managed agent runtime

Define an agent with instructions and tools, interact via threads and runs. Azure manages the agentic loop — no infrastructure code needed.

Built-in tools

Python — Azure AI Agent Service

New Python concept: while loop — repeats a block until a condition becomes False. Explained in comments.
Install: pip install azure-ai-projects azure-identity

import os, time
from azure.ai.projects import AIProjectClient
from azure.identity import DefaultAzureCredential

# Connect to Foundry project
client = AIProjectClient.from_connection_string(
    conn_str   = os.environ.get("AZURE_AI_PROJECT_CONNECTION_STRING"),
    credential = DefaultAzureCredential()
)
agents = client.agents

# Step 1: Create the agent (name + instructions + tools)
agent = agents.create_agent(
    model        = "my-gpt4o",
    name         = "AnalystAgent",
    instructions = "You are a data analyst. Analyse files using code interpreter. Always cite numbers.",
    tools        = agents.get_definitions("code_interpreter")
)

# Step 2: Create a Thread (persistent conversation container)
thread = agents.create_thread()

# Step 3: Add user message to the thread
agents.create_message(
    thread_id = thread.id,
    role      = "user",
    content   = "Analyse the Q3 sales data. Find top 3 products and flag anomalies."
)

# Step 4: Create a Run (execute agent against thread)
run = agents.create_run(thread_id=thread.id, agent_id=agent.id)

# Step 5: Poll until run completes
# "while condition:" — keeps looping while condition is True
# Stops when run.status is no longer "queued" or "in_progress"
while run.status in ["queued", "in_progress"]:
    time.sleep(2)
    run = agents.get_run(thread_id=thread.id, run_id=run.id)
    print(f"Status: {run.status}")

# Step 6: Read the agent's response from the thread
if run.status == "completed":
    messages = agents.list_messages(thread_id=thread.id)
    print(messages.data[0].content[0].text.value)
else:
    print(f"Run failed: {run.last_error}")

Microsoft's SDK for custom agents

Core concepts

Python — Semantic Kernel plugin

New concept: async/await — Semantic Kernel uses asynchronous code for network calls. async def marks a function as async; await waits for its result without blocking.
Install: pip install semantic-kernel

import asyncio, os
from semantic_kernel import Kernel
from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion
from semantic_kernel.functions import kernel_function
from semantic_kernel.contents.chat_history import ChatHistory

# Step 1: Create the Kernel
kernel = Kernel()

# Step 2: Add Azure OpenAI service
kernel.add_service(AzureChatCompletion(
    deployment_name = "my-gpt4o",
    endpoint        = os.environ.get("AZURE_OPENAI_ENDPOINT"),
    api_key         = os.environ.get("AZURE_OPENAI_KEY"),
    service_id      = "azure-chat"
))

# Step 3: Define a Plugin (collection of tools)
class FinancePlugin:
    # @kernel_function registers this method as a tool the LLM can call
    # description= tells the LLM WHEN to use it
    @kernel_function(description="Calculate compound interest: principal, rate (%), years")
    def compound_interest(self, principal: float, rate: float, years: int) -> str:
        amount   = principal * (1 + rate/100) ** years
        interest = amount - principal
        return f"After {years}y: Total=${amount:.2f}, Interest=${interest:.2f}"

    @kernel_function(description="Convert USD to another currency (EUR, GBP, CAD)")
    def convert_currency(self, amount: float, target: str) -> str:
        rates = {"EUR": 0.92, "GBP": 0.79, "CAD": 1.36}
        converted = amount * rates.get(target.upper(), 1)
        return f"${amount} USD = {converted:.2f} {target}"

# Step 4: Add plugin to kernel
kernel.add_plugin(FinancePlugin(), plugin_name="Finance")

# Step 5: Run an agent conversation (async)
async def run_agent():
    history = ChatHistory()
    history.add_system_message("You are a financial advisor. Use Finance plugin for calculations.")
    history.add_user_message("If I invest $10,000 at 7% for 20 years, how much will I have? Convert to GBP.")
    result = await kernel.invoke(function_name="chat", arguments={"chat_history": history})
    print(f"Agent: {result}")

asyncio.run(run_agent())

Multiple agents collaborating

Three multi-agent patterns

Python — AutoGen multi-agent

Install: pip install pyautogen

import os
from autogen import AssistantAgent, UserProxyAgent, GroupChat, GroupChatManager

# LLM config — points to your Azure OpenAI deployment
llm_config = {"config_list": [{
    "model"      : "my-gpt4o",
    "api_type"   : "azure",
    "base_url"   : os.environ.get("AZURE_OPENAI_ENDPOINT"),
    "api_key"    : os.environ.get("AZURE_OPENAI_KEY"),
    "api_version": "2024-02-01"
}]}

# Create specialist agents — each with different system_message = different role
researcher = AssistantAgent(
    name="ResearchAgent", llm_config=llm_config,
    system_message="You gather and synthesise factual information. Cite sources."
)
writer = AssistantAgent(
    name="WriterAgent", llm_config=llm_config,
    system_message="You transform research into clear professional reports."
)
critic = AssistantAgent(
    name="CriticAgent", llm_config=llm_config,
    system_message="You review reports for errors and gaps. Say APPROVED when satisfied."
)

# UserProxyAgent represents the human
# human_input_mode="NEVER" = fully automated (no human input required each step)
# max_consecutive_auto_reply prevents infinite loops
user_proxy = UserProxyAgent(
    name="UserProxy",
    human_input_mode="NEVER",
    max_consecutive_auto_reply=10
)

# GroupChat manages which agent speaks next
group_chat = GroupChat(
    agents=[user_proxy, researcher, writer, critic],
    messages=[], max_round=10  # max_round prevents infinite loops
)
manager = GroupChatManager(groupchat=group_chat, llm_config=llm_config)

# Start the multi-agent conversation
user_proxy.initiate_chat(
    manager,
    message="Research generative AI in banking, write a 3-paragraph summary, then review it."
)

Keeping autonomous agents safe

Agentic Solutions — what the exam specifically tests

Test your understanding

6 questions — select an answer to see the explanation.