Free Oracle 1Z0-1157-26 Practice Test Questions and Answers (2026)

In the OpenAI Agents SDK, multi-step agent tasks are orchestrated through an iterative tool-calling execution loop managed by the Runner. When a user submits a multi-step query requiring sequential operations, the underlying language model first determines that the multiply tool must be called with arguments 15 and 8. The Runner executes this tool, obtains the result 120, and appends the tool response to the conversation history. In the subsequent iteration step, the model reads the updated context containing 120, identifies the second step, and issues a tool call to divide with arguments 120 and 3. Once the final tool result is returned, the model constructs the final response.

Option A: The Runner orchestrates model execution and tool invocations; it does not independently compute arithmetic without calling the model or tools.

Option B: The SDK does not combine distinct multi-step tool declarations into a single merged call unless explicitly defined as a combined tool.

Option D: The model selects tools dynamically based on context and step requirement, rather than redundantly executing every available tool in the registry.

- OpenAI Documentation: OpenAI Agents SDK Core Reference, "Runner, Tool Loop, and Step Lifecycle Management" (2024).

- OpenAI Developer Guides: Function Calling Guide and Multi-Turn Tool Execution Loops.

Modern LLM-based AI agents operate autonomously by determining dynamic execution plans to achieve high-level goals rather than relying on deterministic, static decision trees. Requiring every execution path to be explicitly predefined is a defining attribute of traditional rule-based programs and hardcoded workflows. Conversely, autonomous agents possess reasoning capabilities that allow them to dynamically break complex objectives into multi-step action plans, select and execute external tools or APIs based on real-time observations, evaluate intermediate execution feedback, and iteratively adjust their execution paths to solve complex, unpredictable tasks in open environments.

A: Adjusting behavior based on intermediate observations (reflection and environmental feedback) is a core characteristic of autonomous LLM agents.

B: Pursuing complex goals across multiple sequential planning and execution steps defines fundamental agentic task-decomposition capabilities.

C: Interacting with external tools, APIs, and databases is an essential agentic mechanism used to perform side-effects and retrieve external data.

- Yao, S., et al., "ReAct: Synergizing Reasoning and Acting in Language Models", International Conference on Learning Representations (ICLR), 2023. DOI: https://doi.org/10.48550/arXiv.2210.03629

- Wang, L., et al., "A Survey on Large Language Model based Autonomous Agents", Frontiers of Computer Science, 2024. DOI: https://doi.org/10.1007/s11704-024-40231-1

The Model Context Protocol (MCP) is an open standard designed to enable secure, standardized communication between AI models and external data sources or tools. MCP utilizes JSON-RPC 2.0 as its underlying messaging protocol format for all requests, responses, and notifications exchanged between clients and servers. JSON-RPC 2.0 provides a lightweight, transport-agnostic remote procedure call standard that supports stateful connections, bidirectionality, and structured parameter passing. By building on JSON-RPC 2.0 over transports such as standard input/output (stdio) or Server-Sent Events (SSE), MCP simplifies integration across disparate developer environments while ensuring predictable message serialization and deserialization across heterogeneous systems.

A. SOAP/XML is a legacy XML-based protocol and is not used by MCP's modern architecture.

C. GraphQL is an API query language, whereas MCP specifically relies on JSON-RPC 2.0 for protocol messages.

D. Protocol Buffers is a binary serialization format, not the JSON-RPC standard adopted by MCP.

- Model Context Protocol Specification, Anthropic / MCP Open Standard, Architecture Section: "Protocol Layer & JSON-RPC 2.0 Specification" (2024).

- Oracle Cloud Infrastructure Documentation, "Model Context Protocol Integration and Standards" (2025).

The Model Context Protocol (MCP) is an open standardized protocol created to solve the N x M custom-connector problem between AI applications and external tools or data sources. Prior to MCP, every AI application (e.g., agents, IDEs, desktop assistants) required bespoke integration code for every tool or data repository (e.g., databases, version control, issue trackers), resulting in scaling friction. MCP establishes a universal client-server architecture where host applications (MCP clients) connect seamlessly to any tool or data provider (MCP servers) using a single standardized protocol. This decoupled architecture simplifies interoperability, allowing developers to expose tool capabilities once and make them immediately accessible across diverse agent environments.

