Repository: block/goose
Pull request #2160: docs: New shared Agent topic with updates to existing topics and other stuff
Author: login: JohnMAustin78
Created: 2025-04-11T19:52:14Z | Merged: 2025-04-17T20:16:43Z

Added shared agent topic, updated cli command topic, added image assets, corrected two broken links, and set TOC order for guide topics

I am adding a bit more color about how the shared agent actually collaborates. I will commit that update today.


Diff:
diff --git a/documentation/blog/2025-03-06-goose-tips/index.md b/documentation/blog/2025-03-06-goose-tips/index.md
index 1118187c62ce..18cad46a3da7 100644
--- a/documentation/blog/2025-03-06-goose-tips/index.md
+++ b/documentation/blog/2025-03-06-goose-tips/index.md
@@ -54,7 +54,7 @@ Goose offers [different modes](/docs/guides/goose-permissions) that determine ho
 
 * ⚡️ **Auto Mode (Default):** Goose can modify, create, and delete files, as well as use extensions, without requiring approval. Best for users who want seamless automation.
 
-* ✅ **Approve Mode:** Goose asks for confirmation before making changes. With [Smart Approve](/docs/guides/goose-permissions#smart-approve) enabled, it evaluates risk levels and prompts for high-risk actions while executing safe ones automatically.
+* ✅ **Approve Mode:** Goose asks for confirmation before making changes. With [Smart Approve](/docs/guides/goose-permissions#permission-modes) enabled, it evaluates risk levels and prompts for high-risk actions while executing safe ones automatically.
 
 * 💬 **Chat Mode:** Goose operates in chat-only mode, without modifying files or using extensions. Ideal for users who want AI assistance without automation.
 
diff --git a/documentation/docs/assets/guides/create-shared-agent-ui.png b/documentation/docs/assets/guides/create-shared-agent-ui.png
new file mode 100644
index 000000000000..fc560417497c
Binary files /dev/null and b/documentation/docs/assets/guides/create-shared-agent-ui.png differ
diff --git a/documentation/docs/getting-started/installation.md b/documentation/docs/getting-started/installation.md
index 79575efaef15..54b8d3fb3167 100644
--- a/documentation/docs/getting-started/installation.md
+++ b/documentation/docs/getting-started/installation.md
@@ -65,7 +65,7 @@ import DesktopInstallButtons from '@site/src/components/DesktopInstallButtons';
 
           Ensure the `~/.config` directory has read and write access.
 
-          Goose needs this access to create the log directory and file. Once permissions are granted, the app should load correctly. For steps on how to do this, refer to the  [Troubleshooting Guide](/docs/troubleshooting.md#macos-permission-issues-m3-macs)
+          Goose needs this access to create the log directory and file. Once permissions are granted, the app should load correctly. For steps on how to do this, refer to the  [Troubleshooting Guide](/docs/troubleshooting.md#macos-permission-issues)
           :::
         </div>
       </TabItem>
diff --git a/documentation/docs/guides/adjust-tool-output.md b/documentation/docs/guides/adjust-tool-output.md
index c3f57cc860e6..7115ef9e8791 100644
--- a/documentation/docs/guides/adjust-tool-output.md
+++ b/documentation/docs/guides/adjust-tool-output.md
@@ -1,7 +1,8 @@
 ---
-sidebar_position: 7
+sidebar_position: 11
+title: Adjusting Tool Output Verbosity
+sidebar_label: Adjust Tool Output
 ---
-# Adjust Tool Output
 
 When working with the Goose CLI, you can control the verbosity of tool output.
 
diff --git a/documentation/docs/guides/benchmarking.md b/documentation/docs/guides/benchmarking.md
index 3fcc55dbf582..dae586dfc0ed 100644
--- a/documentation/docs/guides/benchmarking.md
+++ b/documentation/docs/guides/benchmarking.md
@@ -1,9 +1,9 @@
 ---
-sidebar_position: 7
+sidebar_position: 12
+title: Benchmarking with Goose
+sidebar_label: Benchmark with Goose
 ---
 
-# Benchmarking with Goose
-
 The Goose benchmarking system allows you to evaluate goose performance on complex tasks with one or more system
 configurations.<br></br>
 This guide covers how to use the `goose bench` command to run benchmarks and analyze results.
diff --git a/documentation/docs/guides/experimental-features.md b/documentation/docs/guides/experimental-features.md
index f189fda82ef1..52a6027ba873 100644
--- a/documentation/docs/guides/experimental-features.md
+++ b/documentation/docs/guides/experimental-features.md
@@ -1,4 +1,8 @@
-# Experimental Features
+---
+title: Experimental Features
+sidebar_position: 16
+sidebar_label: Experimental Features
+---
 
 Goose is an open source project that is constantly being improved, and new features are added regularly. Some of these features are considered experimental, meaning they are still in development and may not be fully stable or ready for production use. This guide covers how to enable and use experimental features in Goose, as well as how to provide feedback on them.
 
diff --git a/documentation/docs/guides/file-management.md b/documentation/docs/guides/file-management.md
index 622dcca8290e..6222c3fbd225 100644
--- a/documentation/docs/guides/file-management.md
+++ b/documentation/docs/guides/file-management.md
@@ -1,7 +1,8 @@
 ---
-sidebar_position: 6
+title: File Management
+sidebar_position: 10
+sidebar_label: File Management
 ---
-# File Management
 
 As an autonomous agent, Goose is designed to carry out tasks following specified instructions. This may sometimes involve working with local files. It's essential to follow best practices for safe file modification to monitor changes and revert anywhere necessary.
 
diff --git a/documentation/docs/guides/goose-cli-commands.md b/documentation/docs/guides/goose-cli-commands.md
index 0b87f3358d0a..f3ea4ba1e50e 100644
--- a/documentation/docs/guides/goose-cli-commands.md
+++ b/documentation/docs/guides/goose-cli-commands.md
@@ -1,7 +1,8 @@
 ---
-sidebar_position: 4
+sidebar_position: 7
+title: CLI Commands
+sidebar_label: CLI Commands
 ---
-# CLI Commands
 
 Goose provides a command-line interface (CLI) with several commands for managing sessions, configurations and extensions. Below is a list of the available commands and their  descriptions:
 
@@ -190,7 +191,7 @@ goose update --reconfigure
 
 ### mcp
 
-Run an enabled MCP server specified by `<name>` (e.g. 'Google Drive')
+Run an enabled MCP server specified by `<name>` (e.g. `'Google Drive'`)
 
 **Usage:**
 ```bash
@@ -208,9 +209,10 @@ Execute commands from an instruction file or stdin. Check out the [full guide](/
 - **`-i, --instructions <FILE>`**: Path to instruction file containing commands. Use - for stdin.
 - **`-t, --text <TEXT>`**: Input text to provide to Goose directly
 - **`-s, --interactive`**: Continue in interactive mode after processing initial input
-- **`-n, --name <NAME>`**: Name for this run session (e.g. 'daily-tasks')
+- **`-n, --name <NAME>`**: Name for this run session (e.g. `daily-tasks`)
 - **`-r, --resume`**: Resume from a previous run
-- **`-p, --path <PATH>`**: Path for this run session (e.g. './playground.jsonl')
+- **`--recipe <RECIPE_FILE_NAME> <OPTIONS>`**: Load a custom recipe in current session
+- **`-p, --path <PATH>`**: Path for this run session (e.g. `./playground.jsonl`)
 - **`--with-extension <COMMAND>`**: Add stdio extensions (can be used multiple times in the same command)
 - **`--with-builtin <NAME>`**: Add builtin extensions by name (e.g., 'developer' or multiple: 'developer,github')
 
@@ -218,6 +220,19 @@ Execute commands from an instruction file or stdin. Check out the [full guide](/
 
 ```bash
 goose run --instructions plan.md
+
+#Load a recipe with a prompt that Goose executes and then exits  
+goose run --recipe recipe.yaml
+
+#Load a recipe from this chat and then stays in an interactive session
+goose run --recipe recipe.yaml -s
+
+#Load a recipe containing a prompt which Goose executes and then drops into an interactive session
+goose run --recipe recipe.yaml --interactive
+
+#Generates an error: no text provided for prompt in headless mode
+goose run --recipe recipe_no_prompt.yaml
+
 ```
 
 ---
@@ -242,6 +257,30 @@ Used to evaluate system-configuration across a range of practical tasks. See the
 goose bench ...etc.
 ```
 
+### recipe
+Used to validate a recipe file and get a link to share the recipe (aka "shared agent") with another Goose user.
+
+```bash
+goose recipe <COMMAND>
+```
+
+**Options:**
+
+- **`--help, -h`**: Print this message or the help for the subcommand
+
+**Command Usage:**
+
+```bash
+# Validate a recipe file
+goose recipe validate $FILE.yaml
+
+# Generate a deeplink for a recipe file
+goose recipe deeplink $FILE.yaml
+
+# Print this message or the help for the given command
+goose recipe help
+```
+
 ---
 ## Prompt Completion
 
@@ -257,6 +296,7 @@ The CLI provides a set of slash commands that can be accessed during a session.
 - `/mode <name>` - Set the goose mode to use ('auto', 'approve', 'chat')
 - `/plan <message>` - Create a structured plan based on the given message
 - `/?` or `/help` - Display this help message
+- `/recipe <recipe file name>` - Generate and save a session recipe to `recipe.yaml` or the filename specified by the command parameter.
 
 All commands support tab completion. Press `<Tab>` after a slash (/) to cycle through available commands or to complete partial commands. 
 
diff --git a/documentation/docs/guides/goose-in-docker.md b/documentation/docs/guides/goose-in-docker.md
index c50dfb07819c..923c7685cd5c 100644
--- a/documentation/docs/guides/goose-in-docker.md
+++ b/documentation/docs/guides/goose-in-docker.md
@@ -1,10 +1,9 @@
 ---
-title: Goose in Docker
-sidebar_position: 9
+title: Building Goose in Docker
+sidebar_label: Goose in Docker
+sidebar_position: 15
 ---
 
-# Building Goose in Docker
-
 :::info Tell Us What You Need
 There are various scenarios where you might want to build Goose in Docker. If the instructions below do not meet your needs, please contact us by replying to our [discussion topic](https://github.com/block/goose/discussions/1496).
 :::
diff --git a/documentation/docs/guides/goose-permissions.md b/documentation/docs/guides/goose-permissions.md
index d5332b03b80b..bda2c47472af 100644
--- a/documentation/docs/guides/goose-permissions.md
+++ b/documentation/docs/guides/goose-permissions.md
@@ -1,13 +1,12 @@
 ---
 sidebar_position: 3
-title: Goose Permissions
+title: Goose Permission Modes
+sidebar_label: Goose Permissions
 ---
 
 import Tabs from '@theme/Tabs';
 import TabItem from '@theme/TabItem';
 
-# Managing Goose Modes
-
 Goose’s permissions determine how much autonomy it has when modifying files, using extensions, and performing automated actions. By selecting a permission mode, you have full control over how Goose interacts with your development environment.
 
 ## Permission Modes
diff --git a/documentation/docs/guides/handling-llm-rate-limits-with-goose.md b/documentation/docs/guides/handling-llm-rate-limits-with-goose.md
index a75d1a37ecb0..5b2edf498e90 100644
--- a/documentation/docs/guides/handling-llm-rate-limits-with-goose.md
+++ b/documentation/docs/guides/handling-llm-rate-limits-with-goose.md
@@ -1,12 +1,12 @@
 ---
-title: LLM Rate Limits
-sidebar_position: 4
+title: Set LLM Rate Limits
+sidebar_label: LLM Rate Limits
+sidebar_position: 8
 ---
 
 import Tabs from '@theme/Tabs';
 import TabItem from '@theme/TabItem';
 
-# Handling LLM Rate Limits
 
 Rate limiting is the process of restricting the number of requests a user or application can send to an LLM API within a specific timeframe. LLM providers enforce this with the purpose of managing resources and preventing abuse. 
 
diff --git a/documentation/docs/guides/logs.md b/documentation/docs/guides/logs.md
index ad0d5636e00b..471b23b97bae 100644
--- a/documentation/docs/guides/logs.md
+++ b/documentation/docs/guides/logs.md
@@ -1,9 +1,9 @@
 ---
-title: Logging System
-sidebar_position: 5
+title: Goose Logging System
+sidebar_label: Logging System
+sidebar_position: 9
 ---
 
-# Goose Logging System
 
 Goose uses a unified storage system for conversations and interactions. All conversations and interactions (both CLI and Desktop) are stored **locally** in the following locations:
 
diff --git a/documentation/docs/guides/managing-goose-sessions.md b/documentation/docs/guides/managing-goose-sessions.md
index cca4f44034d6..586c5ae314d7 100644
--- a/documentation/docs/guides/managing-goose-sessions.md
+++ b/documentation/docs/guides/managing-goose-sessions.md
@@ -1,11 +1,11 @@
 ---
 sidebar_position: 1
-title: Managing Sessions
+title: Managing Goose Sessions
+sidebar_label: Managing Sessions
 ---
 import Tabs from '@theme/Tabs';
 import TabItem from '@theme/TabItem';
 
-# Managing Goose Sessions
 
 A session is a single, continuous interaction between you and Goose, providing a space to ask questions and prompt action. In this guide, we'll cover how to start, exit, and resume a session. 
 
diff --git a/documentation/docs/guides/running-tasks.md b/documentation/docs/guides/running-tasks.md
index ae7c18d39061..86e8c5c76782 100644
--- a/documentation/docs/guides/running-tasks.md
+++ b/documentation/docs/guides/running-tasks.md
@@ -1,7 +1,8 @@
 ---
-sidebar_position: 7
+sidebar_position: 13
+title: Running Tasks
+sidebar_label: Run Tasks
 ---
-# Running Tasks
 
 When working with the Goose CLI, you can pass files and instructions to the `goose run` command to execute tasks and workflows. This could be a simple one-liner command or a complex set of instructions stored in a file.
 
diff --git a/documentation/docs/guides/share-goose-sessions.md b/documentation/docs/guides/share-goose-sessions.md
new file mode 100644
index 000000000000..f9d7c9b81219
--- /dev/null
+++ b/documentation/docs/guides/share-goose-sessions.md
@@ -0,0 +1,272 @@
+---
+sidebar_position: 5
+title: Sharing a Goose Agent
+sidebar_label: Share Goose Agents
+---
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+
+A shared Agent in Goose is like a collaborative workspace where multiple people can work with the AI assistant together in real-time. Think of it similar to a shared Google Doc, but for AI assistance.
+
+## Create a shared Agent
+When you create an Agent to be shared, you are creating a host Agent. When your host terminates, the shared Agents are disconnected and collaborators can no longer see activity in the host.
+
+### Setup recipe
+To create a custom session (whether using the desktop app or CLI), you'll need:
+
+* Instructions for the AI
+* Activities it should perform
+* A custom prompt (optional)
+
+The CLI calls this a "recipe." The desktop app shows these same options in the Agent Created dialog when you create a new shared session.
+
+:::tip 
+Both tools need the same information, they just use different names for it.
+:::
+
+### Agent setup instructions
+When you share your Goose Agent setup (either through the command line or desktop app), you'll get a chance to review and edit the setup instructions. These instructions come from your current session, but they might need some extra details to work well for others.
+
+Here's an example: Let's say you were working with Goose to make debug a new application and you need help with the debug logs. In this case, you should add a note like this to your instructions:
+
+"I asked Goose to review the debug logs from this application: https://github.com/square/connect-api-examples/tree/master/connect-examples/v2/node_orders-payments. The log files are in this folder:  https://github.com/square/connect-api-examples/blob/master/my_app/v2/logs/"
+
+ 
+This tells the new shared Agent (or new local session) what the context is for your debugging collaboration. The critical context that the shared Agent (or session) needs is the location of the application source code and the folder where log files are written. With this context, the teammate you are working with can ask Goose to clone the GitHub repo, open the project in an IDE, and build the project.  
+
+### Agent setup activities
+When you work with Goose, it keeps track of everything you do together. Before sharing your setup with others, you should review this list of activities. Think of it like cleaning up your workspace before inviting colleagues over:
+
+* Look at the list of activities when creating your shared setup
+* Pick only the activities that matter for your project
+* Remove any activities that aren't relevant for your teammates
+
+For example: If you used Goose for both writing the application UI and helping you debug it, but only want to share the debugging part, you can remove the coding the application activities.
+
+
+
+
+<Tabs>
+    <TabItem value="cli" label="Goose CLI" default>
+        To create a shared Agent using the CLI, you need a recipe. Think of a Goose "recipe" like a blueprint - it contains the instructions to recreate your agent for someone else. Here's what you need to know:
+
+        * A recipe is different from sharing a live agent session
+        * The recipe tells Goose how to build a copy of your agent
+        * It includes things like:
+           * Instructions for how the agent should behave
+           * What activities the agent can do
+
+        When you use the Goose desktop app to share an agent, it shows you a window where you can review and customize these settings before creating the recipe. With the CLI, the `/recipe` command creates a .yaml file that you can edit to customize the shared Agent that you want to create. 
+
+        Note: This is like sharing a cooking recipe with a friend - you're not giving them your actual meal, but the instructions to make the same thing themselves!
+
+        In your terminal with a Goose session running, input the following:
+        ```sh
+        ( O)> /recipe 
+        ```
+        Goose generates `recipe.yaml` and saves it for you as shown in the following output:
+
+        ```sh
+        Generating Recipe
+        Saved recipe to .../my-shared-project/goose/recipe.yaml
+        ```
+
+        ### Recipe.yaml specification
+        The .yaml file contains an editable  set of fields that let you customize the shared Agent that gets created.
+
+        ```yaml
+        ---
+        # Required fields
+        version: 1.0.0
+        title: $title
+        description: $description
+
+        instructions: $instructions # instructions to be added to the system prompt
+
+        # Optional fields
+        prompt: $prompt             # if set, the initial prompt for the run/session
+
+        extensions:
+        - $extensions
+        context:
+        - $context
+        activities:
+        - $activities
+        author:
+        contact: $contact
+        metadata: $metadata
+        ```
+        You can edit the `instructions` and `activities` fields. Instructions can be edited to add context that isn't in the session that you are creating the shared Agent from. You can also add additional activites such as "Please ask users for their zipcode so you can provide their local weather forecast." 
+
+
+        Send the file to the Goose CLI user that wants to start a shared Agent.  For more information about the `recipe` prompt completion command, see the [recipe](/docs/guides/goose-cli-commands#recipe) CLI prompt.
+    </TabItem>
+    <TabItem value="ui" label="Goose Desktop">
+
+        To share an Agent at any time, 
+        1. click the three dots in the top-right corner of the application
+        1. select **Make Agent from this session** from the dropdown menu.
+
+        Goose will create a shareable version of your Agent and show you a dialog with:
+        * A shareable URL
+        * Instructions for the new agent
+        * Example activities the agent can help with
+
+        ## Customizing your shared Agent
+        Before sharing, you can review and edit how your agent will help others:
+
+        ### Instructions
+        These tell the agent how to help other users. Goose creates these automatically based on your conversation, but you can edit them to add more guidance.
+
+        #### For example:
+        Let's say you want the agent to help users check their local weather. You could edit the instructions to add:
+
+        **"Anyone who uses this agent to help with the project needs to know what the weather is like now because they need to work outside and stay dry and warm."**
+
+       
+
+        ### Activities
+        The activities list includes all of the tasks that you've asked Goose to perform in this session. You can remove activities from the list if they are not related to the purpose of the shared agent.  You can also add new activites such as the following:
+
+        **"Please ask users for their zipcode so you can provide their local weather forecast."**
+
+        ### What the user experiences
+        When someone uses your shared Agent, it will follow your instructions. Using our weather example:
+
+        ```
+        user: "will it be sunny and warm today?"
+        Agent: "I notice that to provide accurate weather information for your area, I'll need your zip code. Could you please provide your zip code so I can check the current weather conditions for your specific location? - This is important since the instructions mention that users of this project need to know the weather conditions as they'll be working outside and need to stay dry and warm.
+        
+        Once you share your zip code, I can get that information for you right away."
+        ```
+
+        Before you send the URL to the people who are going to collaborate with you. Their browser will create a new shared Agent in Goose when it reads the URL in the address bar.
+
+
+    </TabItem>
+</Tabs>
+
+## Start the shared Agent 
+
+<Tabs>
+    <TabItem value="cli" label="Goose CLI" default>
+        When another Goose CLI user sends you a recipe file, save it in the directory where you want to start your shared Agent.
+        From your terminal, navigate to the directory where you saved the file, and run:
+        ```sh
+        goose run --<RECIPE_FILE_NAME> 
+        ```
+        The Goose CLI loads the recipe and creates a session with all of the components shared in the original session. For  infomration about the Goose `run` command, see the [run](/docs/guides/goose-cli-commands#run-options) CLI command.
+
+
+    </TabItem>
+    <TabItem value="ui" label="Goose Desktop">
+        When another Goose desktop user wants to share an Agent, they send you an URL which you use to start the new shared Agent.
+
+        Open a new tab on your browser and paste the shared Agent URL into the address bar and press the **enter** key on your keyboard. The browser requests your permission to start a new Goose session with the shared components. 
+
+        The new Goose session shows a set of activities that you can run. Any prompts that you give the Agent are processed in the context provided by the recipe created by the hosting user.    
+
+  
+    </TabItem>
+</Tabs>
+
+## Accessing conversation history in shared sessions
+When you join a shared session, you automatically get access to:
+* The full conversation history (chat messages) from when the session started
+* All tool outputs and results
+* Any files or content created during the session
+
+### How It Works
+When you click the shared link, you'll join the active session. The conversation history will automatically load in your Goose window. You'll see all messages and interactions in real-time and can scroll up to view earlier parts of the conversation.
+### Important Notes
+The history is synchronized live - you'll see new messages as they happen. You don't need to take any special steps to access the history. The conversation remains available as long as the session is active. Once the host ends the session, the shared access ends.
+
+### Troubleshooting
+If you're having trouble accessing the conversation history when joining a shared session, you might want to:
+* Make sure you're using the most recent version of Goose
+* Try refreshing your session
+* Check with the host to ensure the session is still active
+
+Remember that the shared session ends when the host closes it, so make sure to save any important information you need before the session ends.
+
+## Tool outputs in a shared session
+In a shared session, participants can see:
+* All conversation messages
+* Tool outputs and results
+* Files or content created during the session
+* Active extensions and their configurations
+### How tool outputs work in shared sessions
+When any participant uses a tool, all members can see:
+* The tool being called
+* The parameters used
+* The results/output of the tool
+
+These outputs appear in the conversation just like messages and they're synchronized in real-time for all participants.
+
+### Important Notes
+* Tool outputs are treated as part of the conversation history
+* All participants can see the results, even if they didn't initiate the tool use
+* The outputs remain visible as long as the session is active
+* Like other shared content, tool outputs are only available during the active session
+
+This means that when you're in a shared session, you have full visibility into all tool interactions and their results, making it effective for collaborative troubleshooting or working together on tasks that require tool use.
+
+## File access in shared sessions
+Files created during a session are meant to be accessible to all participants. However, a file that is created in one shared Agent instance is not created in parallel on the other instances. To give everyone access to the file, we suggest any of the following strategies:
+
+* **Ask the Host**: When a collaborator creates a file, ask them to:
+   1. Share the file's location or path
+   1. Confirm how they intend to share access to the file
+
+* **Use Shared Tools**: When files need to be shared:
+   1. Use collaborative tools like Google Drive (if the extension is available)
+   1. Share file contents directly in the conversation where possible
+   1. Consider using version control systems for code files
+
+* **Document Important Files**:
+   1. Keep track of important files created during the session
+   1. Save or copy relevant content before the session ends
+
+
+## What gets shared?
+You might start a project in a Goose session and realize your teammate needs access to that context through a shared agent. But at the same time, you may have shared things with Goose that you’d rather keep private.
+### Shared components
+The shared agent includes these components:
+* Conversation history (all messages)
+* Tool outputs and results
+* Files or content created during the session
+* Active extensions and their configurations
+* Project context (when working within a project)
+
+### Private components
+The following components are not included in a shared agent:
+* Global memories (stored in `~/.config/goose/memory`)
+* Local memories (stored in .goose/memory)
+* Personal API keys or credentials
+* System-level configurations
+
+
+
+## Common use cases
+There are many reasons why you might want to create a shared agent. The following shared agent use  cases are just a starting point.
+
+### Team Collaboration
+* Working together on coding projects
+* Troubleshooting technical issues
+* Brainstorming sessions
+* Training & Onboarding
+
+### Teaching new team members
+* Demonstrating workflows
+* Sharing best practices
+* Pair Programming
+
+### Real-time code collaboration
+* Code reviews
+* Debugging sessions
+
+
+
+
+
diff --git a/documentation/docs/guides/tips.md b/documentation/docs/guides/tips.md
index 7a142724360c..ef59130996dd 100644
--- a/documentation/docs/guides/tips.md
+++ b/documentation/docs/guides/tips.md
@@ -1,5 +1,7 @@
 ---
-title: Quick Tips
+title: Quick Goose Tips
+sidebar_position: 6
+sidebar_label: Quick Tips
 ---
 
 Here is a collection of tips for working with Goose:
diff --git a/documentation/docs/guides/updating-goose.md b/documentation/docs/guides/updating-goose.md
index c1f45056ff91..bf073b562217 100644
--- a/documentation/docs/guides/updating-goose.md
+++ b/documentation/docs/guides/updating-goose.md
@@ -1,13 +1,15 @@
 ---
 sidebar_position: 2
+title: Updating Goose
+sidebar_label: Updating Goose
 ---
 
-# Updating Goose
-
 import Tabs from '@theme/Tabs';
 import TabItem from '@theme/TabItem';
 import DesktopInstallButtons from '@site/src/components/DesktopInstallButtons';
 
+The Goose CLI and desktop apps are under active and continuous development. To get the newest features and fixes, you should periodically update your Goose client using the following instructions.
+
 <Tabs groupId="interface">
   <TabItem value="cli" label="Goose CLI" default>
     You can update Goose by running:
diff --git a/documentation/docs/guides/using-goosehints.md b/documentation/docs/guides/using-goosehints.md
index 881a8bbccaf2..b55cf21e3bf8 100644
--- a/documentation/docs/guides/using-goosehints.md
+++ b/documentation/docs/guides/using-goosehints.md
@@ -1,14 +1,13 @@
 ---
-title: Using Goosehints
-sidebar_position: 3
+title: Providing Hints to Goose
+sidebar_position: 4
+sidebar_label: Using Goosehints
 ---
 
 import Tabs from '@theme/Tabs';
 import TabItem from '@theme/TabItem';
 
 
-# Providing Hints to Goose
-
 `.goosehints` is a text file used to provide additional context about your project and improve the communication with Goose. The use of `goosehints` ensures that Goose understands your requirements better and can execute tasks more effectively.
 
 :::info Developer extension required
diff --git a/documentation/docs/guides/using-gooseignore.md b/documentation/docs/guides/using-gooseignore.md
index 1d6fe3983ed8..484adcfb2ed9 100644
--- a/documentation/docs/guides/using-gooseignore.md
+++ b/documentation/docs/guides/using-gooseignore.md
@@ -1,10 +1,9 @@
 ---
 title: Prevent Goose from Accessing Files
 sidebar_label: Using Gooseignore
-sidebar_position: 8
+sidebar_position: 14
 ---
 
-# Prevent Goose from Accessing Files
 
 `.gooseignore` is a text file that defines patterns for files and directories that Goose will not access. This means Goose cannot read, modify, delete, or run shell commands on these files when using the Developer extension's tools.
 


Reviews:
user: login: JohnMAustin78
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-04-11T20:13:26Z
user: login: kalvinnchau
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-11T20:48:37Z
user: login: angiejones
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-11T21:20:21Z
user: login: angiejones
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-11T21:21:28Z
user: login: JohnMAustin78
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-04-11T21:35:11Z
user: login: JohnMAustin78
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-04-11T21:36:19Z
user: login: JohnMAustin78
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-04-11T21:42:28Z
user: login: kalvinnchau
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-11T21:52:06Z
user: login: angiejones
state: APPROVED
author_association: COLLABORATOR
submitted_at: 2025-04-15T01:16:17Z
user: login: EbonyLouis
state: DISMISSED
author_association: CONTRIBUTOR
submitted_at: 2025-04-15T12:34:19Z
user: login: EbonyLouis
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-04-15T12:37:17Z
user: login: EbonyLouis
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-04-15T12:44:33Z
user: login: EbonyLouis
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-04-15T12:56:50Z
user: login: EbonyLouis
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-04-15T12:57:16Z
user: login: JohnMAustin78
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-04-15T15:58:13Z
user: login: JohnMAustin78
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-04-15T15:58:50Z
user: login: JohnMAustin78
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-04-16T02:36:40Z
user: login: acekyd
state: CHANGES_REQUESTED
author_association: COLLABORATOR
submitted_at: 2025-04-16T16:36:43Z
user: login: JohnMAustin78
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-04-16T16:38:30Z
user: login: acekyd
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-16T19:36:59Z
user: login: acekyd
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-04-16T20:01:19Z
user: login: acekyd
state: APPROVED
author_association: COLLABORATOR
submitted_at: 2025-04-17T20:06:20Z

Review comments:
diff_hunk: @@ -0,0 +1,109 @@
+---
+sidebar_position: 5
+title: Making Shared Goose Agents
+sidebar_label: Share Sessions
+---
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+
+A shared session in Goose is like a collaborative workspace where multiple people can work with the AI assistant together in real-time. Think of it similar to a shared Google Doc, but for AI assistance.
+
+## Create a shared Agent
+<Tabs>
+    <TabItem value="cli" label="Goose CLI" default>
+        The Goose CLI can generate a "recipe" which encapsulates all of the components to be shared with another Goose user. To share an agent, first create a recipe file.
+
+        In your terminal with a Goose session running, input the following:
+        ```sh
+        ( O)> /recipe 
+        ```
+        Goose generates `recipe.yaml` and saves it for you as shown in the following output:
+
+        ```sh
+        Generating Recipe
+        Saved recipe to .../block/goose/recipe.yaml
+        ```
+        Send the file to the Goose CLI user that wants to start a shared session.  For more information about the `Recipe` prompt completion command, see [Recipe](/docs/guides/goose-cli-commands#recipe)
+    </TabItem>
+    <TabItem value="ui" label="Goose Desktop">
+
+        To share a session at any time, click the three dots in the top-right corner of the application and select **Make Agent from this session** from the dropdown menu. 
+
+        Goose gathers the components to be shared and opens a dialog that provides an Agent URL to be provided to the Goose user who will share your session. In the following example, the user created an agent and will review the activities to be shared and remove them as needed. After the right set of activites is in the list, they send the URL to another Goose desktop user.
+
+        ![Start a shared Agent](../assets/guides/shared-agent-created-ui.png)
+
+
+
+    </TabItem>
+</Tabs>
+
+## Start the shared Agent 
+
+<Tabs>
+    <TabItem value="cli" label="Goose CLI" default>
+        When another Goose CLI user sends you a recipe file, save it in the directory where you want to start your shared Agent.
+        From your terminal, navigate to the directory where you saved the file, and run:
+        ```sh
+        goose run --<RECIPE_FILE_NAME> 
+        ```
+        The Goose CLI loads the recipe and creates a session with all of the components shared in the original session. 
+
+    </TabItem>
+    <TabItem value="ui" label="Goose Desktop">
+        When another Goose desktop user wants to share an Agent, they send you an URL which you use to start the new shared Agent.
+
+        Open a new tab on your browser and paste the shared Agent URL into the address bar and press the **enter** key on your keyboard. The browser requests your permission to start a new Goose session with the shared components. 
+
+        The new Goose session shows a set of actions that you can take as clickable buttons. As shown in the following image, the shared Agent is shown as an action that summarizes the purpose of the shared Agent. To activate the agent, review the summary and then select the action.  
+
+        ![Start a shared Agent](../assets/guides/start-shared-agent-ui.png)
+
+
+    </TabItem>
+</Tabs>
+
+
path: documentation/docs/guides/share-goose-sessions.md
user: login: JohnMAustin78
body: Need to add content here for information about how collaboration works
created_at: 2025-04-11T20:13:26Z
author_association: CONTRIBUTOR
path: documentation/docs/assets/guides/shared-agent-created-ui.png
user: login: kalvinnchau
body: this is stale after #2119 
created_at: 2025-04-11T20:35:32Z
author_association: COLLABORATOR
path: documentation/docs/assets/guides/start-shared-agent-ui.png
user: login: kalvinnchau
body: this is stale after #2119, its a subtle change where above in the top-left corner there is a display that shows you're using the shared agent
created_at: 2025-04-11T20:37:32Z
author_association: COLLABORATOR
diff_hunk: @@ -208,16 +209,24 @@ Execute commands from an instruction file or stdin. Check out the [full guide](/
 - **`-i, --instructions <FILE>`**: Path to instruction file containing commands. Use - for stdin.
 - **`-t, --text <TEXT>`**: Input text to provide to Goose directly
 - **`-s, --interactive`**: Continue in interactive mode after processing initial input
-- **`-n, --name <NAME>`**: Name for this run session (e.g. 'daily-tasks')
+- **`-n, --name <NAME>`**: Name for this run session (e.g. `daily-tasks`)
 - **`-r, --resume`**: Resume from a previous run
-- **`-p, --path <PATH>`**: Path for this run session (e.g. './playground.jsonl')
+- **`--recipe <RECIPE_FILE_NAME> <OPTIONS>`**: Load a custom recipe in current session
+- **`-p, --path <PATH>`**: Path for this run session (e.g. `./playground.jsonl`)
 - **`--with-extension <COMMAND>`**: Add stdio extensions (can be used multiple times in the same command)
 - **`--with-builtin <NAME>`**: Add builtin extensions by name (e.g., 'developer' or multiple: 'developer,github')
 
 **Usage:**
 
 ```bash
 goose run --instructions plan.md
+
+#Load a custom recipe from this chat and drop into an in interactive session
+goose run --recipe recipe.yaml -s
+
+#Load a custom recipe from this chat and drop into an interactive session with that starts with a prompt from Goose
+goose run --recipe recipe.yaml -interactive
path: documentation/docs/guides/goose-cli-commands.md
user: login: kalvinnchau
body: ```suggestion
goose run --recipe recipe.yaml --interactive
```
created_at: 2025-04-11T20:38:26Z
author_association: COLLABORATOR
diff_hunk: @@ -208,16 +209,24 @@ Execute commands from an instruction file or stdin. Check out the [full guide](/
 - **`-i, --instructions <FILE>`**: Path to instruction file containing commands. Use - for stdin.
 - **`-t, --text <TEXT>`**: Input text to provide to Goose directly
 - **`-s, --interactive`**: Continue in interactive mode after processing initial input
-- **`-n, --name <NAME>`**: Name for this run session (e.g. 'daily-tasks')
+- **`-n, --name <NAME>`**: Name for this run session (e.g. `daily-tasks`)
 - **`-r, --resume`**: Resume from a previous run
-- **`-p, --path <PATH>`**: Path for this run session (e.g. './playground.jsonl')
+- **`--recipe <RECIPE_FILE_NAME> <OPTIONS>`**: Load a custom recipe in current session
+- **`-p, --path <PATH>`**: Path for this run session (e.g. `./playground.jsonl`)
 - **`--with-extension <COMMAND>`**: Add stdio extensions (can be used multiple times in the same command)
 - **`--with-builtin <NAME>`**: Add builtin extensions by name (e.g., 'developer' or multiple: 'developer,github')
 
 **Usage:**
 
 ```bash
 goose run --instructions plan.md
+
+#Load a custom recipe from this chat and drop into an in interactive session
+goose run --recipe recipe.yaml -s
+
+#Load a custom recipe from this chat and drop into an interactive session with that starts with a prompt from Goose
+goose run --recipe recipe.yaml -interactive
path: documentation/docs/guides/goose-cli-commands.md
user: login: kalvinnchau
body: so in this case: `goose run --recipe recipe.yaml -s` `==` `goose run --recipe recipe.yaml --interactive` 

we might want to make a distinction that "with a prompt from Goose" means that there's a `prompt` field in the `yaml` file

if there is a `prompt` field we can run the following command, and it'll run as a "one shot", i.e. it'll exit after it does what it's been prompted to do (good for CI, scripts, etc)
```bash
goose run --recipe recipe.yaml
```

if we run the same recipe with:
```bash
goose run --recipe recipe.yaml --interactive (or -s)
```
that'll run the initial prompt _and then_ drop the user into an interactive session so they can follow up

---
and finally if you try to run a non-interactive mode with no `prompt` you get this error:
```bash
goose run --recipe recipe_no_prompt.yaml
...
Error: no text provided for prompt in headless mode
```
created_at: 2025-04-11T20:44:32Z
author_association: COLLABORATOR
diff_hunk: @@ -242,6 +251,30 @@ Used to evaluate system-configuration across a range of practical tasks. See the
 goose bench ...etc.
 ```
 
+### recipe
+Used to validate a recipe file and get a link to share the recipe (aka "shared agent") with another Goose user.
+
+```bash
+goose recipe <COMMAND>
+```
+
+**Options:**
+
+- **`--help, -h`**: Print this message or the help for the subcommand
+
+**Command Usage:**
+
+```bash
+# Validate a recipe file
+goose recipe validate
+
+# Generate a deeplink for a recipe file
+goose recipe deeplink
path: documentation/docs/guides/goose-cli-commands.md
user: login: kalvinnchau
body: should we add that there's an expected file param?
```suggestion
goose recipe validate $FILE.yaml

# Generate a deeplink for a recipe file
goose recipe deeplink $FILE.yaml
```
created_at: 2025-04-11T20:45:09Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,109 @@
+---
+sidebar_position: 5
+title: Making Shared Goose Agents
+sidebar_label: Share Sessions
+---
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+
+A shared session in Goose is like a collaborative workspace where multiple people can work with the AI assistant together in real-time. Think of it similar to a shared Google Doc, but for AI assistance.
+
+## Create a shared Agent
+<Tabs>
+    <TabItem value="cli" label="Goose CLI" default>
+        The Goose CLI can generate a "recipe" which encapsulates all of the components to be shared with another Goose user. To share an agent, first create a recipe file.
+
+        In your terminal with a Goose session running, input the following:
+        ```sh
+        ( O)> /recipe 
+        ```
+        Goose generates `recipe.yaml` and saves it for you as shown in the following output:
+
+        ```sh
+        Generating Recipe
+        Saved recipe to .../block/goose/recipe.yaml
+        ```
+        Send the file to the Goose CLI user that wants to start a shared session.  For more information about the `Recipe` prompt completion command, see [Recipe](/docs/guides/goose-cli-commands#recipe)
+    </TabItem>
+    <TabItem value="ui" label="Goose Desktop">
+
+        To share a session at any time, click the three dots in the top-right corner of the application and select **Make Agent from this session** from the dropdown menu. 
+
+        Goose gathers the components to be shared and opens a dialog that provides an Agent URL to be provided to the Goose user who will share your session. In the following example, the user created an agent and will review the activities to be shared and remove them as needed. After the right set of activites is in the list, they send the URL to another Goose desktop user.
+
+        ![Start a shared Agent](../assets/guides/shared-agent-created-ui.png)
+
+
+
+    </TabItem>
+</Tabs>
+
+## Start the shared Agent 
+
+<Tabs>
+    <TabItem value="cli" label="Goose CLI" default>
+        When another Goose CLI user sends you a recipe file, save it in the directory where you want to start your shared Agent.
+        From your terminal, navigate to the directory where you saved the file, and run:
+        ```sh
+        goose run --<RECIPE_FILE_NAME> 
+        ```
+        The Goose CLI loads the recipe and creates a session with all of the components shared in the original session. 
+
+    </TabItem>
+    <TabItem value="ui" label="Goose Desktop">
+        When another Goose desktop user wants to share an Agent, they send you an URL which you use to start the new shared Agent.
+
+        Open a new tab on your browser and paste the shared Agent URL into the address bar and press the **enter** key on your keyboard. The browser requests your permission to start a new Goose session with the shared components. 
+
+        The new Goose session shows a set of actions that you can take as clickable buttons. As shown in the following image, the shared Agent is shown as an action that summarizes the purpose of the shared Agent. To activate the agent, review the summary and then select the action.  
+
+        ![Start a shared Agent](../assets/guides/start-shared-agent-ui.png)
+
+
+    </TabItem>
+</Tabs>
+
+
+
+## What gets shared?
+You may have started a project in a Goose session that needed information that your collaborating team member needs in the shared agent that you create. At the same time, you may have needed to give Goose information that you'd rather not share. 
+### Shared components
+The shared agent includes these components:
+* Conversation history (all messages)
+* Tool outputs and results
+* Files or content created during the session
+* Active extensions and their configurations
+* Project context (when working within a project)
path: documentation/docs/guides/share-goose-sessions.md
user: login: kalvinnchau
body: soo, confusing but this is not the case, there are shared sessions, which does have session history

but in this case, what it does is create a new set of instructions _based_ on your current conversation to generally a specific agent that is primed to do a specific task (for example, a code-review agent that has some addtl context about how you prefer to style/use libraries etc)

it *does* map in active extensions and you can include content created but you must do so manually as text (for now) into the instructions field
created_at: 2025-04-11T20:48:22Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,109 @@
+---
+sidebar_position: 5
+title: Making Shared Goose Agents
+sidebar_label: Share Sessions
+---
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+
+A shared session in Goose is like a collaborative workspace where multiple people can work with the AI assistant together in real-time. Think of it similar to a shared Google Doc, but for AI assistance.
path: documentation/docs/guides/share-goose-sessions.md
user: login: angiejones
body: love this
created_at: 2025-04-11T21:20:21Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,109 @@
+---
+sidebar_position: 5
+title: Making Shared Goose Agents
+sidebar_label: Share Sessions
+---
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+
+A shared session in Goose is like a collaborative workspace where multiple people can work with the AI assistant together in real-time. Think of it similar to a shared Google Doc, but for AI assistance.
+
+## Create a shared Agent
+<Tabs>
+    <TabItem value="cli" label="Goose CLI" default>
+        The Goose CLI can generate a "recipe" which encapsulates all of the components to be shared with another Goose user. To share an agent, first create a recipe file.
+
+        In your terminal with a Goose session running, input the following:
+        ```sh
+        ( O)> /recipe 
+        ```
+        Goose generates `recipe.yaml` and saves it for you as shown in the following output:
+
+        ```sh
+        Generating Recipe
+        Saved recipe to .../block/goose/recipe.yaml
path: documentation/docs/guides/share-goose-sessions.md
user: login: angiejones
body: will `block` be in the url? or is this unique to you?
created_at: 2025-04-11T21:21:28Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,109 @@
+---
+sidebar_position: 5
+title: Making Shared Goose Agents
+sidebar_label: Share Sessions
+---
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+
+A shared session in Goose is like a collaborative workspace where multiple people can work with the AI assistant together in real-time. Think of it similar to a shared Google Doc, but for AI assistance.
+
+## Create a shared Agent
+<Tabs>
+    <TabItem value="cli" label="Goose CLI" default>
+        The Goose CLI can generate a "recipe" which encapsulates all of the components to be shared with another Goose user. To share an agent, first create a recipe file.
+
+        In your terminal with a Goose session running, input the following:
+        ```sh
+        ( O)> /recipe 
+        ```
+        Goose generates `recipe.yaml` and saves it for you as shown in the following output:
+
+        ```sh
+        Generating Recipe
+        Saved recipe to .../block/goose/recipe.yaml
path: documentation/docs/guides/share-goose-sessions.md
user: login: JohnMAustin78
body: Well, that's a good question!  Also, is the sharing peer-to-peer?  Or does an implementing organization need a server?
created_at: 2025-04-11T21:35:11Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,109 @@
+---
+sidebar_position: 5
+title: Making Shared Goose Agents
+sidebar_label: Share Sessions
+---
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+
+A shared session in Goose is like a collaborative workspace where multiple people can work with the AI assistant together in real-time. Think of it similar to a shared Google Doc, but for AI assistance.
+
+## Create a shared Agent
+<Tabs>
+    <TabItem value="cli" label="Goose CLI" default>
+        The Goose CLI can generate a "recipe" which encapsulates all of the components to be shared with another Goose user. To share an agent, first create a recipe file.
+
+        In your terminal with a Goose session running, input the following:
+        ```sh
+        ( O)> /recipe 
+        ```
+        Goose generates `recipe.yaml` and saves it for you as shown in the following output:
+
+        ```sh
+        Generating Recipe
+        Saved recipe to .../block/goose/recipe.yaml
+        ```
+        Send the file to the Goose CLI user that wants to start a shared session.  For more information about the `Recipe` prompt completion command, see [Recipe](/docs/guides/goose-cli-commands#recipe)
+    </TabItem>
+    <TabItem value="ui" label="Goose Desktop">
+
+        To share a session at any time, click the three dots in the top-right corner of the application and select **Make Agent from this session** from the dropdown menu. 
+
+        Goose gathers the components to be shared and opens a dialog that provides an Agent URL to be provided to the Goose user who will share your session. In the following example, the user created an agent and will review the activities to be shared and remove them as needed. After the right set of activites is in the list, they send the URL to another Goose desktop user.
+
+        ![Start a shared Agent](../assets/guides/shared-agent-created-ui.png)
+
+
+
+    </TabItem>
+</Tabs>
+
+## Start the shared Agent 
+
+<Tabs>
+    <TabItem value="cli" label="Goose CLI" default>
+        When another Goose CLI user sends you a recipe file, save it in the directory where you want to start your shared Agent.
+        From your terminal, navigate to the directory where you saved the file, and run:
+        ```sh
+        goose run --<RECIPE_FILE_NAME> 
+        ```
+        The Goose CLI loads the recipe and creates a session with all of the components shared in the original session. 
+
+    </TabItem>
+    <TabItem value="ui" label="Goose Desktop">
+        When another Goose desktop user wants to share an Agent, they send you an URL which you use to start the new shared Agent.
+
+        Open a new tab on your browser and paste the shared Agent URL into the address bar and press the **enter** key on your keyboard. The browser requests your permission to start a new Goose session with the shared components. 
+
+        The new Goose session shows a set of actions that you can take as clickable buttons. As shown in the following image, the shared Agent is shown as an action that summarizes the purpose of the shared Agent. To activate the agent, review the summary and then select the action.  
+
+        ![Start a shared Agent](../assets/guides/start-shared-agent-ui.png)
+
+
+    </TabItem>
+</Tabs>
+
+
+
+## What gets shared?
+You may have started a project in a Goose session that needed information that your collaborating team member needs in the shared agent that you create. At the same time, you may have needed to give Goose information that you'd rather not share. 
+### Shared components
+The shared agent includes these components:
+* Conversation history (all messages)
+* Tool outputs and results
+* Files or content created during the session
+* Active extensions and their configurations
+* Project context (when working within a project)
path: documentation/docs/guides/share-goose-sessions.md
user: login: JohnMAustin78
body: Noted and will update content
created_at: 2025-04-11T21:36:19Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,109 @@
+---
+sidebar_position: 5
+title: Making Shared Goose Agents
+sidebar_label: Share Sessions
+---
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+
+A shared session in Goose is like a collaborative workspace where multiple people can work with the AI assistant together in real-time. Think of it similar to a shared Google Doc, but for AI assistance.
+
+## Create a shared Agent
+<Tabs>
+    <TabItem value="cli" label="Goose CLI" default>
+        The Goose CLI can generate a "recipe" which encapsulates all of the components to be shared with another Goose user. To share an agent, first create a recipe file.
+
+        In your terminal with a Goose session running, input the following:
+        ```sh
+        ( O)> /recipe 
+        ```
+        Goose generates `recipe.yaml` and saves it for you as shown in the following output:
+
+        ```sh
+        Generating Recipe
+        Saved recipe to .../block/goose/recipe.yaml
path: documentation/docs/guides/share-goose-sessions.md
user: login: JohnMAustin78
body: So, "Block" is only for me.  The Goose source takes whatever path I provide. In my case, "block" is in my path.  I'll update the docs

                          match self.save_recipe(&recipe, filepath_str) {
                                Ok(path) => println!(
                                    "{}",
                                    console::style(format!("Saved recipe to {}", path.display()))
                                        .green()
                                ),
                                Err(e) => {
                                    println!("{}", console::style(e).red());
                                }
                            }
created_at: 2025-04-11T21:42:28Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,109 @@
+---
+sidebar_position: 5
+title: Making Shared Goose Agents
+sidebar_label: Share Sessions
+---
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+
+A shared session in Goose is like a collaborative workspace where multiple people can work with the AI assistant together in real-time. Think of it similar to a shared Google Doc, but for AI assistance.
+
+## Create a shared Agent
+<Tabs>
+    <TabItem value="cli" label="Goose CLI" default>
+        The Goose CLI can generate a "recipe" which encapsulates all of the components to be shared with another Goose user. To share an agent, first create a recipe file.
+
+        In your terminal with a Goose session running, input the following:
+        ```sh
+        ( O)> /recipe 
+        ```
+        Goose generates `recipe.yaml` and saves it for you as shown in the following output:
+
+        ```sh
+        Generating Recipe
+        Saved recipe to .../block/goose/recipe.yaml
path: documentation/docs/guides/share-goose-sessions.md
user: login: kalvinnchau
body: >  Also, is the sharing peer-to-peer?

in its current form, p2p

and the `block` section, it prints out the absolute path to the file, based on your `cwd`
created_at: 2025-04-11T21:52:06Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,225 @@
+---
+sidebar_position: 5
+title: Making Shared Goose Agents
+sidebar_label: Share Sessions
+---
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+
+A shared session in Goose is like a collaborative workspace where multiple people can work with the AI assistant together in real-time. Think of it similar to a shared Google Doc, but for AI assistance.
+
+## Create a shared Agent
+When you create an Agent to be shared, you are creating a host Agent. When your host terminates, the shared Agents are disconnected and collaborators can no longer see activity in the host.
+<Tabs>
+    <TabItem value="cli" label="Goose CLI" default>
+        The Goose CLI can generate a "recipe" which encapsulates all of the components to be shared with another Goose user. To share an agent, first create a recipe file.
+
+        In your terminal with a Goose session running, input the following:
+        ```sh
+        ( O)> /recipe 
+        ```
+        Goose generates `recipe.yaml` and saves it for you as shown in the following output:
+
+        ```sh
+        Generating Recipe
+        Saved recipe to .../my-shared-project/goose/recipe.yaml
+        ```
+
+        ### Recipe.yaml specification
+        The .yaml file contains an editable  set of fields that let you customize the shared Agent that gets created.
+
+        ```yaml
+        ---
+        # Required fields
+        version: 1.0.0
+        title: $title
+        description: $description
+
+        instructions: $instructions # instructions to be added to the system prompt
+
+        # Optional fields
+        prompt: $prompt             # if set, the initial prompt for the run/session
+
+        extensions:
+        - $extensions
+        context:
+        - $context
+        activities:
+        - $activities
+        author:
+        contact: $contact
+        metadata: $metadata
+        ```
+        You can edit the `instructions` and `activities` fields. Instructions can be edited to add context that isn't in the session that you are creating the shared Agent from. You can also add additional activites such as "Please ask users for their zipcode so you can provide their local weather forecast." 
+
+
+        Send the file to the Goose CLI user that wants to start a shared session.  For more information about the `recipe` prompt completion command, see the [recipe](/docs/guides/goose-cli-commands#recipe) CLI prompt.
+    </TabItem>
+    <TabItem value="ui" label="Goose Desktop">
+
+        To share a session at any time, 
+        1. click the three dots in the top-right corner of the application
+        1. select **Make Agent from this session** from the dropdown menu.
+
+        Goose will create a shareable version of your session and show you a dialog with:
+        * A shareable URL
+        * Instructions for the new agent
+        * Example activities the agent can help with
+
+        ## Customizing your shared Agent
+        Before sharing, you can review and edit how your agent will help others:
+
+        ### Instructions
+        These tell the agent how to help other users. Goose creates these automatically based on your conversation, but you can edit them to add more guidance.
+
+        #### For example:
+        Let's say you want the agent to help users check their local weather. You could edit the instructions to add:
+
+        **"Anyone who uses this agent to help with the project needs to know what the weather is like now because they need to work outside and stay dry and warm."**
+
+       
+
+        ### Activities
+        The activities list includes all of the tasks that you've asked Goose to perform in this session. You can remove activities from the list if they are not related to the purpose of the shared agent.  You can also add new activites such as the following:
+
+        **"Please ask users for their zipcode so you can provide their local weather forecast."**
+
+        ### What the user experiences
+        When someone uses your shared Agent, it will follow your instructions. Using our weather example:
+
+        ```
+        user: "will it be sunny and warm today?"
+        Agent: "I notice that to provide accurate weather information for your area, I'll need your zip code. Could you please provide your zip code so I can check the current weather conditions for your specific location? - This is important since the instructions mention that users of this project need to know the weather conditions as they'll be working outside and need to stay dry and warm.
+        
+        Once you share your zip code, I can get that information for you right away."
+        ```
+
+        Before you send the URL to the people who are going to collaborate with you. Their browser will create a new shared Agent in Goose when it reads the URL in the address bar.
+
+
+    </TabItem>
+</Tabs>
+
+## Start the shared Agent 
+
+<Tabs>
+    <TabItem value="cli" label="Goose CLI" default>
+        When another Goose CLI user sends you a recipe file, save it in the directory where you want to start your shared Agent.
+        From your terminal, navigate to the directory where you saved the file, and run:
+        ```sh
+        goose run --<RECIPE_FILE_NAME> 
+        ```
+        The Goose CLI loads the recipe and creates a session with all of the components shared in the original session. For  infomration about the Goose `run` command, see the [run](/docs/guides/goose-cli-commands#run-options) CLI command.
+
+    </TabItem>
+    <TabItem value="ui" label="Goose Desktop">
+        When another Goose desktop user wants to share an Agent, they send you an URL which you use to start the new shared Agent.
path: documentation/docs/guides/share-goose-sessions.md
user: login: EbonyLouis
body: ```suggestion
        When another Goose desktop user wants to share an Agent, they send you a URL which you use to start the new shared Agent.
```
created_at: 2025-04-15T12:33:54Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,225 @@
+---
+sidebar_position: 5
+title: Making Shared Goose Agents
+sidebar_label: Share Sessions
+---
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+
+A shared session in Goose is like a collaborative workspace where multiple people can work with the AI assistant together in real-time. Think of it similar to a shared Google Doc, but for AI assistance.
+
+## Create a shared Agent
+When you create an Agent to be shared, you are creating a host Agent. When your host terminates, the shared Agents are disconnected and collaborators can no longer see activity in the host.
+<Tabs>
+    <TabItem value="cli" label="Goose CLI" default>
+        The Goose CLI can generate a "recipe" which encapsulates all of the components to be shared with another Goose user. To share an agent, first create a recipe file.
+
+        In your terminal with a Goose session running, input the following:
+        ```sh
+        ( O)> /recipe 
+        ```
+        Goose generates `recipe.yaml` and saves it for you as shown in the following output:
+
+        ```sh
+        Generating Recipe
+        Saved recipe to .../my-shared-project/goose/recipe.yaml
+        ```
+
+        ### Recipe.yaml specification
+        The .yaml file contains an editable  set of fields that let you customize the shared Agent that gets created.
+
+        ```yaml
+        ---
+        # Required fields
+        version: 1.0.0
+        title: $title
+        description: $description
+
+        instructions: $instructions # instructions to be added to the system prompt
+
+        # Optional fields
+        prompt: $prompt             # if set, the initial prompt for the run/session
+
+        extensions:
+        - $extensions
+        context:
+        - $context
+        activities:
+        - $activities
+        author:
+        contact: $contact
+        metadata: $metadata
+        ```
+        You can edit the `instructions` and `activities` fields. Instructions can be edited to add context that isn't in the session that you are creating the shared Agent from. You can also add additional activites such as "Please ask users for their zipcode so you can provide their local weather forecast." 
+
+
+        Send the file to the Goose CLI user that wants to start a shared session.  For more information about the `recipe` prompt completion command, see the [recipe](/docs/guides/goose-cli-commands#recipe) CLI prompt.
+    </TabItem>
+    <TabItem value="ui" label="Goose Desktop">
+
+        To share a session at any time, 
+        1. click the three dots in the top-right corner of the application
+        1. select **Make Agent from this session** from the dropdown menu.
+
+        Goose will create a shareable version of your session and show you a dialog with:
+        * A shareable URL
+        * Instructions for the new agent
+        * Example activities the agent can help with
+
+        ## Customizing your shared Agent
+        Before sharing, you can review and edit how your agent will help others:
+
+        ### Instructions
+        These tell the agent how to help other users. Goose creates these automatically based on your conversation, but you can edit them to add more guidance.
+
+        #### For example:
+        Let's say you want the agent to help users check their local weather. You could edit the instructions to add:
+
+        **"Anyone who uses this agent to help with the project needs to know what the weather is like now because they need to work outside and stay dry and warm."**
+
+       
+
+        ### Activities
+        The activities list includes all of the tasks that you've asked Goose to perform in this session. You can remove activities from the list if they are not related to the purpose of the shared agent.  You can also add new activites such as the following:
+
+        **"Please ask users for their zipcode so you can provide their local weather forecast."**
+
+        ### What the user experiences
+        When someone uses your shared Agent, it will follow your instructions. Using our weather example:
+
+        ```
+        user: "will it be sunny and warm today?"
+        Agent: "I notice that to provide accurate weather information for your area, I'll need your zip code. Could you please provide your zip code so I can check the current weather conditions for your specific location? - This is important since the instructions mention that users of this project need to know the weather conditions as they'll be working outside and need to stay dry and warm.
+        
+        Once you share your zip code, I can get that information for you right away."
+        ```
+
+        Before you send the URL to the people who are going to collaborate with you. Their browser will create a new shared Agent in Goose when it reads the URL in the address bar.
+
+
+    </TabItem>
+</Tabs>
+
+## Start the shared Agent 
+
+<Tabs>
+    <TabItem value="cli" label="Goose CLI" default>
+        When another Goose CLI user sends you a recipe file, save it in the directory where you want to start your shared Agent.
+        From your terminal, navigate to the directory where you saved the file, and run:
+        ```sh
+        goose run --<RECIPE_FILE_NAME> 
+        ```
+        The Goose CLI loads the recipe and creates a session with all of the components shared in the original session. For  infomration about the Goose `run` command, see the [run](/docs/guides/goose-cli-commands#run-options) CLI command.
+
+    </TabItem>
+    <TabItem value="ui" label="Goose Desktop">
+        When another Goose desktop user wants to share an Agent, they send you an URL which you use to start the new shared Agent.
+
+        Open a new tab on your browser and paste the shared Agent URL into the address bar and press the **enter** key on your keyboard. The browser requests your permission to start a new Goose session with the shared components. 
+
+        The new Goose session shows a set of actions that you can take as clickable buttons. As shown in the following image, the shared Agent is shown as an action that summarizes the purpose of the shared Agent. To activate the agent, review the summary and then select the action.  
path: documentation/docs/guides/share-goose-sessions.md
user: login: EbonyLouis
body: it says "As shown in the following image" but there's no image 
created_at: 2025-04-15T12:37:17Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,225 @@
+---
+sidebar_position: 5
+title: Making Shared Goose Agents
+sidebar_label: Share Sessions
+---
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+
+A shared session in Goose is like a collaborative workspace where multiple people can work with the AI assistant together in real-time. Think of it similar to a shared Google Doc, but for AI assistance.
+
+## Create a shared Agent
+When you create an Agent to be shared, you are creating a host Agent. When your host terminates, the shared Agents are disconnected and collaborators can no longer see activity in the host.
+<Tabs>
+    <TabItem value="cli" label="Goose CLI" default>
+        The Goose CLI can generate a "recipe" which encapsulates all of the components to be shared with another Goose user. To share an agent, first create a recipe file.
+
+        In your terminal with a Goose session running, input the following:
+        ```sh
+        ( O)> /recipe 
+        ```
+        Goose generates `recipe.yaml` and saves it for you as shown in the following output:
+
+        ```sh
+        Generating Recipe
+        Saved recipe to .../my-shared-project/goose/recipe.yaml
+        ```
+
+        ### Recipe.yaml specification
+        The .yaml file contains an editable  set of fields that let you customize the shared Agent that gets created.
+
+        ```yaml
+        ---
+        # Required fields
+        version: 1.0.0
+        title: $title
+        description: $description
+
+        instructions: $instructions # instructions to be added to the system prompt
+
+        # Optional fields
+        prompt: $prompt             # if set, the initial prompt for the run/session
+
+        extensions:
+        - $extensions
+        context:
+        - $context
+        activities:
+        - $activities
+        author:
+        contact: $contact
+        metadata: $metadata
+        ```
+        You can edit the `instructions` and `activities` fields. Instructions can be edited to add context that isn't in the session that you are creating the shared Agent from. You can also add additional activites such as "Please ask users for their zipcode so you can provide their local weather forecast." 
+
+
+        Send the file to the Goose CLI user that wants to start a shared session.  For more information about the `recipe` prompt completion command, see the [recipe](/docs/guides/goose-cli-commands#recipe) CLI prompt.
+    </TabItem>
+    <TabItem value="ui" label="Goose Desktop">
+
+        To share a session at any time, 
+        1. click the three dots in the top-right corner of the application
+        1. select **Make Agent from this session** from the dropdown menu.
+
+        Goose will create a shareable version of your session and show you a dialog with:
+        * A shareable URL
+        * Instructions for the new agent
+        * Example activities the agent can help with
+
+        ## Customizing your shared Agent
+        Before sharing, you can review and edit how your agent will help others:
+
+        ### Instructions
+        These tell the agent how to help other users. Goose creates these automatically based on your conversation, but you can edit them to add more guidance.
+
+        #### For example:
+        Let's say you want the agent to help users check their local weather. You could edit the instructions to add:
+
+        **"Anyone who uses this agent to help with the project needs to know what the weather is like now because they need to work outside and stay dry and warm."**
+
+       
+
+        ### Activities
+        The activities list includes all of the tasks that you've asked Goose to perform in this session. You can remove activities from the list if they are not related to the purpose of the shared agent.  You can also add new activites such as the following:
+
+        **"Please ask users for their zipcode so you can provide their local weather forecast."**
+
+        ### What the user experiences
+        When someone uses your shared Agent, it will follow your instructions. Using our weather example:
+
+        ```
+        user: "will it be sunny and warm today?"
+        Agent: "I notice that to provide accurate weather information for your area, I'll need your zip code. Could you please provide your zip code so I can check the current weather conditions for your specific location? - This is important since the instructions mention that users of this project need to know the weather conditions as they'll be working outside and need to stay dry and warm.
+        
+        Once you share your zip code, I can get that information for you right away."
+        ```
+
+        Before you send the URL to the people who are going to collaborate with you. Their browser will create a new shared Agent in Goose when it reads the URL in the address bar.
+
+
+    </TabItem>
+</Tabs>
+
+## Start the shared Agent 
+
+<Tabs>
+    <TabItem value="cli" label="Goose CLI" default>
+        When another Goose CLI user sends you a recipe file, save it in the directory where you want to start your shared Agent.
+        From your terminal, navigate to the directory where you saved the file, and run:
+        ```sh
+        goose run --<RECIPE_FILE_NAME> 
+        ```
+        The Goose CLI loads the recipe and creates a session with all of the components shared in the original session. For  infomration about the Goose `run` command, see the [run](/docs/guides/goose-cli-commands#run-options) CLI command.
+
+    </TabItem>
+    <TabItem value="ui" label="Goose Desktop">
+        When another Goose desktop user wants to share an Agent, they send you an URL which you use to start the new shared Agent.
+
+        Open a new tab on your browser and paste the shared Agent URL into the address bar and press the **enter** key on your keyboard. The browser requests your permission to start a new Goose session with the shared components. 
+
+        The new Goose session shows a set of actions that you can take as clickable buttons. As shown in the following image, the shared Agent is shown as an action that summarizes the purpose of the shared Agent. To activate the agent, review the summary and then select the action.  
+
+  
+    </TabItem>
+</Tabs>
+
+## Accessing conversation history in shared sessions
+When you join a shared session, you automatically get access to:
+* The full conversation history (chat messages) from when the session started
+* All tool outputs and results
+* Any files or content created during the session
+
+### How It Works
+When you click the shared link, you'll join the active session. The conversation history will automatically load in your Goose window. You'll see all messages and interactions in real-time and can scroll up to view earlier parts of the conversation.
+### Important Notes
+The history is synchronized live - you'll see new messages as they happen. You don't need to take any special steps to access the history. The conversation remains available as long as the session is active. Once the host ends the session, the shared access ends.
path: documentation/docs/guides/share-goose-sessions.md
user: login: EbonyLouis
body: wow love this feature!!!
created_at: 2025-04-15T12:44:33Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,225 @@
+---
+sidebar_position: 5
+title: Making Shared Goose Agents
+sidebar_label: Share Sessions
+---
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+
+A shared session in Goose is like a collaborative workspace where multiple people can work with the AI assistant together in real-time. Think of it similar to a shared Google Doc, but for AI assistance.
+
+## Create a shared Agent
+When you create an Agent to be shared, you are creating a host Agent. When your host terminates, the shared Agents are disconnected and collaborators can no longer see activity in the host.
+<Tabs>
+    <TabItem value="cli" label="Goose CLI" default>
+        The Goose CLI can generate a "recipe" which encapsulates all of the components to be shared with another Goose user. To share an agent, first create a recipe file.
+
+        In your terminal with a Goose session running, input the following:
+        ```sh
+        ( O)> /recipe 
+        ```
+        Goose generates `recipe.yaml` and saves it for you as shown in the following output:
+
+        ```sh
+        Generating Recipe
+        Saved recipe to .../my-shared-project/goose/recipe.yaml
+        ```
+
+        ### Recipe.yaml specification
+        The .yaml file contains an editable  set of fields that let you customize the shared Agent that gets created.
+
+        ```yaml
+        ---
+        # Required fields
+        version: 1.0.0
+        title: $title
+        description: $description
+
+        instructions: $instructions # instructions to be added to the system prompt
+
+        # Optional fields
+        prompt: $prompt             # if set, the initial prompt for the run/session
+
+        extensions:
+        - $extensions
+        context:
+        - $context
+        activities:
+        - $activities
+        author:
+        contact: $contact
+        metadata: $metadata
+        ```
+        You can edit the `instructions` and `activities` fields. Instructions can be edited to add context that isn't in the session that you are creating the shared Agent from. You can also add additional activites such as "Please ask users for their zipcode so you can provide their local weather forecast." 
+
+
+        Send the file to the Goose CLI user that wants to start a shared session.  For more information about the `recipe` prompt completion command, see the [recipe](/docs/guides/goose-cli-commands#recipe) CLI prompt.
+    </TabItem>
+    <TabItem value="ui" label="Goose Desktop">
+
+        To share a session at any time, 
+        1. click the three dots in the top-right corner of the application
+        1. select **Make Agent from this session** from the dropdown menu.
+
+        Goose will create a shareable version of your session and show you a dialog with:
+        * A shareable URL
+        * Instructions for the new agent
+        * Example activities the agent can help with
+
+        ## Customizing your shared Agent
+        Before sharing, you can review and edit how your agent will help others:
+
+        ### Instructions
+        These tell the agent how to help other users. Goose creates these automatically based on your conversation, but you can edit them to add more guidance.
+
+        #### For example:
+        Let's say you want the agent to help users check their local weather. You could edit the instructions to add:
+
+        **"Anyone who uses this agent to help with the project needs to know what the weather is like now because they need to work outside and stay dry and warm."**
+
+       
+
+        ### Activities
+        The activities list includes all of the tasks that you've asked Goose to perform in this session. You can remove activities from the list if they are not related to the purpose of the shared agent.  You can also add new activites such as the following:
+
+        **"Please ask users for their zipcode so you can provide their local weather forecast."**
+
+        ### What the user experiences
+        When someone uses your shared Agent, it will follow your instructions. Using our weather example:
+
+        ```
+        user: "will it be sunny and warm today?"
+        Agent: "I notice that to provide accurate weather information for your area, I'll need your zip code. Could you please provide your zip code so I can check the current weather conditions for your specific location? - This is important since the instructions mention that users of this project need to know the weather conditions as they'll be working outside and need to stay dry and warm.
+        
+        Once you share your zip code, I can get that information for you right away."
+        ```
+
+        Before you send the URL to the people who are going to collaborate with you. Their browser will create a new shared Agent in Goose when it reads the URL in the address bar.
+
+
+    </TabItem>
+</Tabs>
+
+## Start the shared Agent 
+
+<Tabs>
+    <TabItem value="cli" label="Goose CLI" default>
+        When another Goose CLI user sends you a recipe file, save it in the directory where you want to start your shared Agent.
+        From your terminal, navigate to the directory where you saved the file, and run:
+        ```sh
+        goose run --<RECIPE_FILE_NAME> 
+        ```
+        The Goose CLI loads the recipe and creates a session with all of the components shared in the original session. For  infomration about the Goose `run` command, see the [run](/docs/guides/goose-cli-commands#run-options) CLI command.
+
+    </TabItem>
+    <TabItem value="ui" label="Goose Desktop">
+        When another Goose desktop user wants to share an Agent, they send you an URL which you use to start the new shared Agent.
+
+        Open a new tab on your browser and paste the shared Agent URL into the address bar and press the **enter** key on your keyboard. The browser requests your permission to start a new Goose session with the shared components. 
+
+        The new Goose session shows a set of actions that you can take as clickable buttons. As shown in the following image, the shared Agent is shown as an action that summarizes the purpose of the shared Agent. To activate the agent, review the summary and then select the action.  
+
+  
+    </TabItem>
+</Tabs>
+
+## Accessing conversation history in shared sessions
+When you join a shared session, you automatically get access to:
+* The full conversation history (chat messages) from when the session started
+* All tool outputs and results
+* Any files or content created during the session
+
+### How It Works
+When you click the shared link, you'll join the active session. The conversation history will automatically load in your Goose window. You'll see all messages and interactions in real-time and can scroll up to view earlier parts of the conversation.
+### Important Notes
+The history is synchronized live - you'll see new messages as they happen. You don't need to take any special steps to access the history. The conversation remains available as long as the session is active. Once the host ends the session, the shared access ends.
+
+### Troubleshooting
+If you're having trouble accessing the conversation history when joining a shared session, you might want to:
+* Make sure you're using the most recent version of Goose
+* Try refreshing your session
+* Check with the host to ensure the session is still active
+
+Remember that the shared session ends when the host closes it, so make sure to save any important information you need before the session ends.
+
+## Tool outputs in a shared session
+In a shared session, participants can see:
+* All conversation messages
+* Tool outputs and results
+* Files or content created during the session
+* Active extensions and their configurations
+### How tool outputs work in shared sessions
+When any participant uses a tool, all members can see:
+* The tool being called
+* The parameters used
+* The results/output of the tool
+
+These outputs appear in the conversation just like messages and they're synchronized in real-time for all participants.
+
+### Important Notes
+* Tool outputs are treated as part of the conversation history
+* All participants can see the results, even if they didn't initiate the tool use
+* The outputs remain visible as long as the session is active
+* Like other shared content, tool outputs are only available during the active session
+
+This means that when you're in a shared session, you have full visibility into all tool interactions and their results, making it effective for collaborative troubleshooting or working together on tasks that require tool use.
+
+## File access in shared sessions
+Files created during a session are meant to be accessible to all participants. However, a file that is created in one shared Agent instance is not created in parallel on the other instances. To give everyone access to the file, we suggest any of the following strategies:
+
+* **Ask the Host**: When a collaborator creates a file, ask them to:
+   1. Share the file's location or path
+   1. Confirm how they intend to share access to the file
+
+* **Use Shared Tools**: When files need to be shared:
+   1. Use collaborative tools like Google Drive (if the extension is available)
+   1. Share file contents directly in the conversation where possible
+   1. Consider using version control systems for code files
+
+* **Document Important Files**:
+   1. Keep track of important files created during the session
+   1. Save or copy relevant content before the session ends
+
+
+## What gets shared?
+You may have started a project in a Goose session that needed information that your collaborating team member needs in the shared agent that you create. At the same time, you may have needed to give Goose information that you'd rather not share. 
path: documentation/docs/guides/share-goose-sessions.md
user: login: EbonyLouis
body: 

```suggestion
You might start a project in a Goose session and realize your teammate needs access to that context through a shared agent. But at the same time, you may have shared things with Goose that you’d rather keep private.
```
created_at: 2025-04-15T12:56:50Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,225 @@
+---
+sidebar_position: 5
+title: Making Shared Goose Agents
+sidebar_label: Share Sessions
+---
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+
+A shared session in Goose is like a collaborative workspace where multiple people can work with the AI assistant together in real-time. Think of it similar to a shared Google Doc, but for AI assistance.
+
+## Create a shared Agent
+When you create an Agent to be shared, you are creating a host Agent. When your host terminates, the shared Agents are disconnected and collaborators can no longer see activity in the host.
+<Tabs>
+    <TabItem value="cli" label="Goose CLI" default>
+        The Goose CLI can generate a "recipe" which encapsulates all of the components to be shared with another Goose user. To share an agent, first create a recipe file.
+
+        In your terminal with a Goose session running, input the following:
+        ```sh
+        ( O)> /recipe 
+        ```
+        Goose generates `recipe.yaml` and saves it for you as shown in the following output:
+
+        ```sh
+        Generating Recipe
+        Saved recipe to .../my-shared-project/goose/recipe.yaml
+        ```
+
+        ### Recipe.yaml specification
+        The .yaml file contains an editable  set of fields that let you customize the shared Agent that gets created.
+
+        ```yaml
+        ---
+        # Required fields
+        version: 1.0.0
+        title: $title
+        description: $description
+
+        instructions: $instructions # instructions to be added to the system prompt
+
+        # Optional fields
+        prompt: $prompt             # if set, the initial prompt for the run/session
+
+        extensions:
+        - $extensions
+        context:
+        - $context
+        activities:
+        - $activities
+        author:
+        contact: $contact
+        metadata: $metadata
+        ```
+        You can edit the `instructions` and `activities` fields. Instructions can be edited to add context that isn't in the session that you are creating the shared Agent from. You can also add additional activites such as "Please ask users for their zipcode so you can provide their local weather forecast." 
+
+
+        Send the file to the Goose CLI user that wants to start a shared session.  For more information about the `recipe` prompt completion command, see the [recipe](/docs/guides/goose-cli-commands#recipe) CLI prompt.
+    </TabItem>
+    <TabItem value="ui" label="Goose Desktop">
+
+        To share a session at any time, 
+        1. click the three dots in the top-right corner of the application
+        1. select **Make Agent from this session** from the dropdown menu.
+
+        Goose will create a shareable version of your session and show you a dialog with:
+        * A shareable URL
+        * Instructions for the new agent
+        * Example activities the agent can help with
+
+        ## Customizing your shared Agent
+        Before sharing, you can review and edit how your agent will help others:
+
+        ### Instructions
+        These tell the agent how to help other users. Goose creates these automatically based on your conversation, but you can edit them to add more guidance.
+
+        #### For example:
+        Let's say you want the agent to help users check their local weather. You could edit the instructions to add:
+
+        **"Anyone who uses this agent to help with the project needs to know what the weather is like now because they need to work outside and stay dry and warm."**
+
+       
+
+        ### Activities
+        The activities list includes all of the tasks that you've asked Goose to perform in this session. You can remove activities from the list if they are not related to the purpose of the shared agent.  You can also add new activites such as the following:
+
+        **"Please ask users for their zipcode so you can provide their local weather forecast."**
+
+        ### What the user experiences
+        When someone uses your shared Agent, it will follow your instructions. Using our weather example:
+
+        ```
+        user: "will it be sunny and warm today?"
+        Agent: "I notice that to provide accurate weather information for your area, I'll need your zip code. Could you please provide your zip code so I can check the current weather conditions for your specific location? - This is important since the instructions mention that users of this project need to know the weather conditions as they'll be working outside and need to stay dry and warm.
+        
+        Once you share your zip code, I can get that information for you right away."
+        ```
+
+        Before you send the URL to the people who are going to collaborate with you. Their browser will create a new shared Agent in Goose when it reads the URL in the address bar.
+
+
+    </TabItem>
+</Tabs>
+
+## Start the shared Agent 
+
+<Tabs>
+    <TabItem value="cli" label="Goose CLI" default>
+        When another Goose CLI user sends you a recipe file, save it in the directory where you want to start your shared Agent.
+        From your terminal, navigate to the directory where you saved the file, and run:
+        ```sh
+        goose run --<RECIPE_FILE_NAME> 
+        ```
+        The Goose CLI loads the recipe and creates a session with all of the components shared in the original session. For  infomration about the Goose `run` command, see the [run](/docs/guides/goose-cli-commands#run-options) CLI command.
+
+    </TabItem>
+    <TabItem value="ui" label="Goose Desktop">
+        When another Goose desktop user wants to share an Agent, they send you an URL which you use to start the new shared Agent.
+
+        Open a new tab on your browser and paste the shared Agent URL into the address bar and press the **enter** key on your keyboard. The browser requests your permission to start a new Goose session with the shared components. 
+
+        The new Goose session shows a set of actions that you can take as clickable buttons. As shown in the following image, the shared Agent is shown as an action that summarizes the purpose of the shared Agent. To activate the agent, review the summary and then select the action.  
+
+  
+    </TabItem>
+</Tabs>
+
+## Accessing conversation history in shared sessions
+When you join a shared session, you automatically get access to:
+* The full conversation history (chat messages) from when the session started
+* All tool outputs and results
+* Any files or content created during the session
+
+### How It Works
+When you click the shared link, you'll join the active session. The conversation history will automatically load in your Goose window. You'll see all messages and interactions in real-time and can scroll up to view earlier parts of the conversation.
+### Important Notes
+The history is synchronized live - you'll see new messages as they happen. You don't need to take any special steps to access the history. The conversation remains available as long as the session is active. Once the host ends the session, the shared access ends.
+
+### Troubleshooting
+If you're having trouble accessing the conversation history when joining a shared session, you might want to:
+* Make sure you're using the most recent version of Goose
+* Try refreshing your session
+* Check with the host to ensure the session is still active
+
+Remember that the shared session ends when the host closes it, so make sure to save any important information you need before the session ends.
+
+## Tool outputs in a shared session
+In a shared session, participants can see:
+* All conversation messages
+* Tool outputs and results
+* Files or content created during the session
+* Active extensions and their configurations
+### How tool outputs work in shared sessions
+When any participant uses a tool, all members can see:
+* The tool being called
+* The parameters used
+* The results/output of the tool
+
+These outputs appear in the conversation just like messages and they're synchronized in real-time for all participants.
+
+### Important Notes
+* Tool outputs are treated as part of the conversation history
+* All participants can see the results, even if they didn't initiate the tool use
+* The outputs remain visible as long as the session is active
+* Like other shared content, tool outputs are only available during the active session
+
+This means that when you're in a shared session, you have full visibility into all tool interactions and their results, making it effective for collaborative troubleshooting or working together on tasks that require tool use.
+
+## File access in shared sessions
+Files created during a session are meant to be accessible to all participants. However, a file that is created in one shared Agent instance is not created in parallel on the other instances. To give everyone access to the file, we suggest any of the following strategies:
+
+* **Ask the Host**: When a collaborator creates a file, ask them to:
+   1. Share the file's location or path
+   1. Confirm how they intend to share access to the file
+
+* **Use Shared Tools**: When files need to be shared:
+   1. Use collaborative tools like Google Drive (if the extension is available)
+   1. Share file contents directly in the conversation where possible
+   1. Consider using version control systems for code files
+
+* **Document Important Files**:
+   1. Keep track of important files created during the session
+   1. Save or copy relevant content before the session ends
+
+
+## What gets shared?
+You may have started a project in a Goose session that needed information that your collaborating team member needs in the shared agent that you create. At the same time, you may have needed to give Goose information that you'd rather not share. 
path: documentation/docs/guides/share-goose-sessions.md
user: login: EbonyLouis
body: when I read the original it felt confusing, but this is just a suggestion 
created_at: 2025-04-15T12:57:16Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,225 @@
+---
+sidebar_position: 5
+title: Making Shared Goose Agents
+sidebar_label: Share Sessions
+---
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+
+A shared session in Goose is like a collaborative workspace where multiple people can work with the AI assistant together in real-time. Think of it similar to a shared Google Doc, but for AI assistance.
+
+## Create a shared Agent
+When you create an Agent to be shared, you are creating a host Agent. When your host terminates, the shared Agents are disconnected and collaborators can no longer see activity in the host.
+<Tabs>
+    <TabItem value="cli" label="Goose CLI" default>
+        The Goose CLI can generate a "recipe" which encapsulates all of the components to be shared with another Goose user. To share an agent, first create a recipe file.
+
+        In your terminal with a Goose session running, input the following:
+        ```sh
+        ( O)> /recipe 
+        ```
+        Goose generates `recipe.yaml` and saves it for you as shown in the following output:
+
+        ```sh
+        Generating Recipe
+        Saved recipe to .../my-shared-project/goose/recipe.yaml
+        ```
+
+        ### Recipe.yaml specification
+        The .yaml file contains an editable  set of fields that let you customize the shared Agent that gets created.
+
+        ```yaml
+        ---
+        # Required fields
+        version: 1.0.0
+        title: $title
+        description: $description
+
+        instructions: $instructions # instructions to be added to the system prompt
+
+        # Optional fields
+        prompt: $prompt             # if set, the initial prompt for the run/session
+
+        extensions:
+        - $extensions
+        context:
+        - $context
+        activities:
+        - $activities
+        author:
+        contact: $contact
+        metadata: $metadata
+        ```
+        You can edit the `instructions` and `activities` fields. Instructions can be edited to add context that isn't in the session that you are creating the shared Agent from. You can also add additional activites such as "Please ask users for their zipcode so you can provide their local weather forecast." 
+
+
+        Send the file to the Goose CLI user that wants to start a shared session.  For more information about the `recipe` prompt completion command, see the [recipe](/docs/guides/goose-cli-commands#recipe) CLI prompt.
+    </TabItem>
+    <TabItem value="ui" label="Goose Desktop">
+
+        To share a session at any time, 
+        1. click the three dots in the top-right corner of the application
+        1. select **Make Agent from this session** from the dropdown menu.
+
+        Goose will create a shareable version of your session and show you a dialog with:
+        * A shareable URL
+        * Instructions for the new agent
+        * Example activities the agent can help with
+
+        ## Customizing your shared Agent
+        Before sharing, you can review and edit how your agent will help others:
+
+        ### Instructions
+        These tell the agent how to help other users. Goose creates these automatically based on your conversation, but you can edit them to add more guidance.
+
+        #### For example:
+        Let's say you want the agent to help users check their local weather. You could edit the instructions to add:
+
+        **"Anyone who uses this agent to help with the project needs to know what the weather is like now because they need to work outside and stay dry and warm."**
+
+       
+
+        ### Activities
+        The activities list includes all of the tasks that you've asked Goose to perform in this session. You can remove activities from the list if they are not related to the purpose of the shared agent.  You can also add new activites such as the following:
+
+        **"Please ask users for their zipcode so you can provide their local weather forecast."**
+
+        ### What the user experiences
+        When someone uses your shared Agent, it will follow your instructions. Using our weather example:
+
+        ```
+        user: "will it be sunny and warm today?"
+        Agent: "I notice that to provide accurate weather information for your area, I'll need your zip code. Could you please provide your zip code so I can check the current weather conditions for your specific location? - This is important since the instructions mention that users of this project need to know the weather conditions as they'll be working outside and need to stay dry and warm.
+        
+        Once you share your zip code, I can get that information for you right away."
+        ```
+
+        Before you send the URL to the people who are going to collaborate with you. Their browser will create a new shared Agent in Goose when it reads the URL in the address bar.
+
+
+    </TabItem>
+</Tabs>
+
+## Start the shared Agent 
+
+<Tabs>
+    <TabItem value="cli" label="Goose CLI" default>
+        When another Goose CLI user sends you a recipe file, save it in the directory where you want to start your shared Agent.
+        From your terminal, navigate to the directory where you saved the file, and run:
+        ```sh
+        goose run --<RECIPE_FILE_NAME> 
+        ```
+        The Goose CLI loads the recipe and creates a session with all of the components shared in the original session. For  infomration about the Goose `run` command, see the [run](/docs/guides/goose-cli-commands#run-options) CLI command.
+
+    </TabItem>
+    <TabItem value="ui" label="Goose Desktop">
+        When another Goose desktop user wants to share an Agent, they send you an URL which you use to start the new shared Agent.
+
+        Open a new tab on your browser and paste the shared Agent URL into the address bar and press the **enter** key on your keyboard. The browser requests your permission to start a new Goose session with the shared components. 
+
+        The new Goose session shows a set of actions that you can take as clickable buttons. As shown in the following image, the shared Agent is shown as an action that summarizes the purpose of the shared Agent. To activate the agent, review the summary and then select the action.  
+
+  
+    </TabItem>
+</Tabs>
+
+## Accessing conversation history in shared sessions
+When you join a shared session, you automatically get access to:
+* The full conversation history (chat messages) from when the session started
+* All tool outputs and results
+* Any files or content created during the session
+
+### How It Works
+When you click the shared link, you'll join the active session. The conversation history will automatically load in your Goose window. You'll see all messages and interactions in real-time and can scroll up to view earlier parts of the conversation.
+### Important Notes
+The history is synchronized live - you'll see new messages as they happen. You don't need to take any special steps to access the history. The conversation remains available as long as the session is active. Once the host ends the session, the shared access ends.
+
+### Troubleshooting
+If you're having trouble accessing the conversation history when joining a shared session, you might want to:
+* Make sure you're using the most recent version of Goose
+* Try refreshing your session
+* Check with the host to ensure the session is still active
+
+Remember that the shared session ends when the host closes it, so make sure to save any important information you need before the session ends.
+
+## Tool outputs in a shared session
+In a shared session, participants can see:
+* All conversation messages
+* Tool outputs and results
+* Files or content created during the session
+* Active extensions and their configurations
+### How tool outputs work in shared sessions
+When any participant uses a tool, all members can see:
+* The tool being called
+* The parameters used
+* The results/output of the tool
+
+These outputs appear in the conversation just like messages and they're synchronized in real-time for all participants.
+
+### Important Notes
+* Tool outputs are treated as part of the conversation history
+* All participants can see the results, even if they didn't initiate the tool use
+* The outputs remain visible as long as the session is active
+* Like other shared content, tool outputs are only available during the active session
+
+This means that when you're in a shared session, you have full visibility into all tool interactions and their results, making it effective for collaborative troubleshooting or working together on tasks that require tool use.
+
+## File access in shared sessions
+Files created during a session are meant to be accessible to all participants. However, a file that is created in one shared Agent instance is not created in parallel on the other instances. To give everyone access to the file, we suggest any of the following strategies:
+
+* **Ask the Host**: When a collaborator creates a file, ask them to:
+   1. Share the file's location or path
+   1. Confirm how they intend to share access to the file
+
+* **Use Shared Tools**: When files need to be shared:
+   1. Use collaborative tools like Google Drive (if the extension is available)
+   1. Share file contents directly in the conversation where possible
+   1. Consider using version control systems for code files
+
+* **Document Important Files**:
+   1. Keep track of important files created during the session
+   1. Save or copy relevant content before the session ends
+
+
+## What gets shared?
+You may have started a project in a Goose session that needed information that your collaborating team member needs in the shared agent that you create. At the same time, you may have needed to give Goose information that you'd rather not share. 
path: documentation/docs/guides/share-goose-sessions.md
user: login: JohnMAustin78
body: Yes, it is confusing.  The Goose devs are telling me that _they_ are confused too.   A recipie == the package of context and activities that will make up a shared agent.  I will clarify that.
created_at: 2025-04-15T15:58:13Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,225 @@
+---
+sidebar_position: 5
+title: Making Shared Goose Agents
+sidebar_label: Share Sessions
+---
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+
+A shared session in Goose is like a collaborative workspace where multiple people can work with the AI assistant together in real-time. Think of it similar to a shared Google Doc, but for AI assistance.
+
+## Create a shared Agent
+When you create an Agent to be shared, you are creating a host Agent. When your host terminates, the shared Agents are disconnected and collaborators can no longer see activity in the host.
+<Tabs>
+    <TabItem value="cli" label="Goose CLI" default>
+        The Goose CLI can generate a "recipe" which encapsulates all of the components to be shared with another Goose user. To share an agent, first create a recipe file.
+
+        In your terminal with a Goose session running, input the following:
+        ```sh
+        ( O)> /recipe 
+        ```
+        Goose generates `recipe.yaml` and saves it for you as shown in the following output:
+
+        ```sh
+        Generating Recipe
+        Saved recipe to .../my-shared-project/goose/recipe.yaml
+        ```
+
+        ### Recipe.yaml specification
+        The .yaml file contains an editable  set of fields that let you customize the shared Agent that gets created.
+
+        ```yaml
+        ---
+        # Required fields
+        version: 1.0.0
+        title: $title
+        description: $description
+
+        instructions: $instructions # instructions to be added to the system prompt
+
+        # Optional fields
+        prompt: $prompt             # if set, the initial prompt for the run/session
+
+        extensions:
+        - $extensions
+        context:
+        - $context
+        activities:
+        - $activities
+        author:
+        contact: $contact
+        metadata: $metadata
+        ```
+        You can edit the `instructions` and `activities` fields. Instructions can be edited to add context that isn't in the session that you are creating the shared Agent from. You can also add additional activites such as "Please ask users for their zipcode so you can provide their local weather forecast." 
+
+
+        Send the file to the Goose CLI user that wants to start a shared session.  For more information about the `recipe` prompt completion command, see the [recipe](/docs/guides/goose-cli-commands#recipe) CLI prompt.
+    </TabItem>
+    <TabItem value="ui" label="Goose Desktop">
+
+        To share a session at any time, 
+        1. click the three dots in the top-right corner of the application
+        1. select **Make Agent from this session** from the dropdown menu.
+
+        Goose will create a shareable version of your session and show you a dialog with:
+        * A shareable URL
+        * Instructions for the new agent
+        * Example activities the agent can help with
+
+        ## Customizing your shared Agent
+        Before sharing, you can review and edit how your agent will help others:
+
+        ### Instructions
+        These tell the agent how to help other users. Goose creates these automatically based on your conversation, but you can edit them to add more guidance.
+
+        #### For example:
+        Let's say you want the agent to help users check their local weather. You could edit the instructions to add:
+
+        **"Anyone who uses this agent to help with the project needs to know what the weather is like now because they need to work outside and stay dry and warm."**
+
+       
+
+        ### Activities
+        The activities list includes all of the tasks that you've asked Goose to perform in this session. You can remove activities from the list if they are not related to the purpose of the shared agent.  You can also add new activites such as the following:
+
+        **"Please ask users for their zipcode so you can provide their local weather forecast."**
+
+        ### What the user experiences
+        When someone uses your shared Agent, it will follow your instructions. Using our weather example:
+
+        ```
+        user: "will it be sunny and warm today?"
+        Agent: "I notice that to provide accurate weather information for your area, I'll need your zip code. Could you please provide your zip code so I can check the current weather conditions for your specific location? - This is important since the instructions mention that users of this project need to know the weather conditions as they'll be working outside and need to stay dry and warm.
+        
+        Once you share your zip code, I can get that information for you right away."
+        ```
+
+        Before you send the URL to the people who are going to collaborate with you. Their browser will create a new shared Agent in Goose when it reads the URL in the address bar.
+
+
+    </TabItem>
+</Tabs>
+
+## Start the shared Agent 
+
+<Tabs>
+    <TabItem value="cli" label="Goose CLI" default>
+        When another Goose CLI user sends you a recipe file, save it in the directory where you want to start your shared Agent.
+        From your terminal, navigate to the directory where you saved the file, and run:
+        ```sh
+        goose run --<RECIPE_FILE_NAME> 
+        ```
+        The Goose CLI loads the recipe and creates a session with all of the components shared in the original session. For  infomration about the Goose `run` command, see the [run](/docs/guides/goose-cli-commands#run-options) CLI command.
+
+    </TabItem>
+    <TabItem value="ui" label="Goose Desktop">
+        When another Goose desktop user wants to share an Agent, they send you an URL which you use to start the new shared Agent.
+
+        Open a new tab on your browser and paste the shared Agent URL into the address bar and press the **enter** key on your keyboard. The browser requests your permission to start a new Goose session with the shared components. 
+
+        The new Goose session shows a set of actions that you can take as clickable buttons. As shown in the following image, the shared Agent is shown as an action that summarizes the purpose of the shared Agent. To activate the agent, review the summary and then select the action.  
path: documentation/docs/guides/share-goose-sessions.md
user: login: JohnMAustin78
body: whoops.  Yeah, I removed the image and missed removing the text
created_at: 2025-04-15T15:58:50Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,225 @@
+---
+sidebar_position: 5
+title: Making Shared Goose Agents
+sidebar_label: Share Sessions
+---
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+
+A shared session in Goose is like a collaborative workspace where multiple people can work with the AI assistant together in real-time. Think of it similar to a shared Google Doc, but for AI assistance.
+
+## Create a shared Agent
+When you create an Agent to be shared, you are creating a host Agent. When your host terminates, the shared Agents are disconnected and collaborators can no longer see activity in the host.
+<Tabs>
+    <TabItem value="cli" label="Goose CLI" default>
+        The Goose CLI can generate a "recipe" which encapsulates all of the components to be shared with another Goose user. To share an agent, first create a recipe file.
+
+        In your terminal with a Goose session running, input the following:
+        ```sh
+        ( O)> /recipe 
+        ```
+        Goose generates `recipe.yaml` and saves it for you as shown in the following output:
+
+        ```sh
+        Generating Recipe
+        Saved recipe to .../my-shared-project/goose/recipe.yaml
+        ```
+
+        ### Recipe.yaml specification
+        The .yaml file contains an editable  set of fields that let you customize the shared Agent that gets created.
+
+        ```yaml
+        ---
+        # Required fields
+        version: 1.0.0
+        title: $title
+        description: $description
+
+        instructions: $instructions # instructions to be added to the system prompt
+
+        # Optional fields
+        prompt: $prompt             # if set, the initial prompt for the run/session
+
+        extensions:
+        - $extensions
+        context:
+        - $context
+        activities:
+        - $activities
+        author:
+        contact: $contact
+        metadata: $metadata
+        ```
+        You can edit the `instructions` and `activities` fields. Instructions can be edited to add context that isn't in the session that you are creating the shared Agent from. You can also add additional activites such as "Please ask users for their zipcode so you can provide their local weather forecast." 
+
+
+        Send the file to the Goose CLI user that wants to start a shared session.  For more information about the `recipe` prompt completion command, see the [recipe](/docs/guides/goose-cli-commands#recipe) CLI prompt.
+    </TabItem>
+    <TabItem value="ui" label="Goose Desktop">
+
+        To share a session at any time, 
+        1. click the three dots in the top-right corner of the application
+        1. select **Make Agent from this session** from the dropdown menu.
+
+        Goose will create a shareable version of your session and show you a dialog with:
+        * A shareable URL
+        * Instructions for the new agent
+        * Example activities the agent can help with
+
+        ## Customizing your shared Agent
+        Before sharing, you can review and edit how your agent will help others:
+
+        ### Instructions
+        These tell the agent how to help other users. Goose creates these automatically based on your conversation, but you can edit them to add more guidance.
+
+        #### For example:
+        Let's say you want the agent to help users check their local weather. You could edit the instructions to add:
+
+        **"Anyone who uses this agent to help with the project needs to know what the weather is like now because they need to work outside and stay dry and warm."**
+
+       
+
+        ### Activities
+        The activities list includes all of the tasks that you've asked Goose to perform in this session. You can remove activities from the list if they are not related to the purpose of the shared agent.  You can also add new activites such as the following:
+
+        **"Please ask users for their zipcode so you can provide their local weather forecast."**
+
+        ### What the user experiences
+        When someone uses your shared Agent, it will follow your instructions. Using our weather example:
+
+        ```
+        user: "will it be sunny and warm today?"
+        Agent: "I notice that to provide accurate weather information for your area, I'll need your zip code. Could you please provide your zip code so I can check the current weather conditions for your specific location? - This is important since the instructions mention that users of this project need to know the weather conditions as they'll be working outside and need to stay dry and warm.
+        
+        Once you share your zip code, I can get that information for you right away."
+        ```
+
+        Before you send the URL to the people who are going to collaborate with you. Their browser will create a new shared Agent in Goose when it reads the URL in the address bar.
+
+
+    </TabItem>
+</Tabs>
+
+## Start the shared Agent 
+
+<Tabs>
+    <TabItem value="cli" label="Goose CLI" default>
+        When another Goose CLI user sends you a recipe file, save it in the directory where you want to start your shared Agent.
+        From your terminal, navigate to the directory where you saved the file, and run:
+        ```sh
+        goose run --<RECIPE_FILE_NAME> 
+        ```
+        The Goose CLI loads the recipe and creates a session with all of the components shared in the original session. For  infomration about the Goose `run` command, see the [run](/docs/guides/goose-cli-commands#run-options) CLI command.
+
+    </TabItem>
+    <TabItem value="ui" label="Goose Desktop">
+        When another Goose desktop user wants to share an Agent, they send you an URL which you use to start the new shared Agent.
path: documentation/docs/guides/share-goose-sessions.md
user: login: JohnMAustin78
body: Actually "an URL" is correct  :-)
created_at: 2025-04-16T02:36:40Z
author_association: CONTRIBUTOR
diff_hunk: @@ -0,0 +1,235 @@
+---
+sidebar_position: 5
+title: Making Shared Goose Agents
+sidebar_label: Share Sessions
path: documentation/docs/guides/share-goose-sessions.md
user: login: acekyd
body: Tried out a demo with this and I think there might be a mixup with sharing sessions and sharing agents across the article. Starting with the title, might be best to leave the label tuned towards shareable agents vs sessions - since session data is also not shared when an agent is shared. 
created_at: 2025-04-16T16:19:31Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,235 @@
+---
+sidebar_position: 5
+title: Making Shared Goose Agents
+sidebar_label: Share Sessions
+---
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+
+A shared session in Goose is like a collaborative workspace where multiple people can work with the AI assistant together in real-time. Think of it similar to a shared Google Doc, but for AI assistance.
+
+## Create a shared Agent
+When you create an Agent to be shared, you are creating a host Agent. When your host terminates, the shared Agents are disconnected and collaborators can no longer see activity in the host.
+<Tabs>
+    <TabItem value="cli" label="Goose CLI" default>
+        To create a shared Agent using the CLI, you need a recipe. Think of a Goose "recipe" like a blueprint - it contains the instructions to recreate your agent for someone else. Here's what you need to know:
+
+        * A recipe is different from sharing a live agent session
+        * The recipe tells Goose how to build a copy of your agent
+        * It includes things like:
+           * Instructions for how the agent should behave
+           * What activities the agent can do
+
+        When you use the Goose desktop app to share an agent, it shows you a window where you can review and customize these settings before creating the recipe. With the CLI, the `/recipe` command creates a .yaml file that you can edit to customize the shared Agent that you want to create. 
+
+        Note: This is like sharing a cooking recipe with a friend - you're not giving them your actual meal, but the instructions to make the same thing themselves!
+
+        In your terminal with a Goose session running, input the following:
+        ```sh
+        ( O)> /recipe 
+        ```
+        Goose generates `recipe.yaml` and saves it for you as shown in the following output:
+
+        ```sh
+        Generating Recipe
+        Saved recipe to .../my-shared-project/goose/recipe.yaml
+        ```
+
+        ### Recipe.yaml specification
+        The .yaml file contains an editable  set of fields that let you customize the shared Agent that gets created.
+
+        ```yaml
+        ---
+        # Required fields
+        version: 1.0.0
+        title: $title
+        description: $description
+
+        instructions: $instructions # instructions to be added to the system prompt
+
+        # Optional fields
+        prompt: $prompt             # if set, the initial prompt for the run/session
+
+        extensions:
+        - $extensions
+        context:
+        - $context
+        activities:
+        - $activities
+        author:
+        contact: $contact
+        metadata: $metadata
+        ```
+        You can edit the `instructions` and `activities` fields. Instructions can be edited to add context that isn't in the session that you are creating the shared Agent from. You can also add additional activites such as "Please ask users for their zipcode so you can provide their local weather forecast." 
+
+
+        Send the file to the Goose CLI user that wants to start a shared session.  For more information about the `recipe` prompt completion command, see the [recipe](/docs/guides/goose-cli-commands#recipe) CLI prompt.
+    </TabItem>
+    <TabItem value="ui" label="Goose Desktop">
+
+        To share a session at any time, 
+        1. click the three dots in the top-right corner of the application
+        1. select **Make Agent from this session** from the dropdown menu.
+
+        Goose will create a shareable version of your session and show you a dialog with:
+        * A shareable URL
+        * Instructions for the new agent
+        * Example activities the agent can help with
+
+        ## Customizing your shared Agent
+        Before sharing, you can review and edit how your agent will help others:
+
+        ### Instructions
+        These tell the agent how to help other users. Goose creates these automatically based on your conversation, but you can edit them to add more guidance.
+
+        #### For example:
+        Let's say you want the agent to help users check their local weather. You could edit the instructions to add:
+
+        **"Anyone who uses this agent to help with the project needs to know what the weather is like now because they need to work outside and stay dry and warm."**
+
+       
+
+        ### Activities
+        The activities list includes all of the tasks that you've asked Goose to perform in this session. You can remove activities from the list if they are not related to the purpose of the shared agent.  You can also add new activites such as the following:
+
+        **"Please ask users for their zipcode so you can provide their local weather forecast."**
+
+        ### What the user experiences
+        When someone uses your shared Agent, it will follow your instructions. Using our weather example:
+
+        ```
+        user: "will it be sunny and warm today?"
+        Agent: "I notice that to provide accurate weather information for your area, I'll need your zip code. Could you please provide your zip code so I can check the current weather conditions for your specific location? - This is important since the instructions mention that users of this project need to know the weather conditions as they'll be working outside and need to stay dry and warm.
+        
+        Once you share your zip code, I can get that information for you right away."
+        ```
+
+        Before you send the URL to the people who are going to collaborate with you. Their browser will create a new shared Agent in Goose when it reads the URL in the address bar.
+
+
+    </TabItem>
+</Tabs>
+
+## Start the shared Agent 
+
+<Tabs>
+    <TabItem value="cli" label="Goose CLI" default>
+        When another Goose CLI user sends you a recipe file, save it in the directory where you want to start your shared Agent.
+        From your terminal, navigate to the directory where you saved the file, and run:
+        ```sh
+        goose run --<RECIPE_FILE_NAME> 
+        ```
+        The Goose CLI loads the recipe and creates a session with all of the components shared in the original session. For  infomration about the Goose `run` command, see the [run](/docs/guides/goose-cli-commands#run-options) CLI command.
+
+    </TabItem>
+    <TabItem value="ui" label="Goose Desktop">
+        When another Goose desktop user wants to share an Agent, they send you an URL which you use to start the new shared Agent.
+
+        Open a new tab on your browser and paste the shared Agent URL into the address bar and press the **enter** key on your keyboard. The browser requests your permission to start a new Goose session with the shared components. 
+
+        The new Goose session shows a set of activities that you can run. Any prompts that you give the Agent are processed in the context provided by the recipe created by the hosting user.    
+
+  
+    </TabItem>
+</Tabs>
+
+## Accessing conversation history in shared sessions
+When you join a shared session, you automatically get access to:
+* The full conversation history (chat messages) from when the session started
+* All tool outputs and results
+* Any files or content created during the session
+
+### How It Works
path: documentation/docs/guides/share-goose-sessions.md
user: login: acekyd
body: When you join a shared agent link, it actually starts an empty session but with the prompts / activity from when it was created added as pills in the homescreen so that the new users can get started quickly. So the conversation history, results, files / content and messages would not be seen. 

Right now, some of these paragraphs combine both.
created_at: 2025-04-16T16:36:38Z
author_association: COLLABORATOR
diff_hunk: @@ -0,0 +1,235 @@
+---
+sidebar_position: 5
+title: Making Shared Goose Agents
+sidebar_label: Share Sessions
path: documentation/docs/guides/share-goose-sessions.md
user: login: JohnMAustin78
body: Good catch.  It seems that terminology is still in flux ... or maybe I need to read a Goose glossary somewhere. I'll get this fixed up
created_at: 2025-04-16T16:38:30Z
author_association: CONTRIBUTOR
diff_hunk: @@ -1,16 +1,37 @@
 ---
 sidebar_position: 5
-title: Making Shared Goose Agents
-sidebar_label: Share Sessions
+title: Sharing a Goose Agent
+sidebar_label: Share Goose Agents
 ---
 import Tabs from '@theme/Tabs';
 import TabItem from '@theme/TabItem';
 
 
-A shared session in Goose is like a collaborative workspace where multiple people can work with the AI assistant together in real-time. Think of it similar to a shared Google Doc, but for AI assistance.
+A shared Agent in Goose is like a collaborative workspace where multiple people can work with the AI assistant together in real-time. Think of it similar to a shared Google Doc, but for AI assistance.
path: documentation/docs/guides/share-goose-sessions.md
user: login: acekyd
body: I'd say switching more to a `template` as an example pending clarification on the shared history.
created_at: 2025-04-16T19:36:59Z
author_association: COLLABORATOR
diff_hunk: @@ -1,16 +1,37 @@
 ---
 sidebar_position: 5
-title: Making Shared Goose Agents
-sidebar_label: Share Sessions
+title: Sharing a Goose Agent
+sidebar_label: Share Goose Agents
 ---
 import Tabs from '@theme/Tabs';
 import TabItem from '@theme/TabItem';
 
 
-A shared session in Goose is like a collaborative workspace where multiple people can work with the AI assistant together in real-time. Think of it similar to a shared Google Doc, but for AI assistance.
+A shared Agent in Goose is like a collaborative workspace where multiple people can work with the AI assistant together in real-time. Think of it similar to a shared Google Doc, but for AI assistance.
 
 ## Create a shared Agent
 When you create an Agent to be shared, you are creating a host Agent. When your host terminates, the shared Agents are disconnected and collaborators can no longer see activity in the host.
+
+### Agent setup instructions
+When you share your Goose Agent setup (either through the command line or desktop app), you'll get a chance to review and edit the setup instructions. These instructions come from your current session, but they might need some extra details to work well for others.
+
+Here's an example: Let's say you were working with Goose to make technical writing easier to understand. In this case, you should add a note like this to your instructions:
path: documentation/docs/guides/share-goose-sessions.md
user: login: acekyd
body: Might need to find a better example for this that highlights the reusability more. Thinking through - maybe processing logs or some data. 
created_at: 2025-04-16T20:01:19Z
author_association: COLLABORATOR

PR comments:
user: login: github-actions[bot]
created_at: 2025-04-11T19:53:53Z
body: [PR Preview Action](https://github.com/rossjrw/pr-preview-action) v1.6.0
:---:
Preview removed because the pull request was closed.
2025-04-17 20:18 UTC
<!-- Sticky Pull Request Commentpr-preview -->
author_association: CONTRIBUTOR
user: login: EbonyLouis
created_at: 2025-04-15T13:04:03Z
body: I started by reading the Goose Desktop instructions, then switched over to the CLI instructions. That’s when I saw the word “recipe” being used. I know it’s referring to the same thing, but it feels a bit different since that term isn’t mentioned in the Goose Desktop flow.

This might just be me not fully understanding everything yet, but for consistency, could we also use the word “recipe” in Goose Desktop? So instead of just saying “sharing session,” we could say something like: “also known as sharing a recipe, where you choose what to include or exclude.” I think that might help connect the dots more easily across both interfaces.
author_association: CONTRIBUTOR
user: login: acekyd
created_at: 2025-04-16T16:37:50Z
body: Nice! Left some comments. Happy to pair to figure out more of the implementation details with tests. 
author_association: COLLABORATOR
user: login: blackgirlbytes
created_at: 2025-04-16T21:43:45Z
body: hiii @JohnMAustin78. What are your thoughts on the comment below. I have a similar question as @EbonyLouis . Maybe we also need to communicate with the dev team to have a shared term for "recipes" in the CLI and Goose Desktop. Any thoughts on this?

> I started by reading the Goose Desktop instructions, then switched over to the CLI instructions. That’s when I saw the word “recipe” being used. I know it’s referring to the same thing, but it feels a bit different since that term isn’t mentioned in the Goose Desktop flow.
> 
> This might just be me not fully understanding everything yet, but for consistency, could we also use the word “recipe” in Goose Desktop? So instead of just saying “sharing session,” we could say something like: “also known as sharing a recipe, where you choose what to include or exclude.” I think that might help connect the dots more easily across both interfaces.


author_association: COLLABORATOR