User Autonomy in Design Frameworks

Have you ever looked at an extremely skilled design team and felt like their output was largely middle-of-the-road or generally unextraordinary? It's usually from a structural leadership bottleneck. Giving highly competent people hard restrictions strips away their autonomy, turning a complex heuristic problem into a mindless, algorithmic task. And the data backs this up. Haaaaaaaard... Sam Glucksberg ran a version of the famous 1945 candle problem experiment out of Princeton University: Two groups, same creative task. One group was incentivized. The other wasn't. The incentivized group took 3.5 minutes longer to solve the problem. According to Daniel Pink's related framework, structure helps with routine work, but for creative work, external control narrows cognitive focus and actively diminishes problem-solving. Design is a heuristic discipline so every brief is essentially its own candle problem. Delf-determination theory reinforces this from the motivation side—for people to do their best work, three psychological needs have to be met: → Autonomy, or the freedom to choose how → Competence, or the ability to exercise mastery → Relatedness, or feeling connected to the team and mission Strip away autonomy and you bottleneck your most capable people with your own cognitive limits. Robert House's path-goal theory says directive leadership is effective for inexperienced workers facing ambiguous tasks, but for high-ability, high-experience people it becomes redundant and is regularly perceived as micromanagement, which tanks satisfaction and motivation. Google confirmed this at scale via a Project Aristotle study, which analyzed 180+ teams and found that psychological safety is the single strongest predictor of team effectiveness. So here's what actually happens when you over-direct senior creatives: ☒ You pay a premium for their brain ☒ You micromanage the execution ☒ Their cognitive capacity gets bottlenecked by your instructions ☒ The result: friction, churn, and expensive people producing forgettable work High-level talent minus autonomy equals a massive pile of technical debt. Management research call the solution "loose-tight leadership": ☑ Tight on the what: Clear goals. Defined constraints. Hard success criteria. Non-negotiable timelines. ☑ Loose on the how: Total flexibility on process. Trust in execution. Room to experiment. Smart designers don't want a blank canvas. They want a defined sandbox with clear parameters and freedom to achieve the goals their own way. So the TL;DR for design leadership: Get the hell out of their way! 😂 Which side of this equation is your team currently stuck on — unclear boundaries, or zero autonomy? #designleadership #productdesign #uxstrategy #designops #creativeleadership ⸻ 👋🏼 I'm Dane—a designer creator + mentor. 🙃 Rated PG-13 for hard facts + adult language. ❤️ If you liked this post a 👍🏼 would be the bee's knees. ➕ Follow for more of my shenanigans in your feed.

"A Multifaceted Vision of the Human-AI Collaboration: A Comprehensive Review" provides some interesting and useful insights into effective Humans + AI work, drawn from across the literature. Some of the specifics insights in the paper: 🧭 Use the five-cluster framework to tailor collaboration depth. The framework defines five types of human-AI collaboration: (1) Humans as optional tools, (2) Consensus-based coordination, (3) Asynchronous collaboration, (4) Humans and AI as co-agents, and (5) Humans directing AI. Choose the type based on your task: use cluster 1 for personalization (e.g. recommender systems), cluster 2 for group decision-making, clusters 3 and 4 for task co-execution, and cluster 5 when human judgment must lead the process. 🧠 Let humans steer the learning loop. Design workflows where human feedback isn't just collected but actively changes the model. Show users how their input influences outcomes, and ensure systems update based on their corrections—failing to do so erodes trust and engagement fast. 🔄 Support iterative improvement through clear feedback cycles. Let users provide input at multiple points in the workflow—before, during, and after AI output. Use real-time feedback, editable suggestions, and memory-based personalization (e.g., saving past preferences) to refine collaboration with each loop. 📣 Grant users communication initiative. Don’t restrict user interaction to predefined prompts—enable them to ask questions, challenge decisions, or suggest new directions. This increases user autonomy, supports trust, and improves performance in both individual and group collaboration. 🛠️ Customize AI outputs to user-specific contexts. Embed features that allow tailoring of recommendations, predictions, or decisions to individual preferences or needs. For example, let users tweak rehabilitation goals in health tools or input content preferences in recommender systems. 🤖 Use AI as an impartial coordinator in group settings. In scenarios with multiple human participants—such as disaster planning or multi-user workflows—deploy AI to synthesize input, allocate tasks, and reduce bias. Ensure the system is transparent and users can reject or adjust AI decisions. 🔐 Prioritize human-centered design values. Build systems that are transparent (explain why outputs were generated), trustworthy (learn from user feedback), accessible (usable by non-experts), and empowering (give users control over high-level behavior). These are essential for lasting, ethical collaboration.

