AI and Non-linear User Interfaces

A non-linear, personalized user interface breaks away from the traditional, one-size-fits-all approach to user interaction. It is dynamic, capable of adjusting its flow based on the user's input, making the experience more engaging and efficient. The essence of this user interface methodology lies in its ability to understand and adapt to the user's preferences and needs. It creates a unique path for each user, while at the same time collecting the data needed by the application.

A Shift Towards Conversational Interfaces

A key component of non-linear interfaces is the use of conversational AI. It facilitates an interactive, dialogue-based exchange between the software and the user. Unlike traditional user interfaces that rely on static forms and predefined pathways, conversational interfaces use natural language processing (NLP) and machine learning (ML) to interpret user inputs and respond dynamically. This approach enables the user interface to ask for information in a way that feels natural and intuitive to the user, often mimicking human-like conversation.

In the example below, the form-based linear user interface on the left has been the norm for decades. It mirrors paper-based forms that we see in professional applications from patient intake forms to loan application forms. The conversational non-linear user interface on the right collects the same information, but mirrors conversations that you might have when face-to-face with a professional, such as a physician or loan officer.

The traditional form-based application has worked well for very specific information collecting, such as first name, last name, and phone number. However, it starts to breakdown when it comes to unstructured information requests, such as the user's financial goal. In cases where the user doesn't know their goal, the conversational user interface could ask a number of additional questions to guide the user towards an answer. The conversational interface could also skip questions that may clearly not apply to the user; for example if a user enters their gender as "male" in a medical application, there' no need to ask if they are pregnant?

At first thought, it would seem that a software developer could just create a wrapper around an LLM, like ChatGPT, and call it a day. However there's quite a bit more work that's necessary. This is because LLMs are designed to answer questions, not ask them.

Tendi.ai: An Example of Non-linear Data Collection

Tendi.ai offers a great example of applying non-linear user interfaces to the domain of financial advisory and data collection. Tendi.ai replaces conventional forms with a conversational AI layer. This transforms the data input experience from a series of rigid fields into a fluid, adaptive conversation. Here's a closer look at some of Tendi.ai's key components.

The backbone of Tendi.ai's user interface is a Conversational AI Engine. It is responsible for generating, interpreting, and managing conversations with users. It interacts with an LLM for understanding and generating natural language and implements custom modules for context management and personalization.

The Conversational AI Engine works closely with a Data Objective Mapper that interprets the underlying purpose of the data collection efforts. In other words, what do we ultimately need to know from the user? It applies a "data objective" design pattern to steer conversations towards achieving specific data collection goals. In the above example, there may be dozens of data objectives, such as name, employment status, personal interests, and so on. The Data Objective Mapper translates these target variables into a series of prompts that may be prioritized and asked of of the user.

Some Key Classes and Components

There are a few interesting classes within the Tendi.ai app code that are essential to making the conversational AI work.

The ConversationManager orchestrates the flow of conversation between the user and the software. It manages state and context to maintain coherence and relevance throughout the user interactions. It also includes the logic for branching conversations based on user responses and the software's data objectives. Examples of key functions include:

• initiateConversation() to start a new conversation session with a user, setting up initial context and welcoming the user.
• handleUserInput(input: String) to process input from the user and determines the next steps in the conversation flow.
• updateContext(contextUpdate: Object) to update the current conversation thread based on the latest exchange with the user.
• selectNextQuestion() to decide the next question to ask based on the conversation's current state, data objectives, and weights associated with each question.
• terminateConversation() to end the current conversation session gracefully, storing any necessary data.

There's also a LanguageUnderstandingModule class that applies NLP to parse and understand user inputs. This module leverages pre-trained models from the LLM and applies fine-tuning based on accumulated user interaction data.

• parseInput(input: String) analyzes the user's input, extracting relevant information, intent, and app-specific keywords.
• detectIntent(input: String) to identify the user's intent from their input to guide the conversation flow.
• extractEntities(input: String) to extract named entities (e.g., dates, locations, amounts) from the user's input and return actionable values.
• validateInput(input: String, expectedType: DataType) to validate user input against expected data types or formats.