A. MCP is an application-level integration protocol for client-server communication, not a hardware memory management or GPU optimization framework.

B. MCP standardizes communication interfaces and message formats between clients and servers, rather than optimizing network transport speed or model latency.

C. MCP manages context retrieval and tool access protocols, but token limit constraints are defined by the underlying language model's architecture.

1. Model Context Protocol Specification, "MCP Architecture Overview," Open Standard Documentation, 2024. Section "Protocol Specification".

2. Oracle Corporation, "Oracle AI Agent Integration Protocols," Oracle AI Documentation, 2024. Chapter 3 "Standardized Tool Connectivity".

The primary purpose of model interaction endpoints such as the OpenAI API is to accept client input requests, process them through hosted foundation models, and return the generated language model outputs. This programmatic interface serves as the standard communication gateway between client application logic and cloud-hosted generative AI models. Through this mechanism, software applications can send user prompts, context, and system instructions to receive structured completions, conversational responses, or function calling directions. By managing model inference on remote managed infrastructure, the API allows developers to integrate advanced language understanding, reasoning, and text generation capabilities directly into enterprise workflows without requiring local hardware or custom model hosting.

A: The API does not compress prompts to reduce token billing; tokenization and prompt optimization are handled on the client side prior to request submission.

B: The OpenAI API provides access to cloud-hosted proprietary models managed by OpenAI, rather than hosting open-source models on local developer hardware.

D: Model training from scratch requires specialized distributed training pipelines; API inference endpoints are designed for generation and execution rather than pre-training foundation models.

- Stanford CS224N: Natural Language Processing with Deep Learning, Lecture "LLM API Integration and Inference Interfaces".

- OpenAI Developer Documentation: API Reference - Chat Completions & Model Response Endpoints.

In the LangChain framework, StrOutputParser() serves as an output parsing component within an LCEL (LangChain Expression Language) pipeline. When an LLM model executes, it returns a structured message object, such as an AIMessage, which contains metadata, generation info, and response content. The primary role of StrOutputParser() is to process this complex model output object, extract the raw text string contained in the content field, and output it as a clean, plain text string. This facilitates streamlined downstream processing or direct text rendering without requiring manual parsing of the underlying message envelope.

Option A: Model API execution and prompt delivery are performed by the language model component (e.g., ChatOracle or ChatOpenAI), not the output parser.

Option B: The option merely repeats the function name rather than defining its operational role in the processing chain.

Option C: Tool execution history is maintained by memory managers and agent executor states, not by individual text output parsers.

1. LangChain Documentation, "Modules: Model I/O - Output Parsers", Section "String Output Parser (StrOutputParser)", 2024.

2. Harrison Chase et al., Building Applications with LLMs and LangChain, Chapter 3 "LCEL Components and Output Parsing", O'Reilly Media, 2024.

OCI Enterprise AI Agents is a fully managed cloud service designed to streamline the deployment, orchestration, and lifecycle management of AI agents. It offloads operational overhead from developers by handling hosted API endpoints, automatic runtime scaling, persistent session state management, and end-to-end observability (including execution logging, tracing, and metrics). While developers define specific prompt instructions and integrate data sources, the underlying OCI Enterprise AI Agents infrastructure manages agent deployment, execution isolation, and secure scaling. This architecture allows enterprise applications to execute complex, multi-step agentic workflows with built-in enterprise governance, security, and enterprise-grade reliability without manually provisioning or maintaining the runtime infrastructure.

A: Document chunking and indexing are handled by vector databases or knowledge base ingest pipelines, not the core agent runtime service.

B: Defining prompts and system instructions is the responsibility of application developers and prompt engineers, not the agent platform.

D: Routing network traffic between raw compute instances and object storage is managed by OCI Virtual Cloud Networks and infrastructure tools, not AI agent runtimes.

- Oracle Documentation: OCI Generative AI Agents Guide, Section "Agent Runtime Capabilities and Observability".