Here's the uncomfortable truth: we're building AI platforms using the same playbook that gave us surveillance capitalism. We start with powerful technology that promises to empower users. We bundle it with convenient features. We optimize for engagement metrics. And before we realize it, we've created systems that constrain the very people they're meant to serve. When our business models depend on keeping users engaged rather than helping them accomplish goals, platform success conflicts with user success. To break this cycle, I outline the Three As framework: ✓ Acceleration - Make users capable, not dependent ✓ Autonomy - Separate compute from context ✓ Accountability - Optimize for outcomes, not engagement The future of AI should look like the cloud revolution—composable, federated, user-controlled. Not social media consolidation. Full article: https://lnkd.in/gA645mQe What patterns are you seeing in AI platform architecture? #PlatformEngineering #AI #SystemsThinking #architecture

We’re leaving “assistants in apps” behind and entering the era of autonomous systems that perceive, reason, act, and learn. The research from University of Oxford is clear: UX must shift from guiding users through procedures to systems that take a goal, execute safely, and return a verified result with an audit trail. Agents can plan, coordinate tools/APIs, adapt from feedback, and carry memory forward. Our job moves from arranging screens to specifying goals, guardrails, and governance. ↳What to design next? ➤ Delegation over steps: Users set objectives and constraints; agents handle multi-step execution. ➤ Receipts for autonomy: Preview the plan, explain actions, expose confidence/provenance. ➤ Reversibility: Approve/modify before execution; one-tap rollback after. ➤ Safety as telemetry: Adversarial tests, shadow runs, and thresholds treated like uptime SLOs. ➤ Inspectable memory: Show what was learned; let users review, edit, or forget it. ↳Forward-thinking questions: ➤ Where can users delegate an outcome instead of a procedure? ➤ How do we surface confidence fast enough for oversight? ➤ What’s the rollback path for every action? ➤ How is memory exposed and controlled? Design the contract well, and autonomy becomes usable, trustworthy, and shippable. Trust is currency. 💰 ---- Inspired by: Michael Negnevitsky (author)

Ever watch your learners' engagement gradually fade in a digital experience, despite compelling content? It’s a common frustration, but often the solution lies in a fundamental human need: a true sense of control. That feeling hit me yesterday on a long bike ride around the island I live on, gazing across the bay at San Francisco in the distance. That expansive view, with its implied freedom to choose any path towards that distant goal, powerfully mirrors the allure of well-designed exploratory experiences. It’s this spirit of exploration and self-directed discovery that games like the recent Zelda titles capture so brilliantly. As I explored in a previous article for UX of EdTech on how games create deep flow (link in comments), a key is empowering users: "Instead of the game dictating where you go and what you do, it offers a vast, interactive world and the tools to explore it freely... empower[ing] you to define your own goals, experiment with solutions, and ultimately control your own adventure." This principle is deeply rooted in motivational psychology. Self-Determination Theory, for instance, highlights that fostering a sense of autonomy (or control) is critical for intrinsic motivation and deep engagement. When individuals feel they have meaningful choices and can direct their own path, their persistence and mastery skyrocket. For EdTech and learning platforms, this means designing experiences that provide learners with genuine options to exercise autonomy – perhaps through choices in learning methods, tools, resources, or allowing them to set their own pace and goals. It’s about shifting from dictating a path to providing a landscape for supported discovery. How are you empowering your users with a sense of control? What does their adventure look like? #UserEngagement #EdTech #LearningDesign

