As digital experiences continue to evolve, so does the role of the designer. We’re moving beyond static pages and linear user flows into a new realm of dynamic, intelligent interactions where users aren’t just navigating content – they’re engaging in conversations with systems that can understand intent and deliver meaningful, personalized responses.
In this expanding era of agentic experiences, powered by tools like Agentforce, design thinking must extend beyond the screen. Today’s designers need to consider how knowledge is structured, how language is interpreted, and how systems reason through complexity.
To help navigate this shift, here are some foundational concepts every designer should understand when working with agentic or AI-assisted experiences, along with practical ideas for applying them today.
Here’s our list of agentic concepts for designers:
Knowledge graphs
Semantic relationships
Taxonomy
Ontology
Structured vs. unstructured data and metadata
Function calling and Model Context Protocol (MCP)
Other helpful agentic concepts
Knowledge graphs
Think of a knowledge graph as a map of how ideas connect. Instead of organizing content into folders or lists, it links related concepts like “reset password,” “billing settings,” or “support agent” and shows how they relate to each other. It’s how machines start to understand meaning, not just words.
Knowledge graphs give systems the ability to infer intent, even when users don’t say things perfectly. For example, if someone types “I can’t log in,” a system powered by a knowledge graph can follow connections to topics like password resets, multi-factor authentication, or login policies, and then deliver the most relevant response.
What it means for users: Knowledge graphs help systems respond faster and more accurately, even when customers use vague or nonstandard language. That means fewer dead ends and more helpful, personalized support.
What it means for designers: You’ll need to think in modules, not pages. Break content into meaningful units that can be tagged, linked, and reused across different scenarios. Collaborate with knowledge engineers to make sure your content is both understandable and discoverable within the graph.
Semantic relationships
While knowledge graphs create structure, semantic relationships bring meaning. These are the connections that help systems understand how ideas relate, even when the words are different. For instance, “resetting my login credentials” and “change password” might look different on the surface, but semantically, they mean the same thing.
Traditional search tools often rely on keyword matches, but agentic systems work by interpreting intent. They recognize that people say things in lots of different ways, and they respond based on what those words mean, not just how they’re written.
What it means for users: Semantic relationships make interactions feel more natural. Customers can use their own language, and the system still knows what they mean. This improves search accuracy, accessibility, and overall experience.
What it means for designers: Design for intent, not just expression. Think about the different ways users might ask for the same thing and work with knowledge engineers to define those relationships. This creates a more inclusive, adaptable system that meets users where they are.
Taxonomy
A taxonomy is a way of organizing information so that systems and people can find what they need. It creates categories and subcategories, often based on things like product, task, user role, or lifecycle stage. Think of it as the backbone that keeps content structured and navigable.
A strong taxonomy helps both humans and machines understand where something belongs and how it relates to everything else. It plays a major role in making content searchable, relevant, and easy to deliver in the right context.
What it means for users: A clear taxonomy improves the findability of content. When the system knows how everything is categorized, it can surface the right answers faster, with less effort from the user.
What it means for designers: Label content using language your users actually use. Collaborate with content strategists, information architects, and ontologists to build category systems that reflect real-world mental models. Watch how people search and ask questions—those patterns reveal what your taxonomy should prioritize.
Ontology
If taxonomy defines what things are, ontology defines how they interact. It defines roles, rules, and relationships between pieces of information. Ontology describes core concepts in a domain, and gives a system its reasoning power. It helps the system make informed decisions based on the relationships between things.
For example, an ontology might express that a user has an account, which has a billing plan, which includes a subscription, which is governed by terms. This lets the system answer more complex questions like “Can I transfer my subscription to another user?”
What it means for users: Ontology allows the system to understand context and make logical connections. That leads to smarter responses and more personalized experiences based on who the user is and what they’re trying to do.
What it means for designers: Understand the rules behind the system. If you know how different objects relate and what logic drives the experience, you can design flows that feel intuitive and responsive. Collaborate closely with the teams building the ontology to make sure your content fits the logic model.
Agentic systems run on data, but not all data is created equal. Structured data is organized and easy for machines to understand. Think of form fields, dropdowns, or database entries. Unstructured data is messier. It includes things like chat transcripts, emails, or help articles. These need to be enriched or restructured to be useful in a conversational system.
Metadata adds an extra layer of intelligence. It describes content using attributes like topic, audience, or intent. This helps the system know what the content is about and when it should be used.
What it means for users: Structured content and metadata help systems deliver faster and more accurate responses. Customers get answers that are relevant to their specific context, even if they don’t ask perfectly.
What it means for designers: Create modular content that can be tagged consistently and reused across different situations. Work with engineers and strategists to convert unstructured content into structured assets. The more clearly the system can “see” your content, the better it can use it.
Function calling and Model Context Protocol (MCP)
As intelligent systems become more powerful, designers are being asked to think not just about content and layout but about logic, orchestration, and how AI systems actually work. Two foundational concepts are emerging in this space: Function calling and MCP (Model Context Protocol). They might sound similar, but they serve very different purposes. And more importantly, they work best when used together.
To help you understand the difference and design more effectively for AI-powered experiences, here’s what you need to know.
Function calling
Function calling enables large language models (LLMs) to decide what tool to use and when to use it. It structures a request to an external tool using predefined parameters and is typically scoped to a single application or environment.
For example, if a user asks, “What’s the weather today?” an LLM can recognize the need to fetch weather data, format a request using the appropriate function, and call the tool. However, the actual execution and logic behind the tool remain outside the LLM – it simply initiates the action.
What it means for users: Function calling helps AI systems take action. Instead of just answering questions, they can interact with APIs, databases, or services to return more dynamic and useful results. That leads to smarter, more proactive experiences.
What it means for designers: You’ll need to think modularly and define clear, structured ways for your system to express intent. Design interactions where user inputs can be translated into structured data. You will also want to understand the tools available and how the system determines when to use them.
MCP (Model Context Protocol)
While function calling is about decision making, MCP is about standardization. It defines a universal protocol for how tools are exposed, described, and accessed across systems. MCP separates tool implementation from consumption, allowing any compatible AI to discover and use tools without needing to know how they work behind the scenes.
What it means for users: MCP creates a more consistent experience across AI platforms. A tool built once can be used anywhere, increasing reliability and reducing fragmentation across applications.
What it means for designers: Design for an ecosystem, not just a single application. With MCP, tools can be shared, reused, and scaled across platforms. Your designs should assume that tools are modular and standardized, and that the systems you are designing for might be calling tools developed by other teams and even other companies.
How they work together
Think of function calling as the decision engine and MCP as the infrastructure that makes those decisions usable at scale.
- Function calling answers the question: What tool should I use and when?
- MCP answers the question: How do I find and access that tool in a standardized way?
For example:
- Function calling: “I need to check the status of an order.”
- MCP: “Here is a standardized way to connect to any order status tool, regardless of where or how it was built.”
Why it matters
MCP could become a common and reliable layer that allows systems to interoperate and developers to focus on building great tools without constantly reinventing the backend.
Function calling and MCP are not competing technologies. They are complementary, and together they enable a future where AI systems can act intelligently and scale efficiently.
What it means for designers: You can build for interoperability and assume tools will live in shared ecosystems. And you can design modular, composable experiences that can flex across systems.
What it means for companies: Organizations that adopt both standards early will be positioned to deliver faster and more consistent AI experiences. You are not choosing between function calling or MCP. You are designing with both.
In an era where systems are becoming more agentic, understanding how they choose and access tools is no longer optional. It is the foundation for designing experiences that are intelligent, adaptive, and built to last.
Other helpful agentic concepts
Beyond the foundational building blocks, here are a few more agentic concepts for designers worth exploring:
Intent modeling: Agentic systems don’t just interpret what users say – they try to understand what users want. This process helps the system decide what action to take or what content to show. Designers can support intent modeling by identifying common user goals and ensuring the interface cues users toward clear, goal-oriented phrasing.
Disambiguation: When a query could mean multiple things – like “cancel,” which could refer to a subscription, a support case, or a scheduled task – the system needs a way to clarify. Thoughtful design makes these clarifying moments feel natural and helpful rather than robotic or frustrating.
Conversational turntaking: Traditional interfaces assume one-way communication. Conversational systems require back-and-forth interaction, where the system may ask follow-up questions or respond in stages. Designers need to consider pacing, tone, and how much information is exchanged in each conversational turn.
Knowledge engineering: This is the discipline of structuring and maintaining information so it is machine-readable. Keep in mind that designers don’t need to become engineers, but partnering with knowledge experts ensures that your content and UI choices can be surfaced effectively by the system.
Shaping knowledge ecosystems
The shift toward agentic experiences is not just about integrating AI; it’s about transforming how we think. We’re no longer designing static menus and screens; we’re designing systems that understand intent and logic. Designers now play a crucial role in shaping knowledge ecosystems that connect content, context, and conversation.
The future of support is about conversations, and those conversations require designers who know how meaning is made, modeled, and delivered. To succeed in agentic environments, focus on knowledge work, not just visual design. The future is intelligent, interconnected, and user-centered, so stay curious, stay open, and design with the system in mind.
