> ## Documentation Index
> Fetch the complete documentation index at: https://docs.tuple.app/llms.txt
> Use this file to discover all available pages before exploring further.

# Ways to use Capture

<View title="macOS" icon="apple">
  [Capture](/pairing-with-tuple/capturing-calls) records what's said and shown on your Tuple calls **locally on your machine**. This allows you to use the context from your calls in **any local harness** with **any model** - either in real time on the call, or after the fact.

  We intentionally designed Capture to be flexible; we want you to be able to use your call content in whatever workflows are right for you and your team. To give you some inspiration for things you could do, we've collected a few ideas below.

  ## Before you begin

  1. Be sure that Capture is fully [set up and enabled](/application-preferences/macos-preferences-capture#start-capture-automatically).
  2. Install the [Tuple CLI](/cli/overview).

  ## During a call

  <Note>
    [Claude Code](https://claude.com/product/claude-code) and [Pi](https://pi.dev/) currently work best for following a call in real time. See [Ask an agent to follow along](/cli/connect#ask-an-agent-to-follow-along) for details.
  </Note>

  <Accordion title="Real-time notes in Notion" icon="note-sticky">
    Connect an agent to a call to take notes in real time, so you can focus on the problem at hand.

    <Steps>
      <Step title="Connect your agent to Notion">
        In your harness of choice, ensure you're connected to [Notion's MCP](https://developers.notion.com/guides/mcp/overview). If you're using Claude desktop, you can use [Notion connector](https://claude.com/marketplace/connectors/notion) instead.
      </Step>

      <Step title="Start capturing">
        See [starting and stopping capture](/pairing-with-tuple/capturing-calls#starting-and-stopping-capture) to get it going.
      </Step>

      <Step title="Connect an agent to the call">
        In your terminal, run:

        ```bash theme={null}
        tuple connect "Create a new Notion page and start taking live notes there. Open the page in my default browser."
        ```

        Once the agent boots up, you should see a Notion page open in your browser.
      </Step>

      <Step title="Share your screen">
        If you're [sharing app metadata](/pairing-with-tuple/sharing-app-metadata), others on the call will receive the URL of the newly-created Notion document. They can then open it locally. It will also get stored in their [local history](/pairing-with-tuple/local-call-history).
      </Step>
    </Steps>
  </Accordion>

  <Accordion title="Fact checking" icon="magnifying-glass">
    Connect an agent to a call to check claims against your codebase, your data, and the web, so you can catch incorrect assumptions before you act on them.

    <Steps>
      <Step title="Give your agent access to your sources">
        Open your terminal in the repo you're discussing. To check against production data, connect your agent to the MCP servers for the tools you use, like your database, analytics, or error tracker.
      </Step>

      <Step title="Start capturing">
        See [starting and stopping capture](/pairing-with-tuple/capturing-calls#starting-and-stopping-capture) to get it going.
      </Step>

      <Step title="Connect an agent to the call">
        In your terminal, run:

        ```bash theme={null}
        tuple connect "Follow this call and fact check claims we make about the codebase, our data, or anything you can verify on the web. When something we say is wrong, send me a Tuple notification with the correction and your source."
        ```

        When the agent catches something, a notification will appear on your screen during the call.
      </Step>
    </Steps>
  </Accordion>

  <Accordion title="Live updates in Slack" icon="slack">
    Connect an agent to a call to post updates in a Slack channel as you work, so your team can follow along without joining.

    <Steps>
      <Step title="Connect your agent to Slack">
        In your harness of choice, ensure you're connected to [Slack's MCP](https://docs.slack.dev/ai/slack-mcp-server/). If you're using Claude desktop, you can use the [Slack connector](https://claude.com/marketplace/connectors/slack) instead.
      </Step>

      <Step title="Start capturing">
        See [starting and stopping capture](/pairing-with-tuple/capturing-calls#starting-and-stopping-capture) to get it going.
      </Step>

      <Step title="Connect an agent to the call">
        In your terminal, run:

        ```bash theme={null}
        tuple connect "Follow this call and post short updates in #incidents as we make progress: what we've found, what we've ruled out, and what we've decided. Post in a single thread."
        ```

        Replace `#incidents` with the channel you want updates in.
      </Step>
    </Steps>
  </Accordion>

  <Accordion title="Open a shared URL locally" icon="arrow-up-right-from-square">
    Open the page or file your pair is looking at on your own machine, so you can follow along without asking them to paste a link.

    <Steps>
      <Step title="Start capturing">
        See [starting and stopping capture](/pairing-with-tuple/capturing-calls#starting-and-stopping-capture) to get it going.
      </Step>

      <Step title="Have someone share their screen">
        The person sharing must be [sharing app metadata](/pairing-with-tuple/sharing-app-metadata). If an app like Chrome or Safari is focused, they'll share the current URL with you.
      </Step>

      <Step title="Open the most recently shared URL">
        In your terminal, run (requires [`jq`](https://jqlang.org/)):

        ```bash theme={null}
        tuple --format json capture show \
          | jq -r 'select(.type == "shared_content_changed") | .data.url.value // empty' \
          | tail -n 1 \
          | xargs open
        ```

        This finds the last URL your pair shared and opens it in your browser.
      </Step>
    </Steps>
  </Accordion>

  <Accordion title="Live iteration on an artifact" icon="arrows-rotate">
    Connect an agent to a call to make changes to what you're building as you and your pair talk it through and annotate on screen.

    <Steps>
      <Step title="Start capturing">
        See [starting and stopping capture](/pairing-with-tuple/capturing-calls#starting-and-stopping-capture) to get it going.
      </Step>

      <Step title="Get your project ready to iterate on">
        In your terminal, navigate to the directory of a project you want to work on with your pair. Get it into a state where you can see changes quickly (for example, start a development server).

        Then [share your screen](/pairing-with-tuple/sharing-your-screen) with the artifact open, so your pair can see it and [annotate](/pairing-with-tuple/collaborative-painting) on it.
      </Step>

      <Step title="Connect an agent to the call">
        In that same directory, run:

        ```bash theme={null}
        tuple connect "Help us iterate on this project. Listen for suggestions about it, and watch for annotations on the shared screen that point out changes. Before you act on any feedback, send me a Tuple notification that describes the change and ask me to confirm it."
        ```

        When the agent picks up on feedback, a notification appears on your screen with the change it wants to make. The agent makes the change only after you accept.
      </Step>
    </Steps>
  </Accordion>

  ## After a call

  <Accordion title="Create an HTML call summary" icon="file-lines">
    Have an agent create a pretty page summarizing the call, complete with screenshots.

    <Steps>
      <Step title="Do a call with capture enabled">
        See [starting and stopping capture](/pairing-with-tuple/capturing-calls#starting-and-stopping-capture) to get it going.
      </Step>

      <Step title="Open the call in an agent">
        After the captured call is complete, you'll get a notification to open it (if you haven't [silenced it](/application-preferences/macos-preferences-capture#notify-me-when-capture-is-complete)).

        Once the call is open in [local history](/pairing-with-tuple/local-call-history), copy the CLI command listed there to launch a CLI-based agent with the call loaded. Or you can copy the prompt on that screen to load the call into a GUI agent, or an agent that's already running.
      </Step>

      <Step>
        Once the call's been loaded into an agent, give it this prompt:

        <Prompt description="Create a pretty HTML call summary">
          Create a visually beautiful HTML page summarizing what happened on this call.

          * Run `tuple agent guide call-content` to understand what call info you have
          * Extract any really impactful pull quotes and present them in a clear and striking way
          * Pull out screenshots of key moments - either when what was on screen was pivotal to the discussion, or when folks were annotating on the screen
        </Prompt>

        Because the agent has access to both the transcript and the screen recording, it can use its best judgement to pull screen shots from important moments.
      </Step>
    </Steps>
  </Accordion>

  <Accordion title="Automatically update your personal wiki" icon="bookmark">
    Have an agent automatically add what you learn on every call to a [personal wiki](https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f).

    <Steps>
      <Step title="Capture every call">
        Turn on [Start Capture automatically](/application-preferences/macos-preferences-capture#start-capture-automatically), so the wiki gets updated from all of your calls, not only the ones you remember to capture.
      </Step>

      <Step title="Have an agent create a trigger">
        Start an agent in your terminal and give it this prompt:

        <Prompt description="Create a trigger that updates your wiki">
          Create a Tuple trigger that updates my personal wiki each time a call capture completes.

          * Run `tuple agent guide automation` to learn how Tuple triggers work, and read the trigger docs it points to
          * Use the `call-capture-complete` event
          * My wiki is a folder of Markdown files at `~/wiki`
          * When the trigger fires, start an agent in the background that reads the capture and updates the wiki: add a page for the call, and update the pages for the people, projects, and decisions that came up
        </Prompt>

        Replace `~/wiki` with the folder you want your wiki in.
      </Step>
    </Steps>

    After your next call, the [trigger](/triggers/building-a-trigger) will run and update your wiki.
  </Accordion>

  <Accordion title="Collaborative PR review" icon="code-pull-request">
    Review a pull request together on a call, then have an agent turn what you agreed on into replies to the PR comments.

    <Steps>
      <Step title="Connect your agent to GitHub">
        Install the [GitHub CLI](https://cli.github.com/) and sign in with `gh auth login`. Or, in your harness of choice, connect to [GitHub's MCP server](https://github.com/github/github-mcp-server).
      </Step>

      <Step title="Do a call about a PR with capture enabled">
        See [starting and stopping capture](/pairing-with-tuple/capturing-calls#starting-and-stopping-capture) to get it going. Go through the PR's comments together and talk through how to respond to each one.
      </Step>

      <Step title="Open the call in an agent">
        After the captured call is complete, you'll get a notification to open it (if you haven't [silenced it](/application-preferences/macos-preferences-capture#notify-me-when-capture-is-complete)).

        Once the call is open in [local history](/pairing-with-tuple/local-call-history), copy the CLI command listed there to launch a CLI-based agent with the call loaded. Or you can copy the prompt on that screen to load the call into a GUI agent, or an agent that's already running.
      </Step>

      <Step title="Draft and post replies">
        Once the call's been loaded into an agent, give it this prompt:

        <Prompt description="Draft replies to PR comments">
          Draft replies to the pull request comments we discussed on this call.

          * Run `tuple agent guide call-content` to understand what call info you have
          * Find the pull request from the URLs in the app metadata, or from what we said
          * For each comment where we agreed on a response, draft a reply
          * Show me each draft and ask whether it looks okay before you post it
          * Post the replies I approve to the pull request
        </Prompt>

        The agent will go through your responses to each PR comment and draft a reply. If you approve the draft, it'll post it.
      </Step>
    </Steps>
  </Accordion>

  <Accordion title="Bug reproduction screenshots" icon="bug">
    Reproduce a bug together on a call, then have an agent write the ticket, complete with screenshots of the bug.

    <Steps>
      <Step title="Connect your agent to your issue tracker">
        In your harness of choice, ensure you're connected to the MCP server or CLI for your issue tracker, like Linear, Jira, or GitHub Issues.
      </Step>

      <Step title="Reproduce the bug on a call with capture enabled">
        See [starting and stopping capture](/pairing-with-tuple/capturing-calls#starting-and-stopping-capture) to get it going. [Share your screen](/pairing-with-tuple/sharing-your-screen) and walk through the bug with your pair, so the recording shows it happening.
      </Step>

      <Step title="Open the call in an agent">
        After the captured call is complete, you'll get a notification to open it (if you haven't [silenced it](/application-preferences/macos-preferences-capture#notify-me-when-capture-is-complete)).

        Once the call is open in [local history](/pairing-with-tuple/local-call-history), copy the CLI command listed there to launch a CLI-based agent with the call loaded. Or you can copy the prompt on that screen to load the call into a GUI agent, or an agent that's already running.
      </Step>

      <Step title="Create the ticket">
        Once the call's been loaded into an agent, give it this prompt:

        <Prompt description="Create a bug ticket from a call">
          Create a ticket in our issue tracker for the bug we reproduced on this call.

          * Run `tuple agent guide call-content` to understand what call info you have
          * Include the steps to reproduce, what we expected, and what happened instead
          * Use `tuple screen --at` to extract screenshots of the moments when the bug was visible, and add them to the ticket
          * If, in the course of the investigation, we encountered a meaningful stack trace, error message, or log line, find a screenshot of it and convert it to text in the ticket
        </Prompt>

        Because the agent has access to the transcript, the screen recording, and the files and URLs shared on the call, it can pull the reproduction steps both from what you said and the evidence from what you showed.
      </Step>
    </Steps>
  </Accordion>

  <Accordion title="Visual before and after" icon="images">
    Have an agent pull before and after screenshots of what you changed on a call.

    <Steps>
      <Step title="Work through visual changes on a call with capture enabled">
        See [starting and stopping capture](/pairing-with-tuple/capturing-calls#starting-and-stopping-capture) to get it going. [Share your screen](/pairing-with-tuple/sharing-your-screen) and work through the changes with your pair, so the recording shows how things looked from start to finish.
      </Step>

      <Step title="Open the call in an agent">
        After the captured call is complete, you'll get a notification to open it (if you haven't [silenced it](/application-preferences/macos-preferences-capture#notify-me-when-capture-is-complete)).

        Once the call is open in [local history](/pairing-with-tuple/local-call-history), copy the CLI command listed there to launch a CLI-based agent with the call loaded. Or you can copy the prompt on that screen to load the call into a GUI agent, or an agent that's already running.
      </Step>

      <Step title="Extract the screenshots">
        Once the call's been loaded into an agent, give it this prompt:

        <Prompt description="Extract before and after screenshots">
          Create before and after screenshots of what we worked on most during this call.

          * Run `tuple agent guide call-content` to understand what call info you have
          * Use `tuple screen --at` to extract a screenshot of it before we started changing it, and another of how it looked at the end
          * Save them as `before.jpg` and `after.jpg` in the current directory
        </Prompt>

        You can use the screenshots in a PR description, for example.
      </Step>
    </Steps>
  </Accordion>

  <Accordion title="Incident response timeline" icon="triangle-exclamation">
    Have an agent put together a timeline of how your team resolved an incident on a call.

    <Steps>
      <Step title="Respond to an incident on a call with capture enabled">
        See [starting and stopping capture](/pairing-with-tuple/capturing-calls#starting-and-stopping-capture) to get it going. [Share your screen](/pairing-with-tuple/sharing-your-screen) as you work the incident, so the recording shows the dashboards and logs you looked at.
      </Step>

      <Step title="Open the call in an agent">
        After the captured call is complete, you'll get a notification to open it (if you haven't [silenced it](/application-preferences/macos-preferences-capture#notify-me-when-capture-is-complete)).

        Once the call is open in [local history](/pairing-with-tuple/local-call-history), copy the CLI command listed there to launch a CLI-based agent with the call loaded. Or you can copy the prompt on that screen to load the call into a GUI agent, or an agent that's already running.
      </Step>

      <Step title="Create the incident timeline">
        Once the call's been loaded into an agent, give it this prompt:

        <Prompt description="Create an incident timeline">
          This call was a response to an incident. Put together a timeline of how we remediated it, and write it to a nicely formatted HTML file.

          * Run `tuple agent guide call-content` to understand what call info you have
          * Link to the dashboards we looked at, using the URLs in the app metadata
          * Use `tuple screen --at` to extract screenshots of relevant moments
          * Include the log lines that helped us track down the problem, converted to text
          * End with what the ultimate solution was
        </Prompt>

        Because the agent has access to the transcript, the screen recording, and app metadata, it can connect what you said to what was on screen at each step.
      </Step>
    </Steps>
  </Accordion>

  <Accordion title="Transition to deep work" icon="brain">
    Bring what you discussed on a call into the agent you already use for focused work, so it can pick up where the conversation left off.

    <Steps>
      <Step title="Talk through something meaty on a call with capture enabled">
        See [starting and stopping capture](/pairing-with-tuple/capturing-calls#starting-and-stopping-capture) to get it going. Talk through a big decision or outline an approach with your pair.
      </Step>

      <Step title="Bring the call into the agent you already use">
        After the captured call is complete, you'll get a notification to open it (if you haven't [silenced it](/application-preferences/macos-preferences-capture#notify-me-when-capture-is-complete)).

        Once the call is open in [local history](/pairing-with-tuple/local-call-history), copy the **Prompt** and paste it into the agent session you already have running for your deep work. The agent keeps everything it already knows about your project and adds the context from the call.
      </Step>

      <Step title="Have the agent make a plan">
        Once the call's been loaded into your agent, give it this prompt:

        <Prompt description="Make a plan from a call">
          Make a plan for yourself based on the outcome of the call you just loaded.

          * Run `tuple agent guide call-content` to understand what call info you have
          * Base the plan on what we decided and the approach we outlined, not on ideas we discussed and set aside
          * Call out any open questions we didn't resolve
          * Write your plan to `plan.md`
        </Prompt>

        The agent will write its plan to `plan.md`, where you can check it before jumping into implementation.
      </Step>
    </Steps>
  </Accordion>
</View>