NVIDIANVIDIA-Certified Professional: Agentic AI2026-101.1 Design user interfaces for intuitive human-agent interaction.
Choose chat, copilot, form, voice, or inbox
Completed by the knowledge check
Learning objective
Choose interaction patterns: chat, embedded copilot, form-driven, voice, and asynchronous task inbox.
Core idea
Choose the interaction surface from the work the person must complete: explore an ambiguous question, revise an existing artifact, submit structured information, speak while occupied, or collect a result later. A conversational model does not make chat the right interface for every task.
Separate that product decision from the transport decision. A chat can stream over HTTP; a form can submit a background job; an embedded copilot can use either. NVIDIA NeMo Agent Toolkit exposes workflow and chat interfaces, while its supplied UI demonstrates chat and intermediate-step visualization. Compose those mechanisms into the chosen product surface.
How it works
Use chat for clarification and exploration
Chat fits requests whose missing information emerges through conversation: an employee investigating why a procurement policy applies, for example. A follow-up can clarify missing information.
NeMo Agent Toolkit distinguishes its Chat Interface from its Generate Interface. The former uses a chat-compatible interface; the latter uses the transaction schema defined by the workflow. The API server reference documents /chat and /chat/stream as legacy chat paths and /v1/chat and /v1/chat/stream as versioned paths. Versioned paths are experimental because of added HTTP human-in-the-loop (HITL) and OAuth support. For workflows using neither behavior, versioned and legacy paths are 1 compatible. Legacy routes remain registered by default; disable_legacy_routes: true removes them.
Chat spends user attention and conversation tokens to collect information that a form might obtain at once. Collect exact account numbers or date ranges in fields when clarification adds no value.
Embed a copilot beside the artifact
An embedded copilot keeps the person in a host application: a claims analyst selects a paragraph, requests a rewrite, and compares the suggestion with the original. Define the integration artifact as a workflow input schema containing the selected text, the requested operation, and the artifact identifier. The host application owns those fields and the display of the resulting suggestion.
Use the Generate Interface when that workflow-specific schema better expresses the operation than a free-text chat. Inspect the running server’s Swagger documentation at /docs; do not assume the example input_message field describes every workflow. Send the selected context rather than an entire case history when the operation needs only that selection. This reduces model input and avoids asking the person to paste material the host already has.
The cost shifts to host integration: the product team must keep the visible selection and submitted input aligned. A separate chat window is cheaper to prototype, but imposes copying and context reconstruction on every use. See 1.1.2 for showing what an operation actually did.
Use a form for bounded submissions
A form fits work with known required inputs, such as a supplier review requiring a supplier ID, jurisdiction, and reporting period. Design fields against the workflow’s transaction schema and validate the submission against that schema before starting expensive processing. The frontend team owns field labels and validation messages; the workflow owner owns accepted types and requirements.
A form can include a free-text question. Keep input validation separate from result review: a valid submission does not guarantee valid model output.
Use voice when speech removes a physical barrier
Voice suits a technician who cannot type while inspecting equipment or a meeting companion that receives spoken discussion. NVIDIA Riva ASR documents offline/batch and streaming recognition modes. In streaming recognition, the server returns an intermediate transcript as it becomes available; this creates an opportunity to display recognized text before the entire recording finishes.
Treat recognition and task execution as separate stages. For a technician’s asset identifier, expose the transcript for correction before constructing the workflow input. Voice adds recognition latency and audio processing; an intermediate transcript is not a completed business action. Riva supports simultaneous speech recognition models up to the GPU’s memory limit. For private financial details in an open office, a form may fit better even when speech is technically available.
Use an inbox when the result outlives attention
An asynchronous task inbox gives the person a submitted job and a place to return for its outcome. NeMo Agent Toolkit’s asynchronous Generate endpoint requires the async_endpoints extra, installed from PyPI as nvidia-nat[async_endpoints]. It submits background execution and returns a job_id and status; the documented legacy route is /generate/async, with experimental versioned counterpart /v1/workflow/async.
sync_timeout defaults to 0, returning immediately, and accepts at most 300 seconds. It bounds response waiting, not workflow runtime. Persist job_id in the product’s task record so the inbox can associate the eventual outcome with the original submission. The API’s optional caller-supplied job_id must be unique; submitting an existing ID returns that job’s status.
The endpoint uses Dask for jobs and SQLAlchemy for history and metadata. With nat serve, set --db_url for persistent history instead of default temporary SQLite, and --scheduler_address for an existing scheduler. Without scheduler_address, --max_concurrent_jobs sets the maximum Dask workers, default 10; concurrency also multiplies by --dask_threads_per_worker, default 1. The worker flag alone is not a job-concurrency ceiling.
expiry_seconds retains output files after job completion: default 3600, minimum 600, maximum 86400 seconds. It does not affect response text. The backend owner must align file retention with when inbox users return.
Key distinctions and trade-offs
Compare the five surfaces by the condition that decides the choice:
| Pattern | Deciding condition | Route or mechanism | Main cost and owner |
|---|---|---|---|
| Chat | Ambiguous request | Chat Interface | Clarification turns and tokens; conversation designer |
| Embedded copilot | Work inside an artifact | Generate with workflow schema | Host integration; host application team |
| Form | Known required inputs | Generate with validated form schema | Schema maintenance; workflow owner |
| Voice | Hands-free access | Riva streaming ASR feeding Generate | Recognition latency and GPU memory; speech platform team |
| Task inbox | Result arrives later | Asynchronous Generate | Dask and database operations; backend team |
Streaming reduces the wait before visible output. Background execution lets a person leave before completion. A token stream does not provide the latter merely because it stays open for several minutes.
Also distinguish an ordinary submission from a workflow that pauses for human input. The toolkit launch tutorial requires WebSocket mode for interactive workflows in its supplied UI. The HTTP Interactive Execution reference documents another path through experimental versioned endpoints, using execution IDs and polling or Server-Sent Events; OpenAI-compatible endpoints require enable_interactive_extensions: true. Check the chosen client and route together. See 10.1.2 for synchronous versus asynchronous human participation, which is a different decision from choosing an inbox for long-running work.
Architecture / decision scenario
A facilities company delivers an employee maintenance assistant. Its product owner sets three scenario requirements: technicians need hands-free capture, dispatchers work inside an existing ticket editor, and a portfolio review takes eight minutes against a 30-second interactive request budget.
Choose voice with a correctable transcript for the technician, an embedded copilot for dispatcher text revisions, and a task inbox backed by asynchronous Generate for the portfolio review. Use a form for the review’s fixed building IDs and month range. Keep chat for questions such as why a particular maintenance policy applies.
A proposed single chat screen would minimize frontend development, but makes dispatchers copy ticket text and technicians type. The eight-minute review takes 480 seconds, exceeding both the 30-second request budget and maximum sync_timeout of 300 seconds: async submission returns job_id and status before completion. The backend owner provisions persistent job history through nat serve --db_url; the product owner funds the inbox and host integration. These choices add implementation work but remove repeated interaction costs from the people doing the job.
Common exam traps
- Choosing chat because the backend uses an LLM, regardless of task structure.
- Treating an embedded copilot as an excuse to submit all host-application data.
- Confusing intermediate speech recognition with a validated action request.
- Treating
sync_timeoutas a maximum job runtime. - Assuming a streaming response provides durable background work.
- Generalizing the supplied UI’s WebSocket requirement to every documented HTTP interface.
What to remember
Use chat for ambiguity, a copilot for work inside an artifact, a form for known inputs, voice for spoken access, and an inbox for deferred results. Match each surface to its actual workflow schema, transport support, and ownership costs.
Knowledge check
A NeMo Agent Toolkit workflow, served with nat serve and the async_endpoints extra installed, produces a portfolio review that takes about eight minutes. The product’s interactive request budget is 30 seconds, and reviewers usually close the page and come back later for the result. Which design fits?
/chat/stream and keep the connection open until the review finishessync_timeout set to 480 and wait for the resultjob_id in the task recordexpiry_seconds on the asynchronous Generate request high enough to cover the eight-minute reviewjob_id and status, and the inbox uses the stored job_id to find the outcome later. A stream only shortens the wait for visible output while the connection stays open. sync_timeout bounds how long the request waits, not how long the workflow runs, and accepts at most 300 seconds; expiry_seconds controls how long output files are kept after completion.Dispatchers edit tickets in an existing ticket editor. They select a paragraph, ask for a rewrite, and compare the suggestion with the original in place. The rewrite depends only on the selected paragraph, the host application already knows the ticket ID, and the team wants to avoid copying text between windows. Which integration fits?
Field technicians cannot type while inspecting equipment, so they dictate an asset identifier to an assistant that uses Riva streaming speech recognition. The workflow then opens a work order against that asset, and a misrecognized identifier would open it against the wrong one. Which design fits?
A workflow pauses to ask the user to approve a step. The team runs it behind the NeMo Agent Toolkit’s supplied UI over its default HTTP connection, and the approval prompt never appears. Which change lets the prompt reach the user?
enable_interactive_extensions: true on the OpenAI-compatible endpointsync_timeout on the HTTP request to cover the approval waitenable_interactive_extensions belongs to that path for OpenAI-compatible endpoints; it serves a client built for it, not the supplied UI. An asynchronous job or a longer sync_timeout changes how long a submission runs or waits, not whether the client can answer a prompt.