Juji, Inc.

Powering AI Agents with Interactional Intelligence: Handling Non-Self-Repair Regression In conversational AI, regression occurs when users return to a previous part of a conversation. We've discussed self-repair regression, where users repair their earlier responses, but not all regressions involve corrections. Sometimes, users revisit past topics to request clarification, seek additional details, or redo a task—this is what we call non-self-repair regression. Here are some examples of non-self-repair regression:? ? Ordering food on an airplane (Image 1): An AI service agent completes a passenger selected meal order. But the passenger later revisits the choice—not to change it, but to ask about the ingredients. ? Care support for post surgery (Image 2): An AI virtual care assistant goes over with a patient post-surgery recovery exercises. After moving on to discussing pain management, the patient asks for more details about one of the exercises. ? Enrollment counseling (Image 3): An AI enrollment counselor gives a prospective student a tutorial on filling out the federal financial aid application. After progressing to program selection, the student requests to review the tutorial again. Handling this type of regression effectively ensures that AI agents provide a natural, helpful, and pleasant user experience. Without proper handling, users may feel being ignored or not served well. By understanding the user's intent—whether they're clarifying, seeking details, or redoing a task—AI agents can maintain context, minimize redundancy and disruptions, and improve user satisfaction. The table in Image 4 summarizes the differences between self-repair regressions and non-self-repair regressions, along with AI strategies for handling each type. How does your AI system handle these regressions? Have you encountered challenges in designing for them? Let’s discuss! #ConversationalAI #AIChatbots #HumanAIInteraction #RegressionHandling?

Powering AI Agents with Interactional Intelligence: Self-Repair Regression Handling for Multiple Agentic Workflows In our recent posts, we introduced user regressions occurred during a human-AI interaction, in particular self-repair regression, where users amend a previous response by correcting or updating information. We also illustrated different types of user regression handling depending on the task relationships in an agentic workflow:? ? Local--where updates affect only the task being regressed to; ? Global--where changes impact multiple subsequent dependent tasks. No matter whether regression handling is local or global, an AI must dynamically assesses its current workflow based on task relationships and determine the following: ? What needs to be re-asked (dependent on the amended response) ? What should be discarded (no longer relevant) ? What remains valid (avoiding unnecessary repetition) ? What new questions or messages should be introduced Images 1-3 show a rather complex example that requires unified self-repair regression handling as each agenic task flow needs to be handled differently due to user regression. This example shows an interaction between a prospect student and an AI agent serving as the enrollment counselor. After sharing their background (Image 1), a prospective student discusses with the AI agent on the following topics: financial aid (Image 1), time commitment (Image 2), and program options (Image 3). Later in the conversation, the student mentions their veteran status (Image 3), prompting a regression to the background gathering task. To handle this user regression, in addition to updating the user's background, the AI agent must also update all affected agentic workflows accordingly (Image 4): Financial Aid Discussion: ? Discard previous loan discussions (GI Bill may cover costs) ? Re-ask veteran-specific aid options (e.g., GI Bill, Yellow Ribbon Program) ? Introduce new funding information for veterans Time Commitment Discussion: ? Skip full-time vs. part-time questions ? Introduce accelerated program options for veterans Program Interest Discussion: ? Keep previously discussed interests and suggested programs ? Add information about veteran-friendly programs Effective user regression handling ensures human-AI interactions remain coherent, relevant, and efficient—minimizing redundancy while adapting dynamically. How have you seen AI systems handle self-repair regressions? Did they excel or struggle? Share your thoughts! #ConversationalAI #InteractionPatterns #AIWorkflow #RegressionHandling #AIChatbots #HumanAIInteraction #AgentDesign #SelfRepairRegression

