Design Principles for AI That Acts on Its Own

Users project human-like intelligence onto conversational interfaces, creating a massive trust gap when those systems act autonomously. When Microsoft introduced Clippy in the late 90s, they understood that people tend to treat computers like social beings. The execution failed because it lacked context awareness and primarily annoyed users. Today’s agentic AI promises a system that can plan, use tools, and coordinate with other agents to solve problems. That autonomy introduces a new challenge. We must design for a system that acts on its own without alienating the person relying on it.

According to Louise Macfadyen’s 2026 book Designing AI Interfaces, the gap between what users think a system does and what it actually does remains one of the central unsolved problems in human-computer interaction. When we let AI systems act autonomously, that gap turns from a curiosity into a liability. If users do not understand the system, they will reject it in high-stakes tasks.

Key takeaways

• Reveal the plan: Build trust by making the agent’s interpretation and proposed sequence visible before execution begins.
• Prioritize what matters: Agentic systems generate overwhelming amounts of data; interfaces must aggressively filter status updates based on task stakes and user focus.
• Design for shared control: Independence without accountability creates anxiety. Maintain clear boundaries, interruptibility, and rollback capabilities.

The transition to agentic workflows

We are moving from models that generate text to systems that operate on our behalf. Macfadyen’s text outlines five core patterns that define this shift: Reflection, Tool Use, Planning, Multiagent Collaboration, and ReAct. These patterns allow AI to evaluate its own outputs, query databases, break complex goals into subtasks, and adaptively iterate on solutions.

When these engineering patterns are translated into experience design, the challenge becomes clear. A user interacting with an agent doesn’t think about multiagent coordination or ReAct loops. They just want to know if the system is doing the right thing. If the interface hides the complexity entirely, users are left with an unpredictable black box. If the interface exposes every API call and thought process, the user is overwhelmed. We must strike a balance that makes the system’s actions legible.

Revealing the plan before execution

When someone delegates a task to an agent, there is an immediate translation risk. The user expresses intent, and the agent must interpret that and decide how to accomplish it. If that interpretation happens invisibly, the user won’t know the agent misunderstood until the work is already underway or complete.

To bridge this trust gap, Macfadyen suggests making the plan visible before execution begins. An agent might propose a numbered outline of steps or a simple diagram of what will happen. This preview takes seconds to review but prevents misdirected effort, creating a natural checkpoint where human judgment can redirect the agent if the planned approach seems flawed. It serves as a contract, setting expectations about the specific scope of work the system will perform.

Prioritizing high-value information and mitigating latency

Agentic systems generate vastly more information than traditional generative AI. They produce plans, intermediate results, tool outputs, and status messages. Showing everything overwhelms the user; hiding too much causes them to lose track of progress. This becomes especially critical when considering the time it takes for these systems to operate.

A 2017 Clutch study found that 72% of app users said completing all onboarding steps in less than a minute is important in their decision to keep using an app. That impatience transfers directly to AI workflows. If an agent takes two minutes to execute a plan without providing any feedback, users will assume the system has failed. The solution lies in aggressive prioritization based on what users actually need to know at each moment.

A tiered approach to progress communication works best. At the top level, notifications provide abstract awareness. A tier-one overview keeps users oriented with minimal detail (e.g., “Analyzing competitor landscape: 60% complete”). A tier-two detailed view provides structure and explanation for users who want to verify the task is unfolding correctly. Finally, a tier-three full record supports review and debugging. The interface should adapt to the level of scrutiny users bring, allowing them to dive deeper only when necessary.

The operational value of tool use

The true value of agentic systems emerges when they interface with other tools. A tool-augmented agent can access external databases, send emails, or run calculations. This fundamentally changes the utility of the AI from an advisor to an operator.

Macfadyen highlights a case where a hardware company deployed tool-augmented agents to generate sales proposals, reducing proposal generation time by 67%. The agent accessed product databases to retrieve specifications, queried customer history for relevant context, and pulled pricing information before generating a complete, data-informed proposal document. The interface supported this by showing status updates (“Searching your calendar…”) and explicit permission requests, keeping the user informed of the agent’s actions across external systems.

