Test tools safely before customers use them

Try an agent's tools in its test chat and test calls without changing anything in your other systems, turn on Send real changes when you want a real run, and check a tool with Check with these values and Check it.

Updated

The film starts in the test chat: the lookup runs for real and the booking waits; rewind to watch the whole story.

Before a customer talks to the agent, you want to see it use its tools: does it find the repair, does it ask before booking, does the booking land on the right calendar. You can do all of that without touching your real systems. Tools that only look things up run for real. Tools that make changes are stopped before they are sent, unless you choose otherwise.

Copperleaf Bike Works is a fictional bike repair shop. Its agent, Copperleaf Front Desk, has Look up a repair (on its workshop system) and Suggest time (on Google Calendar), which only read, and Create event (on Google Calendar) and Add a parts request, which make changes.

There are three places to test, from the smallest to the whole conversation:

WhereWhat it tests
Check it, on the tool in /integrationsOne request, with sample values
Check with these values, on the agent’s Integrations tabThe same tool, with this agent’s account and values
The test chat and Try VoiceThe whole conversation: when the agent uses the tool, how it asks, what it says after

Check it, on the integration

Open the integration under /integrations, then the tool on its Tools tab. The tool’s Check it section “Runs your unsaved draft with sample values that are only for this check.” Fill in the sample values, or pick From a sentence and type what a customer might write. The buttons depend on what the tool does:

The toolButtons
Reads dataRun check sends the real request. Preview the request builds it and sends nothing
Makes changesCheck the request builds it and sends nothing. Run for real sends it once, after you confirm

For a tool that makes changes, Check the request is enough:

“Check the request builds it and sends nothing; that’s enough to save the check. Run for real really sends it once, after you confirm.”

The result says “Checked, not run. Nothing was sent.”, shows the request we would send (keys hidden), and shows what the customer will be asked:

“The agent will read back, in the customer’s language: …”

Run for real asks first, “Really send this change?”. On a tool you built on an API it names the method and path, for example “This really sends POST /orders to the other system, once, with your sample values. It isn’t a test there: undo it afterwards if you need to.” A tool that deletes asks “Really delete?” instead. After a real run the panel reminds you: “That change really happened in the other system. Remember to undo it there if it was only a test.”

If the request uses a value each agent fills in, Agent values from picks whose values to use: “The check uses this agent’s values and the account it uses.” More on building and checking a tool is in make your own tool and check it.

Check with these values, on the agent

A tool that passed on its integration can still fail for one agent: a different account, or a value with a typo. So on the agent’s Integrations tab, a tool that uses this agent’s own values shows Check with these values. It runs the tool with this agent’s account and values:

  • A tool that reads data really runs.
  • A tool that makes changes, and any tool from an app or MCP server, is built with this agent’s values and checked, and nothing is sent.

You see “Look up a repair passed with this agent’s values.”, or “Look up a repair didn’t pass:” and the reason. The row then reads Checked with this agent’s values. Change a value afterwards and it reads Edited, check again.

Checking is optional. A tool you have not checked still works for the agent. See give an agent tools for the rest of the tab.

The test chat

On the agent’s Overview tab, Test Agent opens the test chat in a new tab. Talk to the agent the way a customer would. The chat works like website chat, with the same Confirm and Change buttons.

The test chat with the Send real changes switch off and the line explaining it, a customer asking whether repair R-2051 is ready, and the agent's answer from the workshop system: ready, pick it up after 3 pm, $85.
In the test chat, Look up a repair runs for real. The line under Send real changes says tools that change things don't really run until it is on.

What happens to each tool

If the agent has tools that make changes, a line in the header, under the Send real changes switch, says how they behave:

“In this test chat, tools that can change things don’t really run unless “Send real changes” is on, even ones set not to ask the customer first. Tools that only look things up run for real.”

So in Copperleaf’s test chat:

ToolIn the test chat
Look up a repair, Suggest timeRun for real, against the workshop system and Google Calendar
Create eventThe agent asks, you press Confirm, the card says Done. Nothing is sent, so no event is added
A tool set to Acts right awayRuns without asking, as it would for a customer. Nothing is sent

Under the agent’s reply, a change that was not sent shows one line. For a tool from an app or MCP server, such as Google Calendar’s Create event, it names the server:

Not sent (test chat) · Create event · calendarmcp.googleapis.com/…/v1 See request

A tool you built on an API shows its method and path there instead, such as POST /api/v1/orders.

The test chat: the customer asks to book a full service on Saturday at 10 am, the agent says Dana's bench is free then and proposes it with Confirm, the tester confirms, the card reads Confirmed and Done, and under the reply: Not sent (test chat) · Create event · calendarmcp.googleapis.com/…/v1, See request.
Confirm works as on website chat, but nothing reaches Google Calendar: the line under the reply says Not sent (test chat), and See request shows what would have gone out.

See request shows what would have gone out. For a tool from an app or MCP server, it lists the fields and their values; for a tool on an API, the exact request. The key is not in it:

“The account’s key is added only when a change is really sent.”

The agent is told nothing was sent, so you can test the whole flow — the question, the yes, the answer after it — as many times as you like. Changes that are not sent never count toward a conversation’s limit of five.

A proposed change waits 10 minutes in the test chat, as on website chat. Wait longer and the card reads No longer available. How each channel confirms is in changes the customer confirms.

Tools that aren’t ready

If a tool can’t run yet, the test chat says so at the top, for example:

“1 tool isn’t ready yet: Copperleaf parts needs a value.”

Fill in what it names on the agent’s Integrations tab, then start a New chat.

Send real changes

When the flow looks right and you want one real booking, turn on Send real changes in the test chat’s header. It asks first:

Send real changes from this test chat? “Changes in this test chat will really happen in Copperleaf parts, Google Calendar. Turn on for this session?”

Press Turn on. From then on a confirmed change is really sent, as it would be for a customer, and it counts toward the conversation’s five changes. Use a test record in the other system, and undo the change there afterwards.

A few things to know:

  • Only owners and admins of the workspace see the switch, and only when the agent has a tool that makes changes. When other members of the workspace test the agent, its changes are never sent.
  • It is off every time you open the test chat, and New chat turns it off again.
  • The test chat is not the only place you count as a tester. If you are signed in to the workspace and chat with the agent on its own chat page, your changes are not sent either, unless you are an owner or admin and turned on Send real changes.

Test calls

On the agent’s Try Voice tab, In Browser and Call My Phone start a test call. They follow the same rule as the test chat:

“On a test call, tools that can change things don’t really run unless “Send real changes” is on, even ones set not to ask the customer first. Tools that only look things up run for real.”

Turning on Send real changes here asks “Send real changes from this test call?” and names only the integrations whose change tools are used on calls. While it is on, the panel says “Changes on this test call are really made in the other system.”

On a call, the agent reads the details back and waits for you to say yes, so you also hear how the read-back sounds.

Try it live is real

On the agent’s Channels tab, the website chat card has Try it live. It opens your real chat widget, installed the way your website installs it. It is not a test:

“Conversations here are real: they show up in your inbox, get an AI summary a few minutes after you close this page, and can trigger your alerts.”

Changes confirmed there are really sent. Use it last, once the test chat has done what you expect.

A safe order

  1. Check it on each tool, with Check the request for the ones that make changes.
  2. Check with these values on the agent, for tools that use its own values.
  3. The test chat, with Send real changes off. Try a yes, a no, and a change of details.
  4. One run with Send real changes on, against a test record. Undo it in the other system.
  5. Try it live, then put the agent in front of customers.

Afterwards, each call the agent made is listed in see what a tool did.