1z0-1157-26 Agentic AI Foundations Associate Questions and Answers

OCI Enterprise AI Governance provides the control framework required to operate generative and agentic AI workloads securely in enterprise environments. Oracle defines governance as a combination of infrastructure protection, access control, network security, and runtime safety mechanisms. Key capabilities include OCI IAM policies , which determine who can access and manage Generative AI resources; Private Endpoints , which prevent model traffic from requiring public network exposure; Zero Trust Packet Routing , which introduces identity-aware network enforcement; and Guardrails , which apply safety and compliance controls to model inputs and outputs.

Oracle Guardrails specifically support mechanisms including content moderation, prompt-injection detection, and personally identifiable information detection. These controls address AI-specific operational and security risks rather than model lifecycle rollback or performance optimization.

Therefore, option D accurately expresses the purpose of Enterprise AI Governance. Model version management, runtime implementation, and latency monitoring may be operational concerns in an AI platform, but they are not the principal governance function described by OCI. The uploaded examination source also identifies D as the correct answer.

Study Guide reference/topic: OCI Enterprise AI Agents — Enterprise AI Governance, IAM, Private Endpoints, Zero Trust Packet Routing, and Guardrails.

===============

Tool selection in the OpenAI Agents SDK is model-driven. Each function tool exposes structured metadata that gives the model enough information to determine whether the tool is appropriate and how it should be invoked. The SDK represents a function tool using a name , description , and JSON parameter schema . OpenAI's SDK reference explicitly defines these properties as information shown to the LLM, while function-tool helpers automatically generate the parameter schema from the Python function signature and derive descriptions from documentation when available.

During an agent run, the model evaluates the user's request together with the available tool definitions. It can then select an appropriate tool and generate arguments conforming to that tool's schema. This mechanism is fundamentally semantic and contextual: meaningful names and descriptions tell the model what a tool does, while schemas describe the arguments required to execute it.

There is no rule requiring the first registered tool to be selected, every tool to be invoked, or random selection. Such behavior would undermine agentic reasoning and dynamic orchestration. Consequently, B is the technically correct answer and is explicitly identified as correct in the uploaded question set.

Study Guide reference/topic: OpenAI Responses API and Agents SDK — Function Tools, tool metadata, JSON schemas, tool selection, and model-driven invocation.

===============

For application-defined function tools, an LLM does not inherently execute the external operation itself. Instead, the model produces a structured tool-call request identifying the selected function and supplying arguments. The application or agent runtime then interprets that request, applies appropriate validation or authorization, invokes the corresponding implementation, and returns the result to the model for subsequent reasoning.

The OpenAI Responses API defines function calls as custom tools supplied by the developer that enable the model to request execution of application code using typed arguments. The OpenAI Agents SDK makes the separation explicit: a FunctionTool contains the tool name, description, parameter JSON schema, and an on_invoke_tool implementation that actually executes when the runtime processes the model-generated arguments.

This boundary is critical for security. The model proposes an action; controlled application/runtime logic performs the action. The model is therefore not automatically granted direct database, filesystem, network, or operating-system privileges merely because a tool has been described to it.

Options A, B, and D incorrectly remove this enforcement boundary. Consequently, C is the correct architectural description and matches the supplied question source.

Study Guide reference/topic: OpenAI Responses API and Agents SDK — function calling, structured tool calls, application execution, validation, schemas, and security boundaries.

In MCP, Tools are the primitive explicitly designed to be model-controlled. They represent executable functions that an MCP server exposes so that a language model can take actions, retrieve information, query databases, invoke APIs, modify files, or perform computations. The uploaded question set identifies Tools as the correct answer.

The official MCP specification defines three principal server primitives with different control models: Prompts are user-controlled , Resources are application-controlled , and Tools are model-controlled . Tools can be discovered by the model-facing application and invoked automatically according to the model's contextual interpretation of the user's request.

Resources differ because they primarily provide contextual data such as file contents or database schemas. Prompts provide reusable templates or instructions normally selected through user interaction. “Schemas” are not one of the three MCP primitives in this control hierarchy; schemas describe structures such as tool parameters rather than constituting a standalone primitive.

Therefore, A is correct.

Study Guide reference/topic: Model Context Protocol (MCP) Fundamentals — MCP primitives, Tools, Resources, Prompts, control hierarchy, and tool invocation.

===============

The Agents SDK separates validation at the input and output boundaries of an agent workflow. Input guardrails evaluate the initial user input, while output guardrails evaluate the final agent output before that result is accepted and returned. This makes B the intended architectural answer. A technical nuance is that current SDK input guardrails support both blocking and parallel execution: with blocking execution, validation completes before agent execution starts; with the default parallel mode, the guardrail can execute concurrently with the agent. Output guardrails, however, operate on the completed final output and always execute after the agent finishes producing it. Guardrails are runtime controls rather than decisions the LLM must explicitly request. OCI's agentic architecture similarly emphasizes governed model-and-tool workflows, making these validation boundaries important when implementing production AI agents. OpenAI GitHub

