Oracle OCI Enterprise AI

Agent prompts do more than ask a question: they set a role, rules, tool use and when to stop. You write and test system prompts, tool descriptions and output formats that hold across many inputs.

• System prompts: role, rules and stop conditions
• Writing tool descriptions a model uses correctly
• Examples and few-shot guidance for tool use
• Output schemas and validation
• Versioning and testing prompts as code
• Prompt failures: drift, injection and ambiguity

You build A versioned prompt set with tests for one agent.

A model can be steered several ways, each with a different cost. You compare prompting, retrieval, fine-tuning and other customization, choose by evidence, and judge whether a change improved the agent.

• Prompting, retrieval and tuning compared
• What data tuning needs and how to prepare it
• Customization settings that change behavior
• Building an evaluation set before changing anything
• Judging a tuned model against its base
• Keeping customizations maintainable

You build A lever-choice memo backed by an evaluation of two approaches on one task.

Most agent failures are design failures. You decide what the agent decides on its own and what stays fixed, map decision points and tool calls, and test the design on paper against awkward cases.

• Workflow, single agent or multi-agent
• Mapping decision points and branches
• Planning, routing and tool-selection patterns
• Stopping, retrying and escalating
• Walking the design through failure cases
• Writing a design record others can review

You build A design record for an agentic workflow, tested on paper against failure cases.

Tools let an agent act and memory lets it continue. You design tool interfaces with clear contracts and limits, and choose what the agent keeps in short-term context, in longer-term stores and not at all.

• Tool contracts: inputs, outputs and errors
• Keeping read tools and write tools apart
• Short-term context and conversation state
• Long-term memory and what belongs in it
• Retention, privacy and forgetting
• Idempotency and safe retries

You build Tool contracts and a memory design for the agent in your workflow record.

Before any agent runs, its models must be set up. You select models for the task, configure their parameters and access, and verify their behavior with test calls, within the limits of the platform.

• Selecting a model for the task
• Setting generation parameters
• Access, quotas and limits
• Calling a configured model from an application
• Testing a configuration before use
• Changing models without breaking agents

You build A configured model setup with a test suite that confirms its behavior.

Here the design becomes software. You define an agent with its instructions, models and tools, call it from an application, manage sessions and handle the errors that real traffic brings.

• Defining an agent: instructions, model and tools
• Connecting data sources and knowledge
• Calling an agent from an application
• Sessions and conversation handling
• Handling tool failures and timeouts
• Testing an agent before deployment

You build An application that calls an OCI Enterprise AI agent and handles its failures.

A hosted agent runs on the platform, not on a laptop. You package and deploy it, attach the tools and memory it needs, keep development apart from production, and roll out changes in a way you can reverse.

• What hosting an agent involves
• Deploying and updating a hosted agent
• Connecting tools and external services
• Attaching memory and state stores
• Environments, versions and rollback
• Secrets and configuration

You build A hosted agent deployed with tools, memory and a rollback path.

A working agent can still be too slow or too costly. You measure tokens, calls and latency per task, then reduce them with shorter prompts, caching, smaller models where they suffice and fewer steps.

• Measuring tokens, calls and latency per task
• Shortening prompts and trimming context
• Caching and reuse
• Routing easy tasks to smaller models
• Reducing steps and parallelizing calls
• Budgets and cost alerts

You build A before-and-after performance and cost report for one agent.

Agents act with real permissions on real data. You apply least privilege, data boundaries, guardrails and audit trails, and defend against prompt injection and data leakage.

• Identity and least privilege for agents
• Data boundaries and sensitive information
• Guardrails on inputs, outputs and actions
• Prompt injection and tool abuse
• Audit trails and approvals
• Policies for who may deploy agents

You build A governance and security design with controls mapped to threats.

You cannot improve what you cannot see. You collect traces, logs and metrics for every step an agent takes, alert on failures and drift, and use real conversations to improve the agent.

• Tracing each model call and tool call
• Logs and metrics for agent health
• Alerts for failures, loops and cost spikes
• Detecting drift in answer quality
• Reviewing real conversations
• Feeding production findings back into tests

You build An observability setup that traces a hosted agent and alerts on failure.

Carry one agent from design to operation. You design the workflow, configure the models, deploy it with tools and memory, and show its performance, cost, security and observability, with each decision explained.

• Choosing a business process for an agent
• Designing, building and deploying it
• Evaluating quality, cost and latency
• Applying governance and security controls
• Monitoring it in operation
• Explaining the design and its trade-offs

You build A hosted agent running under governance, with a design record and operating report.