We are moving beyond simple assistants. Today's agents act with greater autonomy, coordinate across systems, and collaborate with humans in nuanced ways. To support this shift, our product design team has developed research-backed principles and patterns for creating systems that are transparent, trustworthy, and truly collaborative.
Five ideas for trustworthy agent experiences that prioritize human control and agency.
Let the Human Set the Rules
What it means
Humans guide how agents operate by setting boundaries, preferences, and intent. Rather than making assumptions, agents respond to this direction with flexibility. Control doesn't mean limiting autonomy, it means aligning it with human goals.
Why this matters
People are more likely to trust and engage with agents when they understand how decisions are made, and can shape them. Giving users control over behaviors, permissions, and preferences makes the system feel collaborative and intentional, rather than unpredictable.
Interaction example: Instruction / Scope
Instruction mode
Users define interaction boundaries by selecting input modes, guiding the agent to operate safely within intended, user-controlled scopes.
Task specific boundaries
Specific checkboxes define what the AI is allowed to change (e.g., title edits) and what it must avoid. These help define clear behavioral constraints.
Overview
This configuration file defines preferences and settings for automated review and analysis of changes, with a focus on new settings. It supports automation, best practice recommendations, and change assessments.
Title and Description Guidelines
Summary of Changes
1. What is the Instruction / Scope pattern in this context?
2. What does a typical user action look like?
3. What does the system (agent) do upon receiving the file?
Interaction example: Authority Sliders
Interaction example: Kill switch and preview modes
Immediate agent shutdown
A prominent "Disable Agent" toggle gives users a fast, irreversible way to halt all agent activity. This supports emergency intervention and restores user authority instantly.
Visible control settings
The system shows settings upfront allowing the user to assess whether to make decisions based on risks and live situations.
Agent Control Panel
Current Activities
Approval Load *
Over-reliance on implicit controls
Assuming users understand what the agent is doing without clear communication
Boundary creep
Agents gradually take on more than intended without safeguards or oversight
Ambiguous authority
It is unclear if the agent or the human is responsible for the task, especially in case of failure states
Hidden behavior
The agent performs actions without surfacing intent or outcomes to the user
Show the agent's reasoning
What it means
Agents should make their reasoning, context, and confidence visible. Instead of acting like black boxes, they show how decisions are made so users can understand, question, or adjust them.
Why this matters
People make better decisions when they understand how an agent reached its conclusion. Clarity helps users spot errors, judge reliability, and decide when to lean in or push back.
Interaction example: Inline Rationale
Agent's reasoning surfaced
The agent labels its own decision logic, making invisible prioritization visible so users can understand, question, or reorder.
Scope of impact
Quantified impact badges let users grasp real-world consequences at a glance — without needing to investigate further.
Contextual rationale
A brief description explains the incident's cause, supporting informed decisions without overwhelming the interface.
Description of the incident, what is causing it and more details on impact
Description of the incident, what is causing it and more details on impact
Interaction example: Diagnostic Report
Reasoning linked to confidence
Explanations are paired with certainty indicators, showing why the system believes something and how strongly it believes it. This helps users validate or challenge the logic.
Confidence levels made visible
Each insight is accompanied by a clear degree of certainty, often a percentage or visual indicator. This helps users assess how much trust to place in each suggestion.
Actions calibrated to certainty
The system tailors its suggested actions based on confidence — more assertive steps when certainty is high, and more cautious ones when confidence is low.
Low confidence is still shown
Even uncertain insights are surfaced, not hidden — but clearly marked. This promotes transparency and allows human judgment to guide next steps.
Diagnostic Report with Actionables
Interaction example: Findings with Sources
Source labels are visually distinct and clickable
The source elements are styled for immediate recognition and likely interactive (e.g., tags, badges, or buttons), improving usability and clarity.
Claims supported by cited references
Each recommendation is backed by named sources, allowing users to verify the rationale and explore more details independently.
Findings about the System
Finding 1
Recommendation about the finding
Finding 2
Recommendation about the finding
Interaction example: Suggested Actions
Consequences and benefits are explicit
Includes options with a clear summary of what it changes and what the effect will be, allowing the user to compare outcomes at a glance.
Multiple actions presented side-by-side
The interface surfaces more than one possible action instead of a single automated path. This supports user agency and accommodates different risk tolerances.
Supports informed trade-off decisions
By presenting pros and cons transparently, the system helps users make context-aware decisions, especially when no option is perfect.
Labels indicate duration and reversibility
Visual tags communicate whether an option is temporary, reversible, or long-term. This helps users understand not just the effect, but also the scope and risk.
Suggested actions to improve performance
First preferred action
Measurable impact
Second preferred action
Measurable impact
Opaque decision logic
Users can't tell why the agent made a choice
Over explanation
Flooding users with too much technical detail and overwhelming them with too much detail
Assume the agent will make mistakes, make them clearly fixable
What it means
Agents will make mistakes, what matters is how fixable they are. Recovery means giving users clear, safe ways to undo actions, correct errors, and guide future behavior. It makes systems feel less brittle and more collaborative.
Why this matters
Without recovery, even small errors can erode trust and stall progress. Clear ways to fix mistakes turn agent failures into moments of learning for both the system and the person using it.
Interaction example: Undo & Redo Support
Actions are reversible by default
The interface includes options like Undo or Revert for each automated change, giving users an immediate path to reverse agent decisions.
Justification for actions builds trust
A short, plain-language explanation helps users understand the rationale behind changes, reducing confusion and making recovery decisions easier.
Multiple levels of recovery available
Users can revert or approve individual changes or apply recovery to all actions at once. This offers both fine-grained control and bulk handling.
Agent Suggested Change
Based on recent activity the agent marked these tasks as complete and reassigned owners
Why this happened
The agent detected inactivity for 5+ days and no blocking comments, so it marked the task as complete.
Interaction example: Editable Outputs
Human-in-the-loop decision making
The interface shows multiple alternatives, but waits for the user to select one. This maintains control and avoids premature execution.
Language supports co-creation
AI's phrasing encourages collaboration reinforcing the user as the final authority, not a passive observer.
Selected output is not final
Once the user picks an option, the system surfaces editable fields instead of applying the change directly. This allows precise customization.
Alternative 1
Explanation
Measurable impact
Alternative 2
Explanation
Measurable impact
Alternative 3
Explanation
Measurable impact
Let's go with alternative 1
Sure, before I go ahead with implementing this, please confirm the following details
Interaction example: Safe Defaults
Builds trust through predictable, gradual control
Safe, consistent defaults help users gain confidence and expand control at their own pace.
Activation requires explicit user intent
Features that could affect security or behavior are opt-in only. This ensures users can explore safely and expand functionality on their terms.
Rules
Rules will ensure safe, conservative operation based on prior user interactions and best practices.
Description of the default
Description of the default
Interaction example: Escalation Paths
Manual input and escalation always available
Users can directly provide input or ask their own questions at any time, ensuring they remain in control and can override or guide the agent when needed.
Clear option to proceed independently
The "Alternate" option offers an immediate escape route — users can skip the assistant and take action themselves without friction or waiting for approval.
Important screen loaded by Agent
Agent asks a question about the screen because they cannot make a decision and need clarification from user
Failing to learn from recovery events
Failing to analyze recovery patterns can lead to repeated mistakes, missing the opportunity to learn from user corrections and improve AI performance over time
Lack of granular control
Using only high-level revision features frustrates users who want to undo specific AI actions without losing their own work, missing the need for precise, collaborative recovery
Inconsistent recovery experiences
Recovery mechanisms that work differently across different parts of the system confuse users and create cognitive overhead
Unclear recovery guidance
Users need clear explanations and recovery options when things go wrong. Vague errors and unclear paths lead to frustration and reduced trust
Design for shared effort and mutual input
What it means
Autonomous agents should act as capable partners, not just tools waiting for commands. Collaboration means shared context, back-and-forth interaction, and joint ownership of outcomes. The agent contributes ideas, takes input, and improves the work in progress.
Why this matters
Collaboration builds stronger results than automation alone. When people and agents shape outcomes together, users stay engaged and push toward more creative, effective solutions.
Interaction example: Mixed Initiative
Agent proactively initiates based on context
Allow the agent to proactively detect issues or make suggestions, especially when it has useful context the user may not.
Build on each other's contributions
Design interactions so the agent can refine its outputs in response to human edits or questions. Keep the flow continuous and collaborative.
Incidents Detected by Agent
Description
Description
Description
Description
Triage Incident
I have detected a major issue starting at 09:17 UTC. What would you like to do?
Compare it to yesterday, and exclude issue x from the analysis.
Done. Compare to yesterday's baseline, it shows a 30% decrease in traffic. I recommend rollback. Would you like to rollback.
No rollback yet. Pull logs from first — I want to check status.
Interaction example: Co-editing Interfaces
Keep AI suggestions non-intrusive
Present changes as proposals, not automatic edits. Let users review, accept, modify, or reject.
Work in shared view
Both AI and human should operate on the same content in the same workspace. Transparency builds clarity and trust.
User always has final say
The human is the editor-in-chief. AI assists, but never publishes or commits changes on its own.
Make editing modalities clear
Let users choose how the AI helps — proofreading, rewriting, suggesting changes, etc. Provide flexible control modes, not just one-size-fits-all.
Policy Editing
Policy Details Editing
Objective
A long description of policy details document added here by the human user.
Scope
Applies to all employees, contractors, and third-party users accessing internal systems via the corporate VPN.
Policy Rules
1. Rule 1 for Policy
Description of the rule written by the human. This is the rule selected and visually distinct from rest.
2. Rule 2 for policy
Description of rule
3. Rule 3 for policy
Description of rule
4. Rule 4 for policy
Description of rule
Assist
Suggestion:
"This is the recommended text for policy rule number 1"
Assistant can make mistakes. Verify responses.
Interaction example: Role Clarity & Turn Signals
Clear stage-based ownership
Break workflows into visible stages and indicate who leads each one. This reduces ambiguity and improves accountability.
Attribute every action
Label actions clearly as system-initiated or human-initiated. This helps users interpret intent and trust the flow.
Signal when it's the user's turn
Use prompts, buttons, or callouts to indicate when the system is waiting for user input. Avoid passive steps that could confuse ownership.
Agent action review required
Waiting for reviewStatus
Description
Description of the agent action
Agent Rationale
Actions
This change is pending your review. It will not move forward until approved. Upon confirmation, it will proceed to peer review for secondary validation.
Lack of transparency
Users don't understand how to influence the agent or override agent actions
Assumed alignment
The agent acts without confirming intent or context
Rigid flows
The system doesn't adapt when users try to collaborate or redirect
Binary choices
Only offering accept/reject rather than co-create options
Make agent behavior visible, searchable & open to review
What it means
Traceability ensures agent decisions can be reviewed, understood, and improved over time. It makes behavior accountable across sessions, users, and workflows supporting debugging, learning, and workflow improvements.
Why this matters
As agents evolve, so do their decisions. Traceability allows teams to track changes, understand outcomes, and stay aligned in multi-user environments. It turns opaque processes into something you can audit, learn from, and improve.
Interaction example: Action History
Make events time-stamped and ordered
List all system and human actions in a clear sequence. Timestamps build trust and help reconstruct events during audits or investigations.
Include cause and effect where possible
Show how one step led to the next. This helps users understand the rationale and logic behind changes.
Capture both automated and manual steps
Record not just user input, but also system decisions. A full picture improves transparency and enables accountability across the workflow.
Use clear, plain language
Write log entries in simple, readable terms — no code dumps or vague system jargon. Everyone should be able to follow what happened.
Failure Log
1:45 PM: Issue detected at this time by the Agent
Agent Action2:00 PM: Agent flagged to the user for optimization
Agent Action2:15 PM: Resolution by the agent, and displayed on UI
Agent Action2:30 PM: User reviews the issue
Reviewed by John Doe2:40 PM: User approves the proposed resolution
Approved by John DoeInteraction example: Visual Diffing
Use side-by-side comparisons
Display the original and updated states in parallel columns. This helps users spot differences immediately without extra mental effort.
Include the why, not just the what
Pair the visual change with a short explanation of the reason or logic behind it. This gives context and supports better decision-making.
Highlight what changed
Use color or styling to draw attention to fields or values that were modified. Don't make users guess what's different.
Let the user validate or intervene
Offer a clear way to accept, reject, or adjust the change. Visual diffs should inform action, not just display information.
Review Changes
Due to issues agent changed default value from old value to new value
Before
After
Interaction example: Behavior Tuning Over Time
Call out what triggered the change
Clearly state the condition or threshold that caused the system to respond differently than before.
Compare past vs. present behavior
Provide users a way to see what's new vs. what used to happen. This helps them understand system learning and decide if further intervention is needed.
Explain the system's current decision logic
Let users understand why the system acted in this instance and how it may influence future behavior. Indicate whether this reflects a one-time response or an evolving pattern.
Allow control or rollback
Include an option to undo, override, or adjust the system's adaptive behavior.
Routing Changes
Why this happened
Agent based on observation modified behavior of the system
Details
False consistency
The system behaves differently in similar situations
No feedback loop
Users don't see whether the action succeeded or failed
The HAX SDK gives developers everything they need to integrate agents into their apps, without losing clarity, structure, or control. Use structured schemas, prebuilt components, and clear boundaries to keep agent behavior collaborative and predictable.
Explore the SDK
