> ## Documentation Index > Fetch the complete documentation index at: https://docs.agent.ai/llms.txt > Use this file to discover all available pages before exploring further. # Conversations & Sharing > Manage conversations, share your knowledge agent, and create great user experiences ## How Conversations Work When someone interacts with your knowledge agent, each interaction creates a **conversation**. Think of conversations like chat threads - they have: * **History** - All messages in the conversation * **Context** - The AI remembers previous messages * **Auto-generated titles** - AI creates descriptive names * **Shareable links** - Can be shared publicly * **Forking** - Others can copy and continue from any point Each conversation is isolated - what happens in one doesn't affect others. ## Conversation Lifecycle ``` User opens your knowledge agent ↓ New conversation created automatically ↓ User and agent exchange messages ↓ AI generates a descriptive title ↓ Conversation saved to history ↓ User can share, fork, or continue later ``` ## Auto-Generated Titles Your knowledge agent automatically generates descriptive titles for conversations after the first few messages. **How it works:** * AI analyzes the conversation topic * Generates a concise, descriptive title * Title appears in conversation history * Makes it easy to find past conversations **Examples of auto-generated titles:** * "Researching AI automation competitors" * "Creating social media campaign for product launch" * "Analyzing Q3 sales data and trends" * "Debugging authentication module errors" **You can't customize the title format**, but you can influence it through: * Clear user requests (AI titles based on main topic) * Focused conversations (don't jump between unrelated topics) If a conversation covers multiple topics, the AI typically titles it based on the first major topic discussed. ## Conversation History All conversations are automatically saved and accessible from the conversation history panel. ### Accessing Your Conversations **As the agent builder:** 1. Open your knowledge agent 2. Look for the conversation list (usually left sidebar) 3. See all conversations sorted by most recent 4. Click any conversation to reopen it **For users interacting with your agent:** 1. Conversations are saved in their account 2. They can return and continue conversations 3. History persists across sessions ### What's Saved Each conversation stores: * All messages (user and agent) * Tool calls made * Knowledge retrieved * Timestamps * Auto-generated title **Privacy note:** Builders can see conversations with their own knowledge agents. Consider this when deciding what features to enable on public agents. ## Sharing Conversations One of the most powerful features of knowledge agents is the ability to share individual conversations via public links. ### How to Share a Conversation 1. **Have a conversation** with your knowledge agent 2. **Look for the share icon** (usually top-right of conversation) 3. **Click to generate a shareable link** 4. **Copy and share** the link anywhere The link looks like: `https://agent.ai/chat/[conversation-id]` ### What Shared Links Include When someone opens a shared conversation link, they see: * **Full conversation history** - All messages in the conversation * **Read-only view** - They can read but not modify the original * **Fork option** - They can copy the conversation and continue it * **Agent information** - Who built it, description ### Use Cases for Sharing **Showcase examples:** ``` Share great examples of your knowledge agent in action: - Marketing campaigns it created - Research it conducted - Code it helped debug - Reports it generated Use these as portfolio pieces or demos. ``` **Collaborative work:** ``` Work with someone on a project: - Start conversation with your knowledge agent - Get to a point where you want input - Share link with colleague - They can fork and continue ``` **Support and troubleshooting:** ``` If something isn't working: - Create a conversation showing the issue - Share with support or the agent builder - They can see exactly what happened ``` **Teaching and examples:** ``` Create example conversations showing: - How to use the agent effectively - What kinds of questions to ask - Sample workflows end-to-end Share these as tutorials. ``` ### Privacy Considerations **Important:** Shared conversation links are **public** - anyone with the link can view the conversation. **Don't share conversations containing:** * Personal information (emails, phone numbers, addresses) * Confidential business data * API keys, passwords, or credentials * Private customer information * Sensitive internal discussions **Before sharing, review the entire conversation** to ensure nothing sensitive is included. ### Best Practices for Sharing **Do:** * Review the conversation before sharing * Share conversations that demonstrate value * Use as examples in documentation * Share success stories and use cases * Include context when sharing (explain why it's interesting) **Don't:** * Share sensitive information * Share conversations with errors if showcasing capabilities * Share incomplete conversations that might confuse viewers * Assume shared links are private (they're public) ## Forking Conversations **Forking** lets users copy a conversation and continue it themselves. This creates powerful collaboration and learning opportunities. ### How Forking Works ``` Original conversation (shared by builder) ↓ User clicks "Fork" or "Continue this conversation" ↓ Exact copy created in user's account ↓ User can now continue the conversation ↓ Original conversation unchanged ``` ### When Users Might Fork **To build on examples:** ``` Builder shares: "Here's how to research competitors" User forks: Continues with their own competitor list ``` **To customize for their needs:** ``` Builder shares: "Campaign strategy for SaaS product" User forks: Adapts strategy for their specific product ``` **To learn and experiment:** ``` Builder shares: "Complex data analysis workflow" User forks: Tries with their own data ``` **To collaborate asynchronously:** ``` Team member 1 starts conversation Shares link Team member 2 forks and continues Shares updated version back ``` ### Enabling Productive Forking As a builder, you can encourage forking by: **Creating "template" conversations:** * Start a conversation with your agent * Walk through a complete workflow * Stop at a point where users can customize * Share with instruction: "Fork this and add your data" **Example:** ``` Title: "Competitor Research Template" Conversation: Agent: "I'll help you research competitors. What industry are you in?" [Builder]: "SaaS" Agent: "Great! I'll research SaaS competitors. Which companies should I analyze?" [Builder]: "Add your companies here →" [Share this - users fork and replace with their companies] ``` **Building progressive examples:** * Share multiple conversations showing progression * Each one builds on the previous * Users can fork at any stage * Creates learning pathways ## Managing Conversations as a Builder ### Testing Your Agent As you build and refine your knowledge agent, you'll have many test conversations: **Organizing test conversations:** * Use consistent naming in your test prompts * Delete obviously failed test conversations * Keep successful examples to share later * Archive old tests after major updates **Starting fresh tests:** * Always start a new conversation for each test scenario * Don't reuse old conversations (context bleeds through) * Test with realistic user scenarios ### Monitoring Usage Check your conversation history to understand: * What users are asking for * Where the agent succeeds * Where it gets confused * What workflows are most popular **Use this feedback to:** * Refine system instructions * Add relevant knowledge * Enable additional tools * Update sample questions **Pro tip:** Review your first 10-20 real user conversations carefully. They'll reveal assumptions you made that users don't share, and unexpected use cases you didn't anticipate. ## User Experience Best Practices ### Setting Expectations in the First Message Your welcome message is critical. It should: **Be clear about capabilities:** ``` Good: "Hi! I can research companies, enrich with LinkedIn data, and add them to HubSpot. What would you like to research?" Bad: "Hello! How can I help you today?" ``` **Show example interactions:** ``` Include in your welcome message: "Try asking me: - 'Research TechCorp and its competitors' - 'Find 10 AI startups in San Francisco' - 'Enrich this list with funding data'" ``` **Set boundaries:** ``` "I specialize in company research and CRM enrichment. For general questions, I recommend [alternative]." ``` ### Conversational Flow **Acknowledge long-running tasks:** ``` Bad: [Agent calls tool, user sees nothing for 30 seconds, then results] Good: "Let me research that for you..." [Calls tool] "Found 15 companies, now enriching with LinkedIn data..." [Calls tool] "Analysis complete! Here are the results:" ``` **Ask clarifying questions early:** ``` User: "Research competitors" Good agent response: "I'd be happy to research competitors. A few questions: - What industry or product category? - Geographic focus? - Should I include indirect competitors too?" Bad agent response: "Okay, researching competitors..." [Doesn't know what to research] ``` **Confirm before sensitive actions:** ``` Good: "I've drafted an email to the CEO. Here's what I'll send: [Shows email] Should I send this?" Bad: "Email sent to CEO." [User had no chance to review] ``` ### Error Handling When things go wrong, your agent should: **Explain what happened:** ``` Good: "I tried to call the Company Research workflow but it returned an error: 'API rate limit exceeded'. This means we've made too many requests. I can try again in a few minutes, or we can approach this differently. What would you prefer?" Bad: "Error occurred." ``` **Offer alternatives:** ``` "The LinkedIn enrichment tool isn't responding. I can: 1. Try a different enrichment source 2. Continue with the data we have 3. Wait and try again later What works best for you?" ``` **Don't get stuck:** ``` If a tool fails repeatedly, don't keep trying. Agent should: "This tool seems to be having issues. Let me try a different approach..." or "I'll skip this step for now..." ``` ## Conversation Analytics While you can't export conversation data directly, you can learn from patterns: ### What to Look For **Common question patterns:** * Are users asking for things your agent can't do? * → Consider adding new tools or knowledge **Where conversations succeed:** * Which workflows work smoothly? * → Highlight these in examples **Where conversations fail:** * Where does the agent get confused? * → Update system instructions or add knowledge **Unexpected use cases:** * Are users doing things you didn't anticipate? * → Consider optimizing for these patterns ### Iterating Based on Conversations **Weekly review process:** 1. Review 10-20 recent conversations 2. Identify 3 common issues 3. Make 1-2 specific improvements 4. Test improvements with new conversations 5. Repeat **Example improvement cycle:** ``` Week 1 observation: Users often ask for data exports Action: Enable Google Sheets integration Week 2 observation: Agent doesn't explain what it's doing Action: Update system instructions to narrate actions Week 3 observation: Users confused about what agent can do Action: Update welcome message and sample questions ``` ## Advanced: Conversation Handoffs For complex agents, you might want to design conversation handoffs: ### Handing Off to Humans ``` System instructions: "If the user requests something outside your capabilities, offer to connect them with a human: 'This requires human expertise. I can: 1. Summarize our conversation so far 2. Send a notification to [team/person] 3. Save our discussion for their review What would you prefer?'" ``` ### Handing Off to Other Agents ``` System instructions: "For [specific task type], suggest forking to the specialized agent: 'For advanced data analysis, I recommend forking this conversation to our Data Analysis Knowledge agent: [link]. It has specialized tools for [capability]. Should I prepare a summary to start there?'" ``` ## Troubleshooting Conversations **Symptoms:** Conversations disappear or don't persist **Possible causes:** 1. Browser cookies/storage disabled 2. Incognito/private browsing mode 3. Account authentication issues **Solutions:** * Ensure user is logged in * Check browser allows cookies and local storage * Try a different browser * Clear cache and reload **Symptoms:** Agent forgets what was discussed earlier **Possible causes:** 1. Conversation is very long (approaching token limits) 2. User jumped between multiple unrelated topics 3. Technical issue with conversation state **Solutions:** * Start a new conversation for new topics * Keep conversations focused on one main task * If very long conversation, fork and continue fresh * This is rare - if it happens often, report to support **Symptoms:** Link shows error or "not found" **Possible causes:** 1. Conversation was deleted 2. Agent was made private 3. Link was copied incorrectly **Solutions:** * Verify the agent is still public * Check conversation still exists in your history * Copy the share link again * Ensure full URL is included (including https\://) **Answer:** 1. Find the conversation in your history 2. Look for delete/trash icon (usually hover or right-click) 3. Confirm deletion **Note:** Deleted conversations cannot be recovered. If you shared the conversation link, it will no longer work. **Answer:** No, conversations are immutable. You cannot edit messages after they're sent. If you made a mistake: * Continue the conversation with clarification * Start a new conversation * Fork the conversation at an earlier point This ensures shared conversations remain truthful representations. **Answer:** There's no built-in export feature currently, but you can: * Copy and paste the conversation text * Take screenshots * Share the link and reference it externally * Use the conversation as training data (upload as knowledge) ## Next Steps Now that you understand conversation management and sharing: Learn advanced techniques for building exceptional knowledge agents Solve common issues and optimize your agent's performance Review how to write better system instructions and prompts Give your agent more capabilities to create better conversations **Remember:** Every conversation is an opportunity to learn what works and what doesn't. Review conversations regularly, share your best examples, and continuously refine based on real usage.