An AI model can suggest a fix for a failed deployment. Inspecting the system, running a test, and showing that the fix worked require an execution system around that model. It must connect reasoning to actions, preserve progress, control access, and establish what actually happened.

OCI Enterprise AI brings together services for model inference, hosting agentic applications, and execution. To understand how they fit, start with four distinct concepts: a model produces output, an agent works toward a goal through a loop, a framework gives developers tools to build agents, and a harness supplies a complete environment for doing work.

Those distinctions become practical when a task spans many steps, encounters unfamiliar evidence, or affects production systems. The architecture needs to give the agent useful freedom while keeping authority, memory, and verification explicit.

From a model call to an agent

A model processes instructions, a user request, and relevant context for an inference call. Its output may be text, structured data, or a request to use a tool. A tool request is still output: software outside the model must decide whether and how to execute it.

An agent places the model inside an iterative loop. The runtime prepares context, calls the model, validates a proposed action, executes it if permitted, returns an observation, and repeats. The model helps select the next step; the runtime carries out the work.

Imagine a checkout service whose latency rises after a release. An agent might compare deployment versions, inspect latency metrics, and query error logs. If those logs point to a database timeout, it can change its investigation. Each observation informs the next model call.

The loop needs explicit limits and stopping conditions: successful verification, a time or cost budget, cancellation, or a failure that requires a person. Completion must be checked against the environment. A model saying “done” does not establish that the task succeeded.

Model v agent
Figure 1: Model vs. Agent

Frameworks build agents and harnesses operate tasks

An agentic framework is a programming model for building agents. It provides primitives for model calls, tool registration, state management, deterministic steps, and orchestration. Developers decide how the loop runs, where approval is required, how errors are handled, and how users interact with the application.

For an incident-triage agent built with LangGraph, a team might register get_service_metrics, compare_deployments, and query_error_logs. The agent routes its investigation according to the evidence, while application code requires human escalation before a production change. The framework supplies building blocks; the team implements the agent and its surrounding application.

A harness such as Codex packages agent capability into a ready-to-use, general-purpose runtime. Sessions, tools, command and file operations, skills, context management, checkpoints, and user interaction are already part of the environment. Users can hand it different problems without engineering a new application for each one.

The same harness might debug a failing test, investigate an incident, or prepare an operations report. It can break a large goal into subtasks, launch specialized sub-agents, and give each the context and tools it needs. The parent collects results, reconciles conflicting findings, and continues the overall task.

A framework and a harness can work together. A harness may use an agentic framework internally or implement its loop directly against model APIs. Developers can customize or embed it. The distinction concerns how much of the operational environment they need to assemble: a framework exposes the programming primitives, while a harness brings the common facilities for completing varied tasks.

That distinction also clarifies responsibility. Whether the team builds an agent or adopts a harness, it still needs a defined boundary around tools, execution, task state, and approvals. Ready-to-use capability does not make every proposed action authorized.

Figure 2: Agentic Framework and Harness
Figure 2: Agentic Framework and Harness

Model APIs and agent hosting on OCI

The OCI Enterprise AI Responses API provides an interface for model inference and supported multi-step tool orchestration. It supports structured outputs, streaming, conversations, File Search, Code Interpreter, function calling, and remote MCP tools. Customers choose among supported models, including supported open-weight models.

The service has its own agent loop. A client sends model input and tool definitions; the service can call the model, invoke supported tools, return their results, and continue. File Search retrieves indexed content from a vector store. Code Interpreter runs Python in a managed environment. Remote MCP tools execute through a remote server.

Developer-defined local functions follow a different path. The API returns the function name and arguments to the client application, which executes the function and supplies the result. That boundary matters because the application remains responsible for the execution and its controls.

Retrieval and ingestion also serve different purposes. Files and Vector Stores APIs handle ingestion and index updates; File Search retrieves from that indexed material. Searching does not itself write new source data. Conversations and project memory help carry context across calls.

To build a custom agent, a team can use an agentic framework like LangGraph to define tools, routing, and its execution loop. It packages that runtime into a container and deploys it through OCI Enterprise AI Applications and Deployments. The running agent calls the Responses API and uses governed MCP servers or application tools for enterprise integrations.

OCI manages deployment infrastructure, the endpoint, and configured scaling, identity, storage, and networking. The team still owns agent logic, business rules, authorization checks, approvals, and task data. Managed hosting makes the application operable as a service; the team must still implement the workflow behavior its users need.


Figure 3: OCI Enterprise AI Responses A
Figure 3: OCI Enterprise AI Responses API

Isolate generated execution from production authority

An agent that generates Python, edits repository files, or runs shell commands creates programs during the task. Those programs may be influenced by untrusted source files, logs, or retrieved documents. Even a legitimate request can produce unsafe commands. Filesystem boundaries, network restrictions, and credential protection must therefore be enforced by the execution environment.

A safe architecture separates three responsibilities. The trusted agent or harness runtime manages policy and the task. A sandbox executes generated commands against isolated files with bounded resources. Governed enterprise tools access production systems under separate authorization.

Both framework-built agents and harnesses need this boundary when they execute untrusted code. Developers connect an execution backend to a framework; a usable harness should provide one as part of its environment. The runtime submits work, collects command results and artifacts, and decides the next step outside the generated code.