👨🏻✈️ From Copilot to Commander: A Practical Framework for AI Agent Autonomy 👉 As AI agents become more capable, how much autonomy should they really have and who decides? A recent paper “Levels of Autonomy for AI Agents” (Feng, McDonald & Zhang) introduces a framework for defining and certifying autonomy levels in AI agents. 😎 This is not about what the agent can do, but what it should be allowed to do, based on human-AI interaction roles. The framework defines five levels of autonomy (related to the user oversight/control position): Operator – Full user control Collaborator – Shared decision-making Consultant – Agent recommends, user decides Approver – Agent acts, user reviews Observer – Agent acts fully autonomously 🔍 Some Take Aways: 👉 Autonomy as a Design Choice: Deliberately set by developers—distinct from AI’s technical capabilities or environment. 👉 User-Centric Framing: Clarity around how user engagement scales down as agent autonomy increases. 👉 Governance Innovation: Introduces idea of Autonomy Certificates, enabling standardised disclosure of an agent’s operational autonomy level. 👉 Evaluation Strategy: Proposes assisted evaluations, where a user (human or AI) supports the agent in tasks, then feedback captures the actual autonomy demonstrated 🎯 Practical Implications 👉 Governance & Compliance: Annotating agent autonomy levels helps stakeholders assess risks, responsibilities, and trust. 👉 Security & Ethics: For safety-critical systems, limiting autonomy or ensuring user oversight becomes easier when autonomy is defined and certified. 👉 Design & UX Clarity: Developers can clearly define user roles, set interaction expectations, and match autonomy to task criticality. 👉 Multi-Agent Coordination: In systems where both humans and agents interact, autonomy certificates help align expectations and capabilities across agents 🤓 Bottom line: as agentic applications are getting momentum governance and compliance regulations (like the EU AI Act) require structured, explainable implementations - the systematic approach for categorisation of the authors can be of help in this context 🔗 to the paper in the comments #artificialintelligence #agents #law #innovation #governance

Anthropic just published its framework for safe AI agents, and for us UX folks, it's a interesting but familiar read. Because it’s not just about safety protocols; it’s a description of human-computer interaction principles being applied to agent development. The framework for building a trustworthy AI agent looks a lot like the heuristics we've been using to design good products for decades. Autonomy vs. Control: Anthropic frames this as a "central tension." In UX, we call this "User Control and Freedom." It’s the ultimate design challenge: give the user (or the agent) enough autonomy to be useful, but always provide a clear "off-ramp" or approval gate. It’s about designing a partnership. Transparency in Agent Behavior: They talk about a "real-time to-do checklist." We call this "Visibility of System Status." The user should always know what the system is doing and why. Their example of an agent explaining its reasoning for contacting the facilities team is a perfect illustration of showing the "why" behind the "what." Aligning with Human Values: This is the core of UX. It's the difference between what a user says and what they mean. The example of an agent "organizing files" by deleting everything is a classic case of a system acting on literal instructions without understanding user intent. Our job has always been to bridge that gap. Privacy & Security: For us, this is the foundation of user trust. No matter how brilliant the functionality or seamless the interface, if a user doesn't trust the system with their information, the experience has failed. It’s the non-negotiable baseline. This framework shows that as AI becomes more autonomous, the principles of user experience design don't become obsolete; they become mission-critical. It’s an exciting time to be a designer. #GenAI #AIDesign #Anthropic #AgentDesign

Most leaders obsess over features and roadmaps. This is a mistake. Leadership is about psychology. Yes your technology matters. Your service's are what get bought and drive your revenue. No doubt. But the real leverage? >> Understanding what drives human behavior >> both in your consumers and in your teams. That’s why all Leaders (Especially product leaders) Should Care About Self-Determination Theory (SDT) from Ed Deci, PhD and Richard M Ryan, PhD. It tells us that people thrive when three psychological needs are met: Autonomy – the sense of choice and control. Competence – the feeling of mastery and progress. Relatedness – the connection to others and shared purpose. Now apply this lens in two directions: 1. Your Users Autonomy: Design products that empower choice and give people a sense of control. Competence: Give feedback loops that help them feel progress and make incremental investments. Relatedness: Build communities, rituals, and shared identity around your products. 2. Your Teams Autonomy: Trust your engineers and designers by empowering decision-making and work to eliminate micromanagement. Competence: Invest in skill growth and celebrate progress, not just outcomes. Create an adaptable team. Relatedness: Create bonds beyond Jira tickets. Share wins, create the stories. measure relationships. Here’s the kicker: When you align SDT for both users and teams, you designing for intrinsic motivation. That’s how momentum compounds. And SDT is one of the sharpest tools you can put in your kit. I have the deep honor of presenting some of these ideas at the INDUSTRY leadership forum (Mind the Product) on September 8th in #Cleveland and intend to have a meaningful conversation with John Cutler there on these ideas. Sean Murray and Daniel Sharp will be interviewing him for the ITX Corp. podcast. I can't wait. I'll also be sharing some of these concepts for Mind the Product in #NewYork & #Chicago in October if you can't make Cleveland! Links in the comments. I would love to hear your thoughts/challenges on the importance of understanding motivation in the comments below. #Momentum #SelfDeterminationTheory #SDT #SoftwareProductLeadership

