IBM watsonx AI Assistant Engineer

Conversation is a design discipline, not a script. You write for the persona and tone, plan multi-turn exchanges, handle ambiguity and errors gracefully, and decide in advance when a person should take over.

• Persona, tone and vocabulary
• Designing a single turn and a full exchange
• Asking for missing information without frustrating users
• Disambiguation and confirmation
• Recovering from misunderstanding
• Designing the handoff to a human agent
• Accessibility and plain language

You build Annotated conversation flows for two use cases, including their failure paths.

Turn designs into working assistants. You build actions and steps, store and reuse information in variables, branch on conditions, reuse parts across actions and add fallbacks for what the assistant does not understand.

• Actions, steps and how they connect
• Collecting customer information with variables
• Conditions and branching
• Reusing logic across actions
• Fallback and escalation behavior
• Session variables and context carried between turns
• Previewing and debugging as you build

You build A working assistant that completes two multi-step tasks with fallback and handoff.

Before an assistant can answer, it has to decide what was asked. You write training examples that separate similar requests, test how the assistant routes them, and fix the confusions that testing exposes.

• How the assistant matches a request to an action
• Writing varied, realistic example phrases
• Overlapping requests and how to separate them
• Testing routing with held-out phrases
• Reading a confusion between two actions
• Keeping examples current as products change

You build A routing test set and the changes it drove in the assistant’s examples.

Large language models add flexibility and new risk. You decide where generation helps and where a scripted answer is safer, shape prompts, choose models, and limit what the assistant may say.

• Where generation helps and where scripts are safer
• Prompting a model for tone and format
• Choosing a model for cost, speed and quality
• Limiting answers to approved topics
• Dealing with hallucination in customer-facing answers
• Mixing generated and authored responses

You build An assistant that combines authored actions with generated answers inside set limits.

Much of what customers ask already exists in documentation. You connect a search source, prepare content so retrieval finds the right passage, and make the assistant answer from it with a trace back to the source.

• Connecting a search source to the assistant
• Preparing documents for retrieval
• Grounded answers and source citations
• Handling questions the documents do not answer
• Keeping the knowledge base fresh
• Evaluating answer quality on a question set

You build A document-grounded answering feature with a tested question set.

An assistant that cannot look up an order or reset a password is only a talking FAQ. You describe back-end APIs as extensions, authenticate to them safely, map responses to variables and handle slow or failing services gracefully.

• Custom extensions from an API description
• Authentication: API keys and OAuth
• Passing user data to an API call
• Mapping API responses into conversation variables
• Timeouts, retries and error messages users understand
• Webhooks and custom logic
• Protecting personal data in transit

You build An assistant that looks up a record and completes a transaction through a real API.

Users meet assistants on websites, phones and messaging apps. You publish through those channels, separate drafts from live versions, verify who is asking, and keep a path to roll back a bad release.

• Web chat, phone and messaging channels
• Draft and live environments
• Versions and releases
• Verifying the user’s identity
• Connecting live-agent handoff
• Rolling back a release safely

You build A published assistant on two channels with a documented release and rollback process.

An assistant is never finished once users arrive. You build regression tests, read conversation analytics, find where users drop out, and run a steady loop of improvement driven by real conversations.

• Regression tests for conversations
• Containment, fallback and escalation rates
• Finding where users abandon a flow
• Reviewing conversations for improvement ideas
• Prioritizing fixes by impact
• Reporting results to the business

You build A test suite and an improvement backlog built from conversation analytics.

Assistants handle personal data and can be manipulated. You protect sensitive input, set retention rules, defend against attempts to push the assistant off-topic, and make sure users know they are talking to a machine.

• Redacting sensitive data in conversations
• Retention and access to logs
• Prompt injection against assistants
• Content safety and refusal behavior
• Disclosure that the assistant is automated
• Reviewing a design for privacy risk

You build A privacy and abuse review of an assistant with the fixes applied.

Take one business brief through the whole job: scope, conversation design, build, generative features, integration, deployment and measurement. You present the assistant and the evidence that it serves users well.

• Reading the brief and scoping the work
• Designing and building the core flows
• Adding retrieval and back-end integration
• Deploying and testing with real conversations
• Presenting results and next steps

You build A live assistant with a design record, a test suite and a results review.