Skip to main content
Capture 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.
  2. Install the Tuple CLI.

​
During a call

Claude Code and Pi currently work best for following a call in real time. See Ask an agent to follow along for details.
Connect an agent to a call to take notes in real time, so you can focus on the problem at hand.
1

Connect your agent to Notion

In your harness of choice, ensure you’re connected to Notion’s MCP. If you’re using Claude desktop, you can use Notion connector instead.
2

Start capturing

See starting and stopping capture to get it going.
3

Connect an agent to the call

In your terminal, run:
Once the agent boots up, you should see a Notion page open in your browser.
4

Share your screen

If you’re 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.
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.
1

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.
2

Start capturing

See starting and stopping capture to get it going.
3

Connect an agent to the call

In your terminal, run:
When the agent catches something, a notification will appear on your screen during the call.
Connect an agent to a call to post updates in a Slack channel as you work, so your team can follow along without joining.
1

Connect your agent to Slack

In your harness of choice, ensure you’re connected to Slack’s MCP. If you’re using Claude desktop, you can use the Slack connector instead.
2

Start capturing

See starting and stopping capture to get it going.
3

Connect an agent to the call

In your terminal, run:
Replace #incidents with the channel you want updates in.
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.
1

Start capturing

See starting and stopping capture to get it going.
2

Have someone share their screen

The person sharing must be sharing app metadata. If an app like Chrome or Safari is focused, they’ll share the current URL with you.
3

Open the most recently shared URL

In your terminal, run (requires jq):
This finds the last URL your pair shared and opens it in your browser.
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.
1

Start capturing

See starting and stopping capture to get it going.
2

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 with the artifact open, so your pair can see it and annotate on it.
3

Connect an agent to the call

In that same directory, run:
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.

​
After a call

Have an agent create a pretty page summarizing the call, complete with screenshots.
1

Do a call with capture enabled

See starting and stopping capture to get it going.
2

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).Once the call is open in local 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.
3
Once the call’s been loaded into an agent, give it this prompt:

Create a pretty HTML call summary

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.
Have an agent automatically add what you learn on every call to a personal wiki.
1

Capture every call

Turn on Start Capture automatically, so the wiki gets updated from all of your calls, not only the ones you remember to capture.
2

Have an agent create a trigger

Start an agent in your terminal and give it this prompt:

Create a trigger that updates your wiki

Replace ~/wiki with the folder you want your wiki in.
After your next call, the trigger will run and update your wiki.
Review a pull request together on a call, then have an agent turn what you agreed on into replies to the PR comments.
1

Connect your agent to GitHub

Install the GitHub CLI and sign in with gh auth login. Or, in your harness of choice, connect to GitHub’s MCP server.
2

Do a call about a PR with capture enabled

See starting and stopping capture to get it going. Go through the PR’s comments together and talk through how to respond to each one.
3

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).Once the call is open in local 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.
4

Draft and post replies

Once the call’s been loaded into an agent, give it this prompt:

Draft replies to PR comments

The agent will go through your responses to each PR comment and draft a reply. If you approve the draft, it’ll post it.
Reproduce a bug together on a call, then have an agent write the ticket, complete with screenshots of the bug.
1

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.
2

Reproduce the bug on a call with capture enabled

See starting and stopping capture to get it going. Share your screen and walk through the bug with your pair, so the recording shows it happening.
3

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).Once the call is open in local 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.
4

Create the ticket

Once the call’s been loaded into an agent, give it this prompt:

Create a bug ticket from a call

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.
Have an agent pull before and after screenshots of what you changed on a call.
1

Work through visual changes on a call with capture enabled

See starting and stopping capture to get it going. Share your screen and work through the changes with your pair, so the recording shows how things looked from start to finish.
2

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).Once the call is open in local 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.
3

Extract the screenshots

Once the call’s been loaded into an agent, give it this prompt:

Extract before and after screenshots

You can use the screenshots in a PR description, for example.
Have an agent put together a timeline of how your team resolved an incident on a call.
1

Respond to an incident on a call with capture enabled

See starting and stopping capture to get it going. Share your screen as you work the incident, so the recording shows the dashboards and logs you looked at.
2

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).Once the call is open in local 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.
3

Create the incident timeline

Once the call’s been loaded into an agent, give it this prompt:

Create an incident timeline

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.
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.
1

Talk through something meaty on a call with capture enabled

See starting and stopping capture to get it going. Talk through a big decision or outline an approach with your pair.
2

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).Once the call is open in local 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.
3

Have the agent make a plan

Once the call’s been loaded into your agent, give it this prompt:

Make a plan from a call

The agent will write its plan to plan.md, where you can check it before jumping into implementation.