- Oracle Cloud Infrastructure Documentation: "Managing Generative AI Agent Endpoints and Sessions", 2024.

AI agents are defined by their capability to perform dynamic reasoning, leverage tools (such as database query APIs and transactional services), and autonomously adapt to unstructured or novel user requests without requiring hardcoded logic path updates. In customer support scenarios involving financial transactions, an agentic framework can parse complex user intents, select appropriate actions dynamically (e.g., fetching account balances or executing refunds via API integrations), and handle ambiguous user inputs gracefully. Unlike fixed template chatbots or rigid rule engines that fail on unprogrammed paths, AI agents utilize large language models as orchestrators to decide when and how to invoke external capabilities based on contextual conversation memory.

B: Traditional chatbots lack dynamic reasoning and autonomous tool orchestration required for processing complex customer transactions outside fixed patterns.

C: Rule-based systems cannot scale to handle unexpected scenarios or natural language variations without continuously writing manual if-then business rules.

D: AI agents require multiple LLM generation steps and tool calls, making them generally slower in latency compared to direct rule evaluations.

E: The three approaches differ significantly in reasoning flexibility, tool orchestration capabilities, and ability to handle unstructured inputs.

- Oracle Cloud Infrastructure (OCI) Generative AI Service Documentation: Building Autonomous AI Agents and Tool Integration.

- Russell, S., & Norvig, P. (2020). Artificial Intelligence: A Modern Approach (4th ed.). Pearson. Chapter 2: Intelligent Agents.

- Xi, Z., et al. (2023). The Rise and Potential of Large Language Model Based Agents: A Survey. arXiv preprint arXiv:2309.07864. https://doi.org/10.48550/arXiv.2309.07864

In the OpenAI Agents SDK, the Runner serves as the core execution engine responsible for managing the agent loop. It continuously orchestrates the lifecycle of an agent interaction by sending user messages and conversation context to the model, intercepting tool call requests generated by the model, invoking the corresponding local or remote function tools, feeding tool outputs back into the chat history, handling agent handoffs, and repeating this loop until the model returns a final text response or reaches a termination condition. This abstraction simplifies agent workflow control while maintaining explicit trace visibility and state management throughout the execution process.

A: The Runner is an orchestration execution loop within the application framework, not a cloud deployment platform or hosting infrastructure.

B: Authentication and API key lifecycle management are handled by the underlying API client configuration, not by the Runner execution engine.

D: JSON schemas for tools are generated automatically by inspectable function signatures or explicit tool definitions, not at compile time by the Runner.

1. OpenAI Agents SDK Documentation, "Architecture Overview & Core Concepts", Section 2: The Runner Lifecycle.

2. Oracle Agentic AI Framework Documentation, "Agent Execution Engine and Loop Control", Section 1.4: Orchestrating Agents with Runners.

The Model Context Protocol (MCP) defines standard transport mechanisms for client-server communication. For remote, network-accessible, or multi-client deployments, MCP specifies an HTTP-based transport standard (often implemented using Server-Sent Events/Streamable HTTP). This transport enables clients to establish secure network connections over standard Web protocols (HTTP/HTTPS), allowing MCP servers to be deployed centrally in cloud infrastructure or web microservices. Through HTTP streaming and POST requests, multiple clients can connect remotely across network boundaries to request tools, prompts, and resources. Conversely, local-only transports like standard input/output (STDIO) are limited strictly to local process boundaries and cannot support remote networked communication across distributed environments.

A: Raw TCP sockets are not defined as standard out-of-the-box MCP transport specifications; MCP standardizes on STDIO and Streamable HTTP/SSE protocols.

B: STDIO (standard input/output) relies on local operating system process pipes, which restricts communication strictly to local processes on a single host.

D: Local Unix domain pipes operate strictly within a single local operating system kernel and cannot route traffic over remote IP networks.

1. Model Context Protocol Specification, "Transports: HTTP with Server-Sent Events (SSE) and STDIO", https://spec.modelcontextprotocol.io/specification/basic/transports/

2. Anthropic MCP Technical Documentation, "Deploying Remote MCP Servers over HTTP/SSE", 2024.