===============

The “USB-C for AI” analogy emphasizes standardization and interoperability . Just as USB-C defines a common interface through which many devices can connect to different peripherals, MCP defines a standardized protocol through which AI applications can connect to external tools, services, and contextual data sources.

The OpenAI Agents SDK's official MCP documentation summarizes MCP as an open protocol that standardizes how applications provide tools and context to language models and explicitly uses the USB-C analogy to explain the common connectivity layer. The key architectural advantage is reduction of bespoke integrations. A compatible host or agent can discover and interact with capabilities exposed by MCP servers without requiring a completely different proprietary integration model for every service.

The analogy has nothing to do with processor performance, physical installation, or specialized hardware. MCP is a software interoperability protocol. Its abstractions—hosts, clients, servers, tools, resources, prompts, and standardized messaging—are intended to make integration consistent across heterogeneous systems.

Therefore, the concept being tested is a standardized interface , making C correct. This matches the uploaded source.

Study Guide reference/topic: Model Context Protocol (MCP) Fundamentals — MCP standardization, interoperability, and the “USB-C for AI” concept.

===============

MCP standardizes how external systems expose capabilities to an AI application, but the model does not need to reason about the transport or deployment location of each capability. Once an MCP server's tools are discovered and incorporated into an agent's available tool set, they are represented to the model as callable tools with names, descriptions, and input schemas. Locally implemented function tools are presented through essentially the same model-facing tool abstraction. OpenAI's Agents SDK documentation explicitly states that tools obtained from configured MCP servers are added to the agent's list of available tools, alongside ordinary tools. Therefore, from the LLM's perspective, both are selected and invoked through the tool-calling mechanism rather than through separate network-specific interfaces.

Authentication, network connectivity, server lifecycle, authorization, and actual execution remain responsibilities of the application/MCP infrastructure. They are deliberately abstracted away from the model. Therefore, option B precisely captures the architectural consistency described in the course question.

Study Guide reference/topic: Model Context Protocol (MCP) Fundamentals — MCP tools, tool discovery, agent tool abstraction, and client-server integration.

===============

For production OCI Enterprise AI workloads, Oracle recommends OCI IAM-based authentication rather than long-lived development credentials. The uploaded source identifies OCI IAM authentication with signed requests and IAM policies as the correct production architecture.

Oracle's OCI Responses API authentication documentation distinguishes service API keys used for testing and early development from IAM authentication intended for production and OCI-managed environments. IAM-based authentication uses OCI identity principals and request-signing mechanisms and allows authorization to be controlled through centralized IAM policies. Oracle specifically recommends IAM when applications execute in services such as OCI Functions or Oracle Kubernetes Engine, when long-lived API keys should be avoided, or when fine-grained centralized access control is required.

IAM policies also implement least privilege by defining exactly which users, groups, resource principals, or workloads can access individual Generative AI resource types.

Browser cookies, anonymous tenancy access, and credentials committed into source repositories violate standard enterprise security practices and significantly increase credential-exposure risk.

Therefore, A is the only production-grade authentication approach among the choices.

Study Guide reference/topic: OCI Enterprise AI Agents — OCI IAM, signed requests, policies, principals, least privilege, and production authentication.

===============

MCP uses JSON-RPC 2.0 as the underlying message protocol for communication between MCP clients and MCP servers. JSON-RPC provides a structured representation for requests, responses, errors, and one-way notifications while remaining independent of the underlying transport. This separation is important because the same protocol semantics can operate over STDIO or Streamable HTTP.

The MCP architecture documentation states that the data layer implements a JSON-RPC 2.0-based exchange protocol defining message structures and semantics. It also explains that the transport layer abstracts communication details, allowing the same JSON-RPC message format to operate across supported transports. The MCP specification similarly requires messages between clients and servers to follow JSON-RPC structures, including methods, parameters, IDs for requests, and result/error structures for responses.

SOAP/XML is a different web-service protocol family; GraphQL is primarily a query language and API runtime; Protocol Buffers is a binary serialization technology. None is the MCP-defined wire-message format. Therefore, option B is correct and agrees with the uploaded answer key.

Study Guide reference/topic: Model Context Protocol (MCP) Fundamentals — JSON-RPC 2.0, requests, responses, notifications, and transport independence.

===============

OCI Enterprise AI Agents provides the operational and orchestration capabilities required to run agentic applications at production scale. The uploaded course source identifies these responsibilities as hosted endpoints, runtime scaling, session management, and observability . Current Oracle documentation supports that architectural classification.

