IBM watsonx Orchestrate AI Engineer

An agent is mostly instructions and the choices around them. You write instructions that make behavior predictable, pick a model, start from a prebuilt catalog agent where one fits, and test agent behavior in conversation.

• Writing agent instructions that hold up
• Choosing a model for the agent
• Describing when and how to use each tool
• Starting from prebuilt agents in the catalog
• Customizing a prebuilt agent
• Testing in conversation and reading the reasoning
• Defining agents as files that can be versioned

You build A configured agent with written instructions, tested on a set of realistic requests.

An agent is only as capable as its tools. You create tools from code and from API descriptions, write tool descriptions a model can choose correctly, and handle inputs, errors and credentials.

• Tools from code and from API descriptions
• Writing names and descriptions a model understands
• Input schemas and validation
• Returning results an agent can use
• Handling errors and empty results
• Connections and credentials for tools
• Making tool calls safe to repeat

You build Two custom tools, one from code and one from an API description, used by an agent.

Hard tasks need specialists. You design an agent that delegates to collaborators, write routing instructions that avoid loops and dead ends, and mix native agents with external ones.

• Supervisor and specialist designs
• Collaborator agents and delegation
• Routing instructions and their failure modes
• Passing context between agents
• Adding an external agent as a collaborator
• Keeping a team of agents debuggable

You build A supervisor agent that delegates a business request to two specialists.

Some work should not be left to an agent’s judgment. You build workflows with fixed steps, branches and approvals, call agents and tools from within them, and decide where a flow is better than autonomy.

• Flow or agent: deciding how much to leave open
• Steps, branches and data mapping
• Calling tools and agents from a workflow
• Human approval steps
• Handling failure inside a workflow
• Running and inspecting workflow executions

You build A workflow that runs a multi-step business process with an approval step.

Agents are useful when they reach the systems people work in. You use the integration catalog, set up connections with the right credentials, and decide whether an agent acts as the user or as a shared account.

• Browsing and using the integration catalog
• Creating connections to business applications
• Shared credentials against per-user credentials
• Calling APIs that are not in the catalog
• Managing secrets used by connections
• Testing an integration end to end

You build An agent connected to two business applications with appropriate credentials.

Open protocols let agents and tools work across vendors. You use the Model Context Protocol to bring in tool servers, understand how agent-to-agent communication works across platforms, and weigh the security cost of each connection.

• The Model Context Protocol and what a server offers
• Adding an MCP server’s tools to an agent
• Agent-to-agent protocol and external agents
• Choosing between a native tool and a protocol connection
• Trusting third-party servers and agents
• Limiting what a connected tool can do

You build An agent that uses an MCP server and an external agent, with trust limits set.

Impressive demos hide weak agents. You build test sets of expected behavior, measure whether responses are reliable and tool calls succeed, track token use and compare changes to find what actually helped.

• Building a set of expected conversations
• Measuring response reliability
• Tool-call success and wrong-tool errors
• Token usage and cost per task
• Comparing two versions of an agent
• Turning failures into fixes

You build An evaluation set and a before-and-after comparison for one agent change.

When an agent misbehaves in production, you need to see what it did. You read traces of reasoning and tool calls, watch usage and errors over time, and trace a bad outcome back to its cause.

• What an agent trace contains
• Reading tool calls and their results
• Dashboards for usage, errors and cost
• Finding why an agent chose the wrong tool
• Spotting loops and runaway usage
• Closing the loop with new tests

You build A troubleshooting write-up that traces one bad outcome to its cause and its fix.

Agents act with real authority, so who may build, change and use them matters. You apply access control and policy, protect personal and sensitive data, and keep people in charge of consequential actions.

• Roles for building, managing and using agents
• Access control across agents, tools and models
• Policies for what an agent may do
• Protecting personal and sensitive data
• Approval for consequential actions
• Auditing agent activity

You build An access and policy plan for an agent that touches sensitive data.

Automate one cross-functional process from request to resolution. You build the agents and tools, wire the integrations and workflow, evaluate the result, and put the controls in place that let a business trust it.

• Choosing the process and mapping it
• Building agents, tools and the workflow
• Connecting the business systems
• Evaluating and tuning
• Applying governance before release

You build A working multi-agent process with evaluation results and a governance plan.