Navigating agreement bias and hallucinations

When an agent acts autonomously, we assume it operates objectively. AI models possess inherent biases built into their training. In their 2022 paper, “Discovering Language Model Behaviors with Model-Written Evaluations,” Ethan Perez et al. demonstrated that models consistently exhibit sycophancy: affirming the user’s implicit assumptions rather than questioning them. If a user asks an agent to plan a marketing campaign based on a flawed premise, the agent is highly likely to agree with the premise and execute the flawed plan.

This is compounded by the persistent risk of hallucinations. As detailed in the 2021 paper “On the Dangers of Stochastic Parrots” by Emily M. Bender, Angelina McMillan-Major, Timnit Gebru, and Margaret Mitchell, large language models are trained to imitate linguistic patterns, not to reason or verify. An agent might confidently generate a plan that includes fictitious data sources or invented capabilities.

To mitigate these risks in agentic workflows, the interface must present the output not as an infallible answer, but as a verifiable artifact. Providing direct links to sources, clearly separating the agent’s reasoning from the raw data, and explicitly flagging areas of low confidence can help users catch sycophantic or hallucinated behavior before it impacts the final output.

The power of multiagent collaboration

No single agent excels at everything. The Multiagent Collaboration pattern mirrors how human organizations work by distributing tasks among specialists who collaborate toward shared goals. An engineering team might use multiple specialized agents for software development: one handles requirements gathering, another writes code, a third generates documentation, and a fourth conducts QA.

For the user experience, the challenge is what to expose. If the coordination works smoothly, users just care about results, not internal architecture. The system can abstract away the fact that multiple agents are involved. But when things go wrong, such as one agent in a pipeline failing, users need enough visibility to understand what happened and how to respond. Error messages should indicate which component failed and provide a clear path forward, transforming a coordination problem into a decision point where human judgment adds value.

Orchestrating the ReAct pattern

The ReAct pattern represents an adaptive approach where agents alternate between reasoning about what to do and taking action, then observing results and reasoning again. This loop continues until the goal is achieved or the agent determines it needs help.

From a design perspective, ReAct agents create unique challenges because their process isn’t fully determined up front. A planning agent can tell you its plan; a ReAct agent can only tell you its current thinking and what it just tried. Transparency becomes especially valuable here. Showing the agent’s reasoning helps users follow the logic and builds trust in the adaptive process. Because the agent is adapting rather than following a predetermined plan, it might discover the problem is more complex than initially apparent. The system needs clear mechanisms for the agent to recognize when it’s out of its depth and escalate to human help, providing a summary of what it attempted.

Designing for shared control and interruptibility

The promise of agentic AI is that it can work independently, but independence without accountability creates anxiety. As Macfadyen argues, users need to feel that delegating work doesn’t mean losing control over it.

Shared control requires clear boundaries about who does what, and it demands interruptibility. An agent should be stoppable at any moment without corrupting work or losing progress. When a user pauses an operation, they should see what’s been completed, what’s in progress, and what remains. The ability to undo or roll back changes makes delegation feel much safer. Ultimately, autonomy should feel like a productive partnership, where agents handle routine execution while humans provide judgment and strategic direction. As we consider designing trust into AI products, we must ensure that the interface supports a collaborative relationship and avoids a complete handover of authority.

References

• Macfadyen, Louise. (2026). Designing AI Interfaces. O’Reilly Media. https://www.oreilly.com/library/view/designing-ai-interfaces/9798341639812/
• Bender, Emily M., Angelina McMillan-Major, Timnit Gebru, and Margaret Mitchell. (2021). “On the Dangers of Stochastic Parrots: Can Language Models Be Too Big?” FAccT ’21. https://doi.org/10.1145/3442188.3445922
• Perez, Ethan, et al. (2022). “Discovering Language Model Behaviors with Model-Written Evaluations.” https://doi.org/10.18653/v1/2023.findings-acl.847