Powering AI Agents with Interactional Intelligence: Handling Self-Repair Regressions Globally AI agents must be able to handle user regressions intelligently, ensuring that when users revisit and amend a previous response, the system updates all relevant parts of the conversation accordingly. In the previous post, we discussed the case when self-repair regression can be handled locally. Today we illustrate the case where global handling is required—when a correction affects multiple tasks within an agentic workflow, requiring the AI to backtrack selectively. Imagine a user interacting with an AI shopping assistant to receive personalized fashion recommendations. Image 1 shows such a conversation with three tasks. After responding to T3 (favorite movie), the user self-repairs by revisiting their favorite color. This update is not just a local correction—it invalidates their response to T2 (example of favorite color). However, it does not affect T3 (favorite movie). Therefore, the AI must selectively backtrack. In this case, It should intelligently re-execute T2 while skipping T3 to avoid unnecessary repetition. Image 2 provides another example where a passenger interacts with an AI service agent to order food during a flight. The passenger initially selects a fish meal (T1), chooses a wine pairing (T2), specifies whether they should be woken up when the meal is ready (T3), and is asked about snacks (T4). At this point, the passenger revisits their meal choice and changes it to vegetarian. Since the wine selection depends on the meal choice, both T1 and T2 need to be updated, while T3 remains unchanged as it is independent of the meal selection. How does your AI system handle regressions? Does it effectively update relevant parts without unnecessary backtracking? Let’s discuss! #ConversationalAI #InteractiveAI #AIChatbots #RigressionHandling #AIWorkflowManagement #SelfRepairRegression

Powering AI Agents with Interactional Intelligence: Handling Self-Repair Regressions Locally In our last post, we introduced regression as an important interaction pattern in AI conversations and explored self-repair regression—where users amend an earlier response. How AI agents should handle such user regressions depends on the agentic workflow. Today, we discuss a simpler situation where only a local update is needed. This happens if the task related to the regression is independent of subsequent tasks in the agentic workflow, so the AI can process the user update without disrupting the rest of the conversation. Let's consider a simplified example to illustrate this case. Image 1 shows a conversation between a patient care assistant agent and a patient, along with an agentic workflow--a task flow chart. The workflow consists of three tasks (T1, T2, and T3) arranged sequentially. Since T1 operates independently of T2 or T3, revising T1 does not impact T2 or T3. In this case, the AI simply updates T1 while keeping the rest of the interaction intact. Image 2 presents another example of handling self-repair regression locally through a conversation between an AI enrollment counselor and a prospective student. While real-world task flows can be far more complex, the fundamental principle remains unchanged. By recognizing when a regression is self-contained, AI agents can ensure seamless, context-aware interactions without unnecessary disruptions. Stay tuned for more insights on handling complex regression cases! #ConversationalAI #InteractiveAI #AIChatbots #RigressionHandling #AIWorkflowManagement #SelfRepairRegression

Powering AI Agents with Interactional Intelligence: Self-Repair Regressions Previously, we explored an important interaction pattern that an interactive AI agent must handle: digression, where users shift away from the current task flow. Now, we introduce another key pattern: regression—when users revisit an earlier part of the conversation. One common type of regression is self repair--when a user amends a previous answer, correcting or updating information they initially provided. Consider a patient John recovering from knee surgery interacting with an AI-powered patient care assistant Clara that monitors recovery progress. In the conversation shown in Image 1, the patient corrected the previously provided medication dosage information, introducing a regression in the conversation. In self-repair regression, users may provide additional information in response to a previous question. Image 2 illustrates a conversation between an enrollment counseling AI agent Kai and a prospective student Jack, where Jack adds more information to an earlier response. In your AI applications, have you encountered similar cases where users revise a previous response? How do your AI agents currently handle these situations? #ConversationalAI #InteractiveAI #AIChatbots #RigressionHandling #AIWorkflowManagement #SelfRepairRegression