Building Trust in Agentic Experiences Years ago, one of my first automation projects was in a bank. We built a system to automate a back-office workflow. It worked flawlessly, and the MVP was a success on paper. But adoption was low. The back office team didn’t trust it. They kept asking for a notification to confirm when the job was done. The system already sent alerts when it failed as silence meant success. But no matter how clearly we explained that logic, users still wanted reassurance. Eventually, we built the confirmation notification anyway. That experience taught me something I keep coming back to: trust in automation isn’t about accuracy in getting the job done. Fast forward to today, as we build agentic systems that can reason, decide, and act with less predictability. The same challenge remains, just on a new scale. When users can’t see how an agent reached its conclusion or don’t know how to validate its work, the gap isn’t technical; it’s emotional. So, while Evaluation frameworks are key in ensuring the quality of agent work but they are not sufficient in earning users trust. From experimenting with various agentic products and my personal experience in building agents, I’ve noticed a few design patterns that help close that gap: Show your work: Let users see what’s happening behind the scenes. Transparency creates confidence. Search agents have been pioneer in this pattern. Ask for confirmation wisely: autonomous agents feel more reliable when they pause at key points for user confirmation. Claude Code does it well. Allow undo: people need a way to reverse mistakes. I have not seen any app that does it well. For example all coding agents offer Undo, but sometimes they mess up the code, specially for novice users like me. Set guardrails: Let users define what the agent can and can’t do. Customer Service agents do it great by enabling users to define operational playbooks for the agent. I can see “agent playbook writing” becoming a critical operational skill. In the end, it’s the same story I lived years ago in that bank: even when the system works perfectly, people still want to see it, feel it, and trust it. That small "job completed" notification we built back then was not just another feature. It was a lesson learned in how to build trust in automation.

Six principles for human-centered agent design (the ADEPTS capability framework): The defining quality of an AI agent is to act autonomously, to do things for you. As an AI agents researcher and practitioner that is most likely the prime capability you should be working on. But I think it is far from being the ONLY ONE you should be working on. As the adoption of modern LLM-based AI agents grows, as people start to use them in their everyday life, it is becoming apparent that there is more to them than mere task execution. So what should an agent be capable of in order to smoothly help people? Here are six principles that I think could guide human-centered agent design: (A) Autonomous Actuation: The agent should autonomously execute tasks on the user’s behalf, translating intent into actions according to the permissions granted by the user and the constraints enforced by the agent designer. (D) Intent Disambiguation: The agent should actively clarify and confirm the user’s goal, context, and constraints whenever uncertainty could alter the outcome. (E) Situational Evaluation: The agent should track task progress and overall context, surfacing status and providing answers for the user to understand the current situation or resume control. (P) Adaptive Personalization: The agent should learn and predict the user’s evolving preferences and abilities, and respect them while executing tasks. (T) Operational Transparency: The agent should expose its inputs, reasoning, plans and past actions to the user at a depth suitable to inform oversight and to build trust. (S) Proactive Safety: The agent should pre-emptively prevent harm to people, data, or property, enforcing privacy, security and ethical constraints before and during execution. Together, these capabilities form the ADEPTS framework. It is an agent capability framework drawing from the design principles provided by pioneers such as Jakob Nielsen and Don Norman, to inform agent design. ADEPTS may not cover every detail required for building usable agents, but I think it's a pretty good mnemonic to remember or discuss some of the essential elements around human-centered agent design. ADEPTS is a user-facing capability contract. It does not prescribe the how, how an agent should do something, or how something should be surfaced to a user. It prescribes the what, what the agent should do for a user. It leaves all the creative freedom to designers, engineers, researchers, practitioners. Want to learn more? Read our paper (in the comments), which comes with examples for different types of AI agents and guidelines for designing capability tiers.