OCI Generative AI Applications provide a managed runtime for agent workloads and centralize configuration for scaling, storage, networking, authentication, and deployments. Active deployments expose managed endpoints, while autoscaling controls can increase or decrease replicas according to workload metrics. OCI's Responses API also provides conversation state, Conversations, memory, and related context-management facilities for stateful agent interaction. Operational visibility is supported through OCI metrics, monitoring, endpoint telemetry, tracing, and hosted application logs integrated with OCI Observability and Management.

Document chunking/indexing is a retrieval-processing responsibility rather than the complete agent-platform role. Prompt definition remains application logic, and OCI network routing is handled by underlying OCI networking services.

Therefore, C best represents the production responsibilities of the Enterprise AI Agents layer.

Study Guide reference/topic: OCI Enterprise AI Agents — managed runtime, deployments, autoscaling, endpoints, conversations, memory, monitoring, and observability.

===============

When a LangChain agent is invoked through agent.invoke() , the agent runtime abstracts the core mechanics required for model-mediated tool execution. LangChain tools expose structured inputs and outputs, and tool definitions provide the model with schemas derived from Python type information or explicitly supplied schemas. The framework then coordinates model responses containing tool calls, dispatches the corresponding tools, passes observations back to the model, and repeats the process until the agent reaches a termination condition.

This is a major distinction between directly binding tools to a standalone chat model and using a LangChain agent. LangChain documentation states that, with a model alone, the developer must execute returned tool calls and feed results back manually; when an agent is used, the agent loop handles that tool-execution loop .

Thus, the course's intended abstraction is captured by B: building/exposing tool schemas, processing model tool calls, and orchestrating iterative execution. GPU memory distribution and model training are infrastructure/model-development responsibilities, not functions of agent.invoke() .

The supplied question source explicitly marks B as the expected answer.

Study Guide reference/topic: LangChain for AI Agents — agent.invoke(), tool schemas, tool-call parsing, ToolNode execution, and iterative agent loops.

===============

An embedding is a numerical vector representation of data created by an embedding model, normally implemented using a neural network. Its purpose is to encode semantic characteristics so that items with related meanings are positioned near each other in a multidimensional vector space. Instead of matching only literal keywords, a semantic-search system converts documents and queries into vectors and compares their relative distances or similarities.

Oracle AI Vector Search documentation explains that vector embeddings are mathematical representations describing semantic meaning for content such as text, documents, images, or audio. Oracle further states that modern embeddings are created through neural networks, commonly transformer-based models, although other neural architectures can also be used. This allows Oracle AI Database to store those embeddings using its VECTOR data type and perform similarity searches against them.

A trigger is procedural database logic, a SQL JOIN combines relational data, and a compressed video format is unrelated to semantic representation. Consequently, B is the only technically valid definition. The uploaded question set confirms the same answer.

Study Guide reference/topic: Agentic AI for Oracle AI Database — Oracle AI Vector Search, vector embeddings, semantic similarity, and neural embedding models.

===============

Embedding models accept inputs only up to their supported input-size or token limits. Large documents can exceed those limits and therefore must be divided into smaller segments before embedding generation. The course source explicitly identifies overcoming token limits as the reason for chunking.

Oracle AI Vector Search includes native chunking functionality that can split text according to characters, words, or model vocabulary tokens. Oracle's Vector Search guidance specifically states that input length must remain within the token limits of the embedding model and provides configurable maximum chunk sizes.

Chunking also provides an important retrieval benefit. Instead of representing an entire long document with one coarse embedding, the system creates embeddings for semantically meaningful sections. A similarity query can then retrieve only the chunks most relevant to the user's question, reducing irrelevant context and improving retrieval-augmented generation precision.

Chunking does not intentionally remove semantic meaning; well-designed chunking attempts to preserve it. It does not automatically provide encryption, and SQL storage format is not its underlying purpose.

Therefore, A is correct.

Study Guide reference/topic: Agentic AI for Oracle AI Database — document chunking, embedding token limits, vector generation, semantic retrieval, and RAG.

===============

The OpenAI Agents SDK uses an iterative agent loop for multi-step tool execution. In this scenario, the model first determines that it needs the multiply tool and generates a call with the arguments 15 and 8 . The application executes that tool and returns 120 as a tool result. The model receives the updated conversation state, recognizes that another operation remains, and subsequently requests divide(120, 3) . The resulting value is then available for the final response. The uploaded course source explicitly specifies this sequence.

OpenAI's Agents SDK documentation confirms that the Runner repeatedly calls the LLM, executes requested tools, appends their results, and runs the model again until final output is produced.

The Runner does not independently decide to calculate the arithmetic itself. Nor does the SDK automatically merge unrelated function calls into one synthetic operation. Likewise, an agent does not invoke every registered tool indiscriminately; the model selects the tools required by the current task.

Therefore, D accurately describes the sequential model/tool interaction.

Study Guide reference/topic: OpenAI Responses API and Agents SDK — agent loop, sequential tool calls, tool results, Runner orchestration, and multi-step execution.

===============