Overview
Domain 2 moves from single prompts to agents: systems where a model decides on a sequence of actions to reach a goal. You need to describe the agent loop, in which the model reasons about the task, chooses an action such as a tool call, observes the result and repeats until it can answer or hits a limit.
The section covers how function calling works, with the model emitting a structured call and the application executing it, and how the Model Context Protocol (MCP) standardises the way agents discover and invoke tools hosted by separate servers. It also covers memory: what belongs in short-term conversation context, what belongs in long-term memory, and how compaction keeps long sessions inside the context window. Finally it looks at planning, multi-step workflows, multi-agent patterns and where human approval belongs. These ideas are mostly vendor-neutral; Domain 4 shows how OCI implements them.
How it's tested
Agentic concept questions describe a goal and a set of systems, then ask how the agent should reach them. Expect to pick the right tool mechanism, decide what the agent should remember, or identify where a loop needs a stop condition or human approval before a risky action.
-
Who runs the tool
You decide whether the model, your application, a managed built-in tool or a remote MCP server executes a given action.
-
What to remember
A scenario mixes session facts and lasting user preferences, and you assign each to short-term or long-term memory.
-
Loop control
An agent repeats tool calls or takes an irreversible action, and you choose iteration limits, validation or a human approval step.
An agent must check stock in an ERP system that several teams already expose through an MCP server, then email a buyer. Writing a new local function for stock lookups duplicates the server and its access rules. The better design connects the agent to the existing MCP server, keeps email as an application function, and requires approval before sending because email leaves the organisation.
Topics 5
Official topics from the Oracle outline, in outline order.
2.1 Explain the agent loop and autonomy levelsReason, act, observe and repeat until done.
- What it means
- An agent wraps a language model in a loop. On each turn the model looks at the goal, history and latest observations, decides whether to call a tool or answer, and the system feeds tool results back in. The loop ends on a final answer, an error or a configured limit.
- What to understand
- This reason-act-observe pattern is often called ReAct. Autonomy ranges from a fixed workflow where code decides each step, through tool-using assistants, to agents that plan multi-step tasks on their own. More autonomy means more flexibility and more risk. Good loops set maximum iterations, timeouts and clear success criteria, and they log each step so failures can be traced.
- How it shows up
- Expect a scenario about an agent that keeps calling the same tool and asks what control is missing.
- Common confusion
- Thinking the model itself runs indefinitely; the surrounding application or service drives each iteration.
2.2 Describe tools and function callingTool schemas, structured calls and execution responsibility.
- What it means
- Function calling lets a model request an action by returning a function name and JSON arguments that match a schema you supplied. The model never runs the code. Your application, or a managed service, executes the call and returns the output as a new message in the conversation.
- What to understand
- Clear names, descriptions and parameter schemas drive how reliably a model picks the right tool. Validate arguments before execution, because the model can produce plausible but wrong values. Built-in tools such as search or code execution are run by the platform, whereas custom functions run in your code under your permissions. Parallel tool calls can speed up independent lookups. Tool output counts toward context, so return concise results.
- How it shows up
- A question asks which component executes a function after the model selects it.
- Common confusion
- Believing the model has direct network or database access when it only proposes calls.
2.3 Explain the Model Context ProtocolMCP hosts, clients, servers and the capabilities they expose.
- What it means
- The Model Context Protocol is an open standard for connecting AI applications to external tools and data. An MCP server exposes capabilities, mainly tools, resources and prompts. An MCP client inside the agent host connects to the server, lists what it offers and invokes tools on the model's behalf.
- What to understand
- MCP replaces one-off integrations with a reusable interface: one server can serve many agents and frameworks. Local servers often use standard input and output, while remote servers use HTTP-based transport. Because the server performs the action, its authentication and authorization decide what the agent can reach. Approving which servers and tools an agent may use is a governance decision, and untrusted server descriptions can carry prompt injection.
- How it shows up
- Questions contrast connecting to an existing MCP server with writing a custom function for the same capability.
- Common confusion
- Treating MCP as a model or a hosting service rather than a protocol between agents and tool servers.
2.4 Manage agent memory and contextShort-term, long-term memory and context compaction.
- What it means
- Short-term memory is the working context of one conversation: recent messages, tool calls and results. Long-term memory persists selected facts, such as user preferences or past outcomes, across sessions so a later conversation can recall them.
- What to understand
- Everything in short-term memory is resent and billed on each turn, so long sessions grow expensive and can exceed the context window. Compaction or summarisation replaces older turns with a shorter representation, trading some detail for room. Long-term memory needs rules about what to store, retention, and who can read it, especially when it holds personal data. Retrieval over stored memories works like RAG over a private knowledge base.
- How it shows up
- A scenario asks how to keep a week-long support thread within limits without losing key decisions.
- Common confusion
- Assuming long-term memory means the model weights learn from each conversation.
2.5 Design multi-step and multi-agent workflowsPlanning, orchestration patterns and human-in-the-loop checkpoints.
- What it means
- Complex tasks can be split into steps or across agents. Patterns include a planner that breaks a goal into subtasks, a router that sends requests to specialised agents, and an orchestrator that calls worker agents and combines their output.
- What to understand
- Deterministic workflows suit well-understood processes with audit requirements; open-ended agents suit exploration. Splitting work across agents limits each agent's tools and context, which improves reliability and security, but adds latency and coordination cost. Human-in-the-loop approval belongs before irreversible or external actions such as payments, deletions or customer messages. Evaluation should test whole trajectories, not only final answers.
- How it shows up
- Expect to place an approval step or choose between a fixed workflow and an autonomous agent.
- Common confusion
- Adding more agents by default when a single agent with well-scoped tools would be simpler.
High-yield concepts
The terms, rules and formulas this domain turns into questions most often.
-
Agent loop
Repeated cycle of reasoning, acting and observing.
- Remember
- Needs stop conditions such as max iterations.
- Tested as
- Runaway and reliability scenarios.
- Trap
- Assuming the loop stops on its own.
-
ReAct
Pattern that interleaves reasoning steps with tool actions.
- Remember
- Each observation informs the next decision.
- Tested as
- Agent design questions.
- Trap
- Confusing it with a single prompt technique.
-
Function calling
Model outputs a structured call that code executes.
- Remember
- The model proposes; the application runs.
- Tested as
- Execution and permission questions.
- Trap
- Thinking the model executes code directly.
-
Tool schema
Name, description and JSON parameters describing a tool.
- Remember
- Quality of descriptions drives tool selection.
- Tested as
- Wrong-tool scenarios.
- Trap
- Leaving descriptions vague.
-
Model Context Protocol (MCP)
Open standard linking agents to tool and data servers.
- Remember
- Servers expose tools, resources and prompts.
- Tested as
- Integration choice questions.
- Trap
- Calling it a model or hosting product.
-
MCP server
Process that implements and exposes capabilities over MCP.
- Remember
- Its own auth decides what the agent can reach.
- Tested as
- Shared tool scenarios.
- Trap
- Duplicating it with custom functions.
-
Short-term memory
Context carried within one conversation.
- Remember
- Resent and billed every turn.
- Tested as
- Cost and context limit questions.
- Trap
- Keeping full history forever.
-
Long-term memory
Facts persisted across conversations.
- Remember
- Needs retention and privacy rules.
- Tested as
- Personalisation scenarios.
- Trap
- Believing it retrains the model.
-
Compaction
Shrinking older context into a shorter form.
- Remember
- Saves tokens but can drop detail.
- Tested as
- Long session questions.
- Trap
- Assuming it is free and lossless.
-
Human-in-the-loop
A person approves or edits before an action proceeds.
- Remember
- Place it before irreversible or external actions.
- Tested as
- Risk control scenarios.
- Trap
- Requiring approval on every read-only step.
-
Orchestrator pattern
A coordinating agent that delegates to worker agents.
- Remember
- Narrows each worker's tools and context.
- Tested as
- Multi-agent design questions.
- Trap
- Using it where one agent suffices.
Side by side
Concepts candidates mix up, compared on the point that decides the answer.
Tool mechanisms
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| Custom function | Your code runs the action after the model asks | You own execution and permissions | Exposing broad credentials to the function |
| Built-in platform tool | Managed tool run by the service | No code to host, fixed capability | Expecting custom business logic |
| MCP server tool | Remote capability reached via the protocol | Reusable across agents and frameworks | Skipping review of server permissions |
Memory types
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| Short-term | Messages and tool results in the current conversation | Lives for one session | Letting it grow past the context window |
| Long-term | Selected facts stored across sessions | Persists and can be recalled later | Storing personal data without retention rules |
| Compacted context | Summarised or encoded older turns | Smaller but less detailed | Expecting exact recall of compacted turns |
Workflow styles
| Concept | Meaning | Key difference | Common trap |
|---|---|---|---|
| Deterministic workflow | Code fixes the sequence of steps | Predictable and auditable | Using it for open-ended research |
| Autonomous agent | Model chooses steps at run time | Flexible but less predictable | Giving it irreversible tools without approval |
| Multi-agent orchestration | Coordinator delegates to specialists | Separation of tools and context | Adding latency without need |
Exam traps
Each trap is an answer that looks right. Learn the clue that should change your mind.
-
Model runs the tool
- What candidates pick
- The LLM connects to the database when it calls a function.
- Why it looks right
- The model output names the function.
- Why it's wrong
- The model only emits a structured request; the application or managed service executes it under its own permissions.
Clue to watch for The question asks which component needs database credentials.
-
MCP is a model
- What candidates pick
- Choose MCP as the model that powers the agent.
- Why it looks right
- It appears alongside model names in agent docs.
- Why it's wrong
- MCP is a protocol for tool and data access; any capable model can use an MCP client.
Clue to watch for Options mix model names with protocols.
-
Long-term memory retrains weights
- What candidates pick
- Pick long-term memory to make the model learn permanently.
- Why it looks right
- Memory sounds like learning.
- Why it's wrong
- Stored memories are retrieved into context later; weights change only through fine-tuning.
Clue to watch for Words like remember preferences across sessions.
-
More agents means better results
- What candidates pick
- Split a simple lookup into five cooperating agents.
- Why it looks right
- Multi-agent designs sound advanced.
- Why it's wrong
- Extra agents add latency, cost and failure points; one agent with scoped tools fits simple tasks.
Clue to watch for The task is narrow with one data source.
-
Approval on every step
- What candidates pick
- Require human approval for each search and read.
- Why it looks right
- It looks safest.
- Why it's wrong
- Blanket approval stalls the agent; approval belongs before irreversible or external actions such as payments or emails.
Clue to watch for The scenario separates read-only lookups from a final send action.
-
Unlimited loop for hard tasks
- What candidates pick
- Remove iteration limits so the agent can finish.
- Why it looks right
- Limits seem to block success.
- Why it's wrong
- Without limits a confused agent can loop forever and run up cost; set maximums and handle the stop case.
Clue to watch for Reports of repeated identical tool calls or rising bills.
Answer framework
Use these steps to design or troubleshoot an agent in a concept question.
- Define the goal and success condition, then decide whether a fixed workflow or a model-driven loop fits the level of uncertainty.
- List the actions required and assign each to a built-in tool, a custom function or an existing MCP server based on ownership and reuse.
- Decide what context each turn needs, what should persist as long-term memory, and when to compact older turns, so the agent keeps the facts it needs without exceeding the model's context window.
- Add controls: iteration limits, argument validation, scoped credentials and human approval before irreversible or external actions.
- Plan evaluation and logging of full trajectories so you can see which step, tool or memory item caused a failure.
Practice question
Want more like this? The 1Z0-1158-26 practice test has questions for every domain.
Checklist
0 of 12
Tick each one you can do without notes. Your ticks stay in this browser.
Study strategy
Draw the agent loop on paper before you read any OCI API reference: goal, model decision, tool call, observation, repeat, stop. Annotate who executes each box. This one diagram answers a surprising number of questions.
Next, build a tiny agent with one custom function, for example a weather or inventory lookup, using any OpenAI-compatible SDK. Watch the model return a function call, run it yourself, and send the result back. Then connect the same agent to a public sample MCP server and compare how tools are discovered rather than declared. Note where credentials live in each case.
For memory, run a long conversation and track token counts as history grows. Try summarising older turns and see what detail disappears. Write down which facts should persist beyond the session and which should not.
Finally, take three business processes from your own work and label each as a fixed workflow, a single agent or a multi-agent design, adding approval points. Reviewing these choices aloud is good preparation, because scenario questions in this section reward clear reasoning about control and responsibility rather than recall of API names.
FAQ
How much of 1Z0-1158-26 is Domain 2, Applying Agentic AI Concepts?
Oracle publishes no weights. Third-party practice material gives this section about a fifth of items, so expect it to be one of the larger blocks.
Is MCP an Oracle product?
No. The Model Context Protocol is an open standard. OCI supports it through the MCP Calling tool in the Responses API and Oracle publishes MCP servers for some of its services.
Does the model run my function code?
No. The model returns a function name and arguments. Your application or a managed service executes the function and sends the result back.
What is the difference between short-term and long-term memory?
Short-term memory is the context of the current conversation. Long-term memory stores selected facts so later conversations can recall them.
Why does compaction matter?
Without it, conversation history grows each turn, raising cost and eventually exceeding the context window. Compaction shrinks older turns at the cost of some detail.
When should a human approve agent actions?
Before actions that cannot be undone or that leave the organisation, such as payments, deletions or external messages. Read-only steps rarely need approval.
Are these questions OCI-specific?
Mostly not. This section tests general agent design; Domain 4 maps the same ideas to OCI Responses API features.
Other Artificial Intelligence & Machine Learning certifications
Where the same subject shows up in other exams. Cards marked "Same subject" open the matching domain.
Test your Domain 2 knowledge
You have covered the agent loop, function calling, MCP, memory, compaction and multi-agent patterns. Test how you assign tools, memory and approvals in scenarios.
Keep going
- Training Training Built on your Weak areas
- Practice test Questions by domain, with explanations
- Mock exam Full length, timed like the real exam
- Readiness test Find your weakest domain in minutes
- Cheat sheet Key terms and formulas on one page
- Ask the 1Z0-1158-26 AI tutor Get any concept explained your way