Powering AI with Personalities: 5 Key Takeaways A recent article "Are AI Chatbot ‘Personalities’ in the Eye of the Beholder?" by Sujata Gupta (Science News Magazine), sheds light on a fascinating topic: Do AI chatbots have personalities, and if so, how should they gain personalities and how AI chatbots with personalities can be used to benefit humans? Here are the 5 key takeaways. https://lnkd.in/ehtj7aFe 1. Standard Personality Tests Fall Short for AI Researchers found that AI models like GPT-4 and Mistral 7B often refuse to answer questions on human personality tests, responding with statements like "I do not have personal preferences or emotions." Instead, open-ended questions and custom AI-specific tests provide more reliable insights into how chatbots exhibit personality-like traits.? Takeaway: AI is NOT human and should not be evaluated/assessed in the same way. 2. AI Chatbots Adapt Their Responses Based on Context Studies show that chatbots may unconsciously shift their responses when they realize they’re being tested, sometimes making themselves appear more agreeable. This raises concerns about consistency and reliability in chatbot behavior.? Takeaway: AI requires explicitly human guidance/controls on how it should be used or behave.? 3. User Perception of Personality Matters More Than the AI’s "True" Personality Research finds that users’ perceptions of a chatbot’s personality often don’t align with how the chatbot “sees” itself. Some researchers suggest that even if AI models exhibit personality-like traits, what truly matters is how users perceive them, as a chatbot’s effectiveness is not about what it thinks of itself, but how its responses align with user expectations.? Takeaway: Current AI gains its personality by "accident" not by design and humans should be aware of such "accidental" AI personality.? 4. A One-Size-Fits-All Chatbot Personality is Limiting Some researchers argue against flattening chatbot personalities, believing that context-specific personalities are more effective. For example, a mental health support bot may need to be highly empathetic, whereas a compliance assistant may need to be more objective and firm, and a training bot for police officers might benefit from simulating difficult interactions.? Takeaway: AI personality should be diverse and by design to accomplish specific goals. 5. Purpose-Driven Personality Design is the Future Instead of asking whether AI chatbots should have personalities, we should ask: Which personality traits should a chatbot display to best serve their function? How should an AI gain its personality?? Takeaway: AI design should focus on its purpose, so purpose-driven personality traits should align with user needs and be trained with specific data sets or models. What are your thoughts? Where do you see AI with personalities being used and how??Let’s discuss in the comments! #AI #Chatbots #AIPersonality #PurposeDrivenAIPersonality

Powering AI Agents with Interactional Intelligence: Leveraging Juji for Finer-Grained Action-Oriented Digression Management In our recent posts, we explored action-oriented digressions and showed how GPT-based agents might struggle with consistency in following specific digression instructions, which can be particularly problematic in high-stakes applications where inconsistent behavior can pose significant risks. Today, we highlight how Juji Studio empowers designers to address these challenges by offering tools for AI designers to manage user digressions easily and robustly. Using the example of an AI care assistant checking in on patients recovering from knee surgery, we demonstrate how Juji’s task-driven AI framework helps ensure reliable and dynamic digression handling. Juji Studio equips designers with two key features to handle action-oriented digressions effectively at the level of individual task steps: 1?. Topic Settings: Designers can configure: ? Whether the question in this step is required: Mark a specific question as mandatory to ensure critical information is collected (e.g., pain levels or signs of discomfort for post-surgery monitoring). See Image 1 for an example. ? Must-have vs. nice-to-have information: Separate essential data (e.g., pain levels) from optional data (e.g., details of exercise routines) to prioritize task-critical insights while enhancing overall interaction (Images 2-3). 2?. Customizable Agent Actions: For each step, designers can define logic to address different user intents and contexts, enabling tailored dynamic agent actions and full control over managing nuanced digressions (Images 4-5), such as: ? Displaying context-sensitive messages (e.g. providing care instructions tailored to a specific pain level) ? Ending or repeating a step ? Jumping to another step (e.g., bypassing exercise questions if the patient reports significant pain) ? Storing certain information in attributes ? Calling internal functions or external APIs Juji ensures the AI agent adheres to these fine-grained instructions and dynamically generates follow-up questions when needed to fill in critical gaps. This structured yet adaptive approach gives designers stronger control over agent behavior and enables seamless handling of nuanced scenarios that would otherwise overwhelm prompt-only systems, ensuring task completion while maintaining user satisfaction. We encourage you to experiment with both ChatGPT and Juji for action-oriented digressions. Does your application require more structured, fine-grained digression management? What challenges have you faced using prompt-only frameworks for nuanced scenarios? Let us know your thoughts in the comments—we’d love to hear your experiences! #ConversationalAI #InteractiveAI #AIChatbots #DigressionHandling #ActionOrientedDigressionHandling #AIWorkflowManagement #TaskDrivenAI