The controls must be concrete: bound compute and execution time, apply a deliberate network policy, keep broad OCI credentials outside generated code, and record what ran. Sandbox workspaces are temporary. Lasting decisions, checkpoints, and deliverables need durable storage elsewhere.

OCI Enterprise AI provides Code Interpreter as a managed Python tool through the Responses API. Containers and Container Files interfaces support isolated, stateful workspaces and file transfer across steps. The recently announced OCI Enterprise AI Sandboxes offering extends that execution boundary to general command-and-file workflows.

Execution capability must remain separate from infrastructure authority. If sandbox code determines that a production volume should be deleted, it cannot simply inherit the agent’s production credentials. A governed tool outside the sandbox checks the caller, resource identifiers, policy, and required approval before changing OCI resources. Isolation limits what generated code can affect; authorization governs the production action.


Figure 4: OCI Enterprise AI Sandbox
Figure 4: OCI Enterprise AI Sandboxes

Preserve context and recover from interruptions

A sandbox supplies somewhere to compute. Continuing after a context limit, interruption, or handoff requires several kinds of state with different purposes. Model context is the limited working view for one inference. Conversation history records messages and tool exchanges. Workflow state tracks plans, completed steps, results, pending approvals, attempts, and next actions. Shared memory retains validated decisions and reusable facts for authorized sessions and team members. Artifacts preserve files and supporting evidence.

Consider an intermittent integration test failure. One sub-agent examines relevant logs with read-only tools, while another compares recent commits. Each returns a concise finding and evidence. The parent brings those findings into its model context, forms a hypothesis, applies a patch in the sandbox, and runs the test.

The exchanges become conversation history. The hypothesis, saved patch, test outcome, and next action become workflow state. If the investigation establishes a reusable lesson, that validated finding can enter shared memory. A later session or another engineer can build fresh model context from the saved workflow and relevant memory, consulting the detailed exchanges when needed.

Context compaction helps avoid resending an entire history, but it must preserve important constraints and decisions. The complete task record and artifacts remain available outside the model’s context window. A framework application must connect that storage; a harness should provide checkpointing, context management, and shared-memory integration with appropriate access controls.

OCI Enterprise AI Projects organize responses, conversations, files, and containers and can provide managed conversation compaction and long-term memory features. Those facilities do not automatically constitute a shared task ledger. Applications may still need an access-controlled workflow database and durable artifact store. Memory supports continuity; fresh evidence and authorization still govern current decisions.

Recovery requires particular care when a tool times out after submitting a change. The target service may have completed it even if the response was lost. The runtime must distinguish proposed, attempted, and confirmed actions, reconcile external state, and retry only when safe or protected against duplicate effects. Explicit acceptance criteria determine completion; unverified outcomes must remain identified as such.

Figure 5: Shared Memory, Context and Recovery
Figure 5: Shared Memory, Context and Recovery

Put the boundaries to work

An engineer asks for a CSV of currently unattached block volumes created more than 30 days ago, with estimated monthly costs. Deletion requires approval.

In the OCI-hosted configuration shown here, Codex uses the Responses API for inference. Authorized, read-only OCI tools discover regions and compartments and retrieve inventory, attachment status, and pricing. Credentials stay with the tool service; the sandbox receives the analysis data.

Sandbox code combines records, applies filters, estimates costs from volume size and effective performance level, and produces the CSV. The harness inspects the results and corrects errors.

The workflow tracks the regions, compartments, and inventory pages processed. The report identifies coverage gaps and pricing assumptions so the engineer can judge its completeness and estimates.

The initial result is a report. A separately authorized deletion tool requires approval for specific volume identifiers, revalidates resource state, performs approved operations, and verifies the outcome. The harness records the evidence and remaining uncertainty.

Figure 6: End-to-end AI workflow
Figure 6: End-to-end AI workflow

Key takeaways

  • Keep the layers distinct. A model produces output; an agent connects it to tools and observations. A framework supports custom development, while a harness supplies a complete environment and can coordinate sub-agents.
  • Make ownership explicit. Managed hosting operates the application infrastructure; the team remains responsible for agent logic, business rules, authorization, approvals, and task data.
  • Separate execution from authority. Run generated code within a controlled sandbox and keep production credentials and consequential operations behind independently authorized tools.
  • Preserve the right state. Use context, conversation history, workflow checkpoints, shared memory, and durable artifacts for their respective purposes, with access controls for sessions and handoffs.
  • Verify completion and recovery. Retain evidence of what ran, what was approved, and what was checked. Reconcile uncertain actions before retrying and report gaps instead of assuming success.

Conclusion

Agentic AI goes beyond model reasoning to enable secure execution, reliable automation, and verifiable outcomes. OCI Enterprise AI brings together models, agent frameworks, managed hosting, and isolated execution environments to support complex, multi-step workflows. By separating execution from authority, clearly defining responsibilities, managing state, and preserving evidence of actions and results, OCI provides a secure, scalable foundation for enterprise AI agents. This approach enables organizations to move beyond generating answers toward reliably completing tasks, recovering from failures, and demonstrating successful outcomes.