The ResponseGenerator class generates responses based on the conversation context, user input, and the goals set by the Data Objective Mapper. It uses templates and generative AI models to produce varied and contextually appropriate responses. By using templates, the software can produce responses that adhere to specific conversational standards and brand guidelines. This ensures that all communications is coherent and meets user interaction quality requirements.

• generateResponse(intent: String, context: Object) crafts a response to the user based on the detected intent and current context.
• selectTemplate(intent: String) chooses a response template suitable for the intent and context of the conversation.
• fillTemplate(template: String, data: Object) populates a selected template with dynamic data to create a coherent response.
• adaptResponse(userModel: UserModel) modifies and improves a response to better suit the user's vernacular and preferences. Some users may prefer a casual vernacular while others prefer more professional.

The LearningEngine class analyzes user interactions to adapt the conversation flow and language to the user's preferences. This component uses feedback loops and reinforcement learning to continuously improve understanding and prediction capabilities. This is by far the most difficult to implement and is still a work in progress.

• updateUserModel(userInput: String, response: String) updates the underlying UserModel based on recent exchanges to refine future interactions.
• trainOnFeedback(feedback: UserFeedback) uses explicit user feedback to improve conversational strategies and response accuracy.
• adjustResponseStrategies() dynamically adjusts response generation strategies based on ongoing learning and user interaction patterns.
• evaluateConversationEfficiency() measures and evaluates the efficiency and effectiveness of conversations for continual improvement.

The DataObjective class encapsulates the overall framework that guides the conversation towards specific information goals. An instance of this class defines the parameters, expected data types, and validation rules for the data collected through the conversation.

• defineObjectiveParameters(parameters: Object) specifies the parameters and data types associated with a data collection objective.
• validateDataAgainstObjective(data: Object) verifies the collected data to ensure it meets the predefined objectives and constraints.
• determineQuestionSequence() decides the sequence of questions to be asked to fulfill the data objective efficiently.
• mapInputToObjective(input: String) associates the user input to specific objectives to track progress in data collection.

Lastly, the UserModel class encapsulates information about the user's preferences, vernacular, and interaction history. This model is continuously updated with each user interaction to enhance the system's ability to provide personalized experiences.

• setInteraction(interaction: Object) logs an interaction to build a comprehensive profile of the user's preferences and patterns.
• updatePreferences(preferences: Object) continuously updates the model with new user preferences identified through interactions.
• getPreferredVernacular() retrieves the user's preferred vernacular or speech pattern for tailoring responses.
• evaluateAdaptationSuccess() assesses how well the system's adaptations have matched the user's communication style and preferences.

Future Directions

Looking forward, there are several trends and innovations are lining-up to shape the future of non-linear user interfaces. There's ongoing improvements in NLP and AI that will enable conversational interfaces to understand and generate human language with even more sophistication. This will further blurr the lines between human-human and human-computer interaction.

Future non-linear user interfaces will also extend beyond text-based conversations and include realtime voice, video, gesture, and even emotional cues, enabling more nuanced and expressive interactions.

Conversational interfaces will become more anticipatory and proactive as AI systems become better at interpreting the context of user interactions. This will enable software to offer information and suggestions proactively before the user explicitly requests them.

Conclusion

Non-linear user interfaces mark a paradigm shift in the design of human-computer interaction. They offer a more natural, engaging, and efficient way for users to interact with software. They don't apply to every type of software, however, when a lot of unstructured data needs to be collected from the user, its very effective. The boundaries of what is possible in human-computer interaction will continue to expand as generative AI continues to evolve. This will open new avenues for innovation and fundamentally change our relationship with technology. For software engineers, embracing these advancements offers the opportunity to create more intuitive, responsive, and personalized user experiences to transform how we interact with the digital world.