You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
- content: "What is the key distinction between AI agents and traditional chatbots?"
16
+
choices:
17
+
- content: "AI agents can only respond to specific user queries with prescripted answers."
18
+
isCorrect: false
19
+
explanation: "Incorrect. Responding to specific queries with prescripted answers describes chatbot behavior, not AI agent behavior."
20
+
- content: "Chatbots follow predetermined conversational paths, while agents dynamically plan and execute multi-step workflows to achieve an outcome."
21
+
isCorrect: true
22
+
explanation: "Correct. AI agents go beyond scripted responses by using AI-driven reasoning to plan, execute, and adapt their actions across multiple steps to accomplish a goal."
23
+
- content: "AI agents require step-by-step human guidance for each action they take."
24
+
isCorrect: false
25
+
explanation: "Incorrect. AI agents operate with a degree of independence and can make decisions, use tools, and adapt autonomously without step-by-step human guidance."
26
+
- content: "Which capability enables AI agents to interact with external systems like databases and REST APIs?"
27
+
choices:
28
+
- content: "Reasoning and planning."
29
+
isCorrect: false
30
+
explanation: "Incorrect. Reasoning and planning enable the agent to interpret requests and decide what actions to take, but this capability alone doesn't provide interaction with external systems."
31
+
- content: "Memory and context."
32
+
isCorrect: false
33
+
explanation: "Incorrect. Memory and context help the agent maintain coherence across multiple interactions, but they don't provide the mechanism for interacting with external systems."
34
+
- content: "Tool use."
35
+
isCorrect: true
36
+
explanation: "Correct. Tools give agents the ability to call external functions, APIs, or commands, enabling them to interact with real systems like databases and REST APIs."
37
+
- content: "What communication architecture does the GitHub Copilot SDK use to interact with the Copilot CLI?"
38
+
choices:
39
+
- content: "The SDK communicates with a cloud-hosted API using REST over HTTPS."
40
+
isCorrect: false
41
+
explanation: "Incorrect. The SDK communicates with a local CLI process, not a cloud-hosted API."
42
+
- content: "The SDK sends JSON-RPC messages to the Copilot CLI running in server mode as a local process."
43
+
isCorrect: true
44
+
explanation: "Correct. The SDK architecture follows the flow: Application → SDK Client → (JSON-RPC) → Copilot CLI (server mode), with the CLI running as a local process."
45
+
- content: "The SDK embeds the AI model directly and runs inference locally without any external process."
46
+
isCorrect: false
47
+
explanation: "Incorrect. The SDK relies on the Copilot CLI running in server mode and communicates with it through JSON-RPC, rather than embedding a model directly."
48
+
- content: "What is the purpose of the SDK's infinite sessions feature?"
49
+
choices:
50
+
- content: "To allow an unlimited number of concurrent users to share a single session."
51
+
isCorrect: false
52
+
explanation: "Incorrect. The infinite sessions feature is about managing context within a single session, not about handling multiple concurrent users."
53
+
- content: "To automatically compact context when the context window approaches its limit, preventing token overflow errors."
54
+
isCorrect: true
55
+
explanation: "Correct. The infinite sessions feature automatically compacts older context when the context window nears its limit, preserving essential information while preventing token overflow errors."
56
+
- content: "To enable the agent to register an unlimited number of tools within a session."
57
+
isCorrect: false
58
+
explanation: "Incorrect. The infinite sessions feature manages conversation history length, not the number of tools registered with a session."
59
+
- content: "How are tools defined in the GitHub Copilot SDK for .NET?"
60
+
choices:
61
+
- content: "Using XML configuration files that map tool names to API endpoints."
62
+
isCorrect: false
63
+
explanation: "Incorrect. The .NET SDK defines tools programmatically in code, not through XML configuration files."
64
+
- content: "Using `AIFunctionFactory.Create` from the `Microsoft.Extensions.AI` package with a lambda function, tool name, and description."
65
+
isCorrect: true
66
+
explanation: "Correct. Each `AIFunctionFactory.Create` call takes a lambda function with `[Description]` attributes on parameters, a tool name, and a description that helps the model understand when to call it."
67
+
- content: "Using decorator attributes on controller classes that automatically expose methods as tools."
68
+
isCorrect: false
69
+
explanation: "Incorrect. Tools are defined explicitly using `AIFunctionFactory.Create`, not through decorator attributes on controller classes."
70
+
- content: "What are the five core architectural components that every AI agent system requires?"
71
+
choices:
72
+
- content: "Input handler, output formatter, cache, scheduler, and logger."
73
+
isCorrect: false
74
+
explanation: "Incorrect. While these items are common software components, they don't represent the specific architectural building blocks of an AI agent system."
75
+
- content: "AI reasoning engine, tools, planner and controller, memory and context, and policies and guardrails."
76
+
isCorrect: true
77
+
explanation: "Correct. These components form the architectural blueprint that every agent system shares, from the large language model (LLM) that reasons to the guardrails that ensure safe operation."
78
+
- content: "Database, API gateway, message queue, load balancer, and monitoring service."
79
+
isCorrect: false
80
+
explanation: "Incorrect. These items are infrastructure components for distributed systems, not the core building blocks of an AI agent architecture."
81
+
- content: "What does the `OnPreToolUse` session hook return to control whether a tool call proceeds?"
82
+
choices:
83
+
- content: "A boolean value indicating true to proceed or false to cancel."
84
+
isCorrect: false
85
+
explanation: "Incorrect. The hook uses a more granular control mechanism than a simple boolean."
86
+
- content: "A `PermissionDecision` value of `Allow`, `Deny`, or `Ask`."
87
+
isCorrect: true
88
+
explanation: "Correct. The `PermissionDecision` value provides three options: `Allow` to proceed, `Deny` to block the call, or `Ask` to prompt the user for confirmation before the tool executes."
89
+
- content: "An HTTP status code such as 200 for success or 403 for forbidden."
90
+
isCorrect: false
91
+
explanation: "Incorrect. The SDK uses its own `PermissionDecision` enum for tool call control, not HTTP status codes."
92
+
- content: "Which three design areas should a developer focus on when building an agent with the Copilot SDK?"
93
+
choices:
94
+
- content: "Speed, cost, and scalability."
95
+
isCorrect: false
96
+
explanation: "Incorrect. While these areas are important operational considerations, they aren't the primary design areas for agent configuration."
97
+
- content: "Context, tools, and policies."
98
+
isCorrect: true
99
+
explanation: "Correct. Context defines what information the agent needs, tools define what actions it can take, and policies define what rules it must follow."
100
+
- content: "UI design, database schema, and network architecture."
101
+
isCorrect: false
102
+
explanation: "Incorrect. These areas relate to general application design rather than the specific design decisions for an AI agent built with the Copilot SDK."
103
+
- content: "What event type signals that the agent finished processing a request, including all tool calls?"
104
+
choices:
105
+
- content: "`AssistantMessageEvent`."
106
+
isCorrect: false
107
+
explanation: "Incorrect. `AssistantMessageEvent` contains a portion of the agent's response text, but it doesn't indicate that all processing is complete."
108
+
- content: "`ToolExecutionCompleteEvent`."
109
+
isCorrect: false
110
+
explanation: "Incorrect. `ToolExecutionCompleteEvent` signals that a specific tool call finished, but the agent might still need to process more tool calls or generate more responses."
111
+
- content: "`SessionIdleEvent`."
112
+
isCorrect: true
113
+
explanation: "Correct. `SessionIdleEvent` signals that the agent finished all processing for the current request, including any tool calls, and the response is complete."
114
+
- content: "What does the `SystemMessageMode.Replace` setting do in a session configuration?"
115
+
choices:
116
+
- content: "It replaces the AI model assigned to the session with a different model."
117
+
isCorrect: false
118
+
explanation: "Incorrect. The `SystemMessageMode` controls system prompt behavior, not model selection. Model selection is handled by the `Model` property."
119
+
- content: "It replaces the default system message with a custom system prompt."
120
+
isCorrect: true
121
+
explanation: "Correct. Setting the mode to `Replace` ensures the custom system prompt entirely replaces the default system message, giving the developer full control over the agent's role and behavior definition."
122
+
- content: "It replaces all existing tool definitions with a new set of tools."
123
+
isCorrect: false
124
+
explanation: "Incorrect. `SystemMessageMode` affects only the system prompt configuration, not tool definitions."
125
+
- content: "Which event type should a developer subscribe to when streaming the agent's response token by token in a chat UI?"
126
+
choices:
127
+
- content: "`AssistantMessageEvent`."
128
+
isCorrect: false
129
+
explanation: "Incorrect. `AssistantMessageEvent` provides the complete response, not incremental tokens. It's used for nonstreaming scenarios."
130
+
- content: "`AssistantMessageDeltaEvent`."
131
+
isCorrect: true
132
+
explanation: "Correct. `AssistantMessageDeltaEvent` provides incremental text fragments through the `DeltaContent` property, which the developer can render in real time for a responsive chat experience."
133
+
- content: "`SessionIdleEvent`."
134
+
isCorrect: false
135
+
explanation: "Incorrect. `SessionIdleEvent` signals that processing is complete, but it doesn't provide response content for streaming."
136
+
- content: "What pattern gives a customer-facing agent access to product information and FAQs beyond the AI model's training data?"
137
+
choices:
138
+
- content: "Fine-tuning the AI model with the company's proprietary data."
139
+
isCorrect: false
140
+
explanation: "Incorrect. While fine-tuning can be useful, the recommended pattern for grounding agents in current documentation uses a different approach."
141
+
- content: "Retrieval-Augmented Generation (RAG) using a knowledge base search tool."
142
+
isCorrect: true
143
+
explanation: "Correct. RAG grounds the agent's answers in the developer's actual documentation by providing a search tool like `search_knowledge_base(query)` that queries the developer's FAQ system or documentation."
144
+
- content: "Increasing the model's context window size to include all company documents."
145
+
isCorrect: false
146
+
explanation: "Incorrect. Context window limits make it impractical to include all company documents, and RAG provides a more efficient and maintainable approach."
147
+
- content: "Why should back-office agents use tools for mathematical operations rather than relying on the AI model?"
148
+
choices:
149
+
- content: "Tools are faster than the AI model at performing complex calculations."
150
+
isCorrect: false
151
+
explanation: "Incorrect. While tools can be faster, speed isn't the primary reason for using tools for math operations."
152
+
- content: "Tools produce reliable results, while the AI model might introduce arithmetic errors."
153
+
isCorrect: true
154
+
explanation: "Correct. In enterprise processes where accuracy is critical, using tools like `calculate_tax(amount, rate)` for mathematical operations ensures deterministic, reliable results."
explanation: "Incorrect. The primary reason is reliability and accuracy, not token usage considerations."
158
+
- content: "What approach should be used when a back-office agent is triggered by monitoring alerts or webhooks?"
159
+
choices:
160
+
- content: "Process all alerts in a single shared session for efficiency."
161
+
isCorrect: false
162
+
explanation: "Incorrect. Using a shared session risks carry-over confusion between unrelated operations."
163
+
- content: "Queue all alerts and process them in a daily batch job."
164
+
isCorrect: false
165
+
explanation: "Incorrect. Delayed processing defeats the purpose of event-driven automation, especially for time-sensitive alerts like system incidents."
166
+
- content: "Process each event in an independent session to prevent context mixing between unrelated operations."
167
+
isCorrect: true
168
+
explanation: "Correct. Stateless execution with independent sessions for each event prevents context from one operation interfering with another, ensuring reliable processing."
169
+
- content: "What iterative workflow does an AI agent follow when processing a request?"
170
+
choices:
171
+
- content: "Research, implement, test, deploy, and monitor."
172
+
isCorrect: false
173
+
explanation: "Incorrect. These steps describe a software development lifecycle, not an AI agent's processing workflow."
174
+
- content: "Receive input, reason and plan, act, observe, and iterate or respond."
175
+
isCorrect: true
176
+
explanation: "Correct. This cycle repeats until the agent's goal is met: receive the user's input, reason about what to do, take an action like calling a tool, observe the result, and either iterate for more steps or produce a final response."
177
+
- content: "Parse request, validate data, execute query, format output, and return response."
178
+
isCorrect: false
179
+
explanation: "Incorrect. These steps describe a traditional request-response pipeline, not the adaptive, iterative workflow that AI agents use."
0 commit comments