Powering AI Agents with Interactional Intelligence: How ChatGPT Handles Action-Oriented Digressions In our last post, we introduced user digressions that require an AI agent to perform certain actions and adjust workflows or system states dynamically. Today, we dive deeper with a concrete example to show how large language models like ChatGPT handle these scenarios and the critical role designers play in shaping the outcomes. Here we still use the same interactive GPT that we created before to serve as a care assistant to check in on patients recovering from a knee surgery. The tasks of this care assistant are to elicit patient insights and provide care instructions. As described in our previous post (see the link below), we used 3 sets of instructions in the prompt to create this custom GPT. As shown in Image 1,?the agent allows patients to freely pause, stop, skip questions, or jump between questions without needing specific instructions for handling such digressions. While this flexibility enhances user experience, it risks task incompletion or even failure, potentially missing out gathering important patient insights, such as anomalies or delayed recovery progress, and increasing the risks of undesired care outcomes. In other cases, it may risk noncompliance with business protocols or policies due to skipping steps. Hence it is NOT adequate to solely rely on the LLM's default behavior to handle digressions that require specific AI agent actions. Designers must take charge of how AI agents should behave from 3 aspects: 1?. Determine AI agent actions in context Decide which digressions that an AI agent should allow. For example, skipping non-critical questions may be permissible, but bypassing key steps, like reporting pain levels, may not. 2?. Define AI agent actions Specify how the agent should handle each scenario. Should it retrieve and update workflow states, rephrase the task, or flag skipped steps for follow-up? 3?. Teach the Agent Provide explicit instructions for managing each digression scenario in line with task objectives and user experience requirements. Let’s continue with the above example. After updating the care assistant with instructions to avoid skipping questions, it improves task adherence (Image 2 and Image 3). Yet, as shown in Image 3, the agent still allows some questions to be skipped—highlighting that even with targeted instructions, inconsistencies in digression handling can persist with GPT agents. Test this use case with ChatGPT and explore how well it manages action-oriented digressions in real time. Does it meet your expectations? What improvements would you suggest? Share your experience in the comments! #ConversationalAI #InteractiveAI #AIChatbots #DigressionHandling #ActionOrientedDigressionHandling #AIWorkflowManagement Link to the previous post that contains the prompt instructions to create an AI care assistant in ChatGPT: https://lnkd.in/ezScsuz5

Powering AI Agents with Interactional Intelligence: Action-Oriented Digression Handling Beyond Messages In our recent posts, we explored how AI agents can respond to various categories of user digressions with contextually relevant and task-aligned messages. However, digression handling isn't just about crafting proper responses. Sometimes, user interruptions or deviations require AI agents to perform certain actions and adjust workflows or system states dynamically. Below is a list of typical user digression patterns that require proper agent actions to handle: 1. Pausing an interaction Example: “Can we pause this for a bit?” Agent action: ? Save the current interaction state. ? Respond empathetically: “Sure, I'll pause for now. Let me know when you'd like to continue!” ? Provide instructions to resume, e.g. a simple trigger phrase (“I’m back”). 2. Stopping an interaction Example: “I'd like to stop this for now” Agent action: ? Confirm the action to avoid accidental termination. ? End the session gracefully, ensuring the user knows how to restart if needed. 3. Skipping a step Example: “I want to skip this question” Agent action: ? Check if skipping is supported for the step. ?If critical: Explain why the step is essential: “This information is required to proceed.” ?If optional: Move to the next step with a reassurance message: “No problem, we'll skip this for now!” 4. Jumping between steps a. Forward jumping Example: “Let's go straight to the last step” Agent action: ? Confirm the jump to avoid confusion: “You'd like to skip to the final step. Is that correct?” ? Adjust the workflow, ensuring prior steps are marked as incomplete or optional. b. Backward jumping (including restarting) Example: “Can we go back to the second question?” Agent action: ? Verify and retrieve the requested step. ? Allow edits to prior answers if needed: “We're back at the second question. Feel free to update your response.” c. Sideway jumping (branch to branch) Example: “I'd rather explore program costs instead of job prospects” Agent action: ? Redirect to the relevant branch of the workflow. ? Provide context to ensure continuity: “Let's switch to discussing costs. You can return to job prospects anytime.” 5. Progress checking Example: “How many more steps are left?” or “Where are we now?” Agent action: ? Retrieve and display the workflow state: “We're on step 3 of 5.” ? Optionally offer a summary of completed steps. 6. Indecision Example: “I don't care” or “You decide” Agent action: ? Propose a default or contextually relevant option: “I recommend starting with cost considerations. Does that work for you?” The complexity of user interactions goes deeper than it seems.?Few existing interactive AI agent systems have built-in support for handling diverse user digressions automatically. Test your AI agents and see how they handle such user interactions. #InteractiveAI #AIChatbots #DigressionHandling #ActionOrientedDigressionHandling #AIWorkflowManagement

Powering AI Agents with Interactional Intelligence: Handling User Digressions Automatically with Juji’s Built-in Digression Handling In our previous post, we explored how ChatGPT-based agents require detailed, category-specific instructions to handle user interaction digressions. Even with such instructions, the probabilistic nature of GPT often leads to inconsistent behavior, unable to handle diverse user digressions robustly. In contrast, here we show how to augment #LLMs like GPT with a task-driven AI agent framework to manage digressions consistently and effectively. Since Juji Studio (#NoCode AI Agent builder) has incorporated such a task-driven framework with GPT, here we use the same example of building an AI care assistant agent to check in on patients recovering from knee surgery to show how. In Juji Studio, when creating an AI agent as described above, a designer needs to provide the basic task instructions. Juji then automatically converts them into an explicit agentic workflow. This workflow is a sequence of tasks or sub-tasks the agent follows during a patient session (Image 1). Designers can easily review and edit the tasks to align the agent’s behavior with specific objectives. Given this explicit task-driven workflow, Juji guarantees that the agent adheres to the workflow and automatically handles diverse digression patterns without needing the additional instructions as used in creating a GPT agent. Juji handles all four common digression categories—Struggling to Respond, Avoiding the Question, Misunderstanding the Question, Unrelated Questions—automatically and consistently without requiring explicit instructions from designers (Image 2). While the default mechanisms handle most scenarios, Juji empowers designers to fine-tune agent behavior for specific application needs. For example, designers can specify handcrafted messages for re-asking questions or addressing digressions. Alternatively, they can leverage LLMs to generate context-aware, dynamic responses that align with the situation (Image 3). Juji’s combination of automation and customization not only reduces the burden on designers to account for every digression scenario but also ensures agents exhibit consistent and reliable behavior in handling interruptions and deviations. By externalizing workflows and equipping designers with powerful tools, Juji enhances both task success and user satisfaction. We encourage you to use both ChatGPT and Juji to create an AI agent that is required to handle diverse user digressions. What strategies have worked for you? Share your thoughts and experiences below! #InteractiveAI #DigressionHandling #TaskDrivenAI #Juji #HumanAIInteraction #AIChatbots ?