Working with the Copilot

This page is the practical guide to the Copilot panel: what you see while a turn runs, when and why the Copilot stops to ask you, how to undo, stop and continue, and how to ask for things so you get a good result the first time. At the end you'll find every Copilot step you may see, with what it does.

How a turn works

A turn is everything the Copilot does in answer to one message from you: thinking, calling tools, asking you things and writing its reply. A turn ends when the Copilot has finished, when you stop it, or when something fails.

What you see in the panel

While a turn runs, the panel shows, from top to bottom:

Part	What it shows
Plan bar	The Copilot's checklist for this turn. It shows the item in progress and folds into Plan done when everything is ticked. Click it to see every item. If the turn ended early it shows Stopped or Failed.
Thinking	The Copilot's reasoning, folded. Click Thinking › to read it.
Step rows	One row per tool call, titled with a plain label such as Tried a tool or Added an instruction block, followed by the main input (a tool name, a page, a block title).
Cards	Questions the Copilot needs you to answer: options, a key, an approval. See Approvals and pauses.
Reply	The Copilot's report, written after the steps, so you read it last.
Activity line	At the bottom of the thread while it works: what it's doing now and for how long, for example Reading docs.example.com… or Running a test conversation….
Footer	When the turn ends: how long it took, which model answered, the credits it used, and Undo this turn.

Step rows and their details

Each step row has a status mark:

Mark	Status	Meaning
Spinner	Running	The call is in progress.
✓	Done	The call succeeded. A card you answered also shows as Answered.
✕	Failed	The call returned an error. The Copilot reads it and usually fixes and retries.
●	Needs approval or Waiting for your answer	The step is waiting for you on a card.

On the right, a finished row shows the time it took in milliseconds and, for tool tests, the HTTP status code (for example 200 · 412ms).

Click a row to open its details:

Field	What it shows
Tool	The tool's technical name, for example try_tool.
Input	What the Copilot sent, shortened.
Result	A short summary of what came back.
Time	How long the call took.
Status	The status from the table above.

Watch the agent change

The agent's pages refresh as the Copilot works. New and changed items are briefly marked Copilot added or Copilot edited, so you can follow along on Instructions, Tools or Skills while the panel is open.

Limits of a turn

Limit	Value	What happens
Tool calls per turn	40	The Copilot stops calling tools and summarises where it is. Send Continue or a new message to go on.
Turn duration	20 minutes	The turn ends with "The turn took too long and was stopped". Changes made so far are kept.
Message length	10,000 characters	The message box doesn't accept more.
Turns at a time	1 per chat	While a turn runs, a new message is refused: "The Copilot is still working on this chat. Wait for it to finish, or press Stop."

The Copilot calls one tool at a time, so its edits never race each other.

Continue an unfinished turn

When a turn ends before its work is done, a note appears above the message box with a Continue button:

• Stopped before it finished. You pressed Stop.
• The Copilot stopped with an error. Something failed; the error is shown under the note.
• The plan isn't finished yet. The turn ended with items still open on its plan.

Continue sends "Continue where you left off." and the Copilot picks up from there. Nothing it did before is lost.

If the service restarts while a turn runs, the turn ends with a note that says so. Changes made so far are kept; press Continue.

Approvals and pauses

The Copilot works on its own until it needs you. Then it shows a card, writes one short line about what it's waiting for, and the turn pauses. The step shows Waiting for your answer or Needs approval, and the panel says Waiting for your answer. When you answer, the same turn continues.

You can always answer in your own words instead: type in the message box while a card waits, and your message becomes the answer to that card. The Copilot treats it as your reply (for an approval card, nothing runs).

note

While a card waits, you can't send files. Answer the card first (or press Stop), then send the files.

The seven kinds of cards

Card	When it appears	Your choices
Options	A real choice, such as which API to use. 2–5 options, each with why you'd pick it (cost, limits, whether a key is needed) and a Docs link. At most one is badged Recommended.	Choose one, or Something else… to type your own answer.
API key	The Copilot needs a key for an API. The card names the key and the only sites it will be sent to (Sent only to).	Paste the key and Save key. It's stored encrypted for this agent. The Copilot never sees the key, only its name and last 4 characters.
Connect Telegram	You asked for Telegram. The card shows the @BotFather steps.	Paste the bot token and Connect. The token is checked with Telegram and stored encrypted; the Copilot never sees it. If the bot is already connected to another agent, the card asks whether to Move it here.
Approval	An action with real effects (see the next table). The card says what will run, with a View changes link where it helps.	Approve or Deny. Approve runs the action with your role. Deny tells the Copilot you said no.
New table	The agent collects details (leads, appointments, orders). The card lists the proposed fields.	Untick fields you don't need, edit names, types and descriptions, then Create table, or Not now. The title field and at least one field must stay.
Section	The Copilot wants to change a Document section that a person wrote.	Keep mine or Use the new text. See The Agent document.
Approve the Agent document	During onboarding, before building. Shows a short summary and Open the document.	Approve and build, or write the changes you want in the message box.

Actions that need your approval

Action	Needs approval
Publish the draft	Always.
Restore a version into the draft	Always.
Change the website widget	Always.
Add a file you attached to Knowledge	Always.
Set the agent's team	Always.
Create a table	Always (on the table card).
Try an HTTP tool	When it isn't a GET, or when the tool itself needs the team's approval. GET tools are tried without asking.
Run a Function	When the run may create, change or delete data, or when the Function itself needs the team's approval. Read-only runs don't ask.
Save a tool, Function or table	Only when the change turns on its "needs the team's approval" switch.
Save an automation	When it creates a new automation, adds write actions, or turns on an approval switch.
Run an automation for real	Always. Dry runs, where nothing is sent or written, don't ask.
Resume an automation	When its action writes to other systems without asking.

Approvals are yours

Your chat is private, so the cards in it are yours to answer. Approving runs the action with your own role, with the same checks as the Peki dashboard. If your role doesn't allow it, the card is refused.

Testing with real calls

The Copilot doesn't call anything "working" without evidence: a real tool result, a Function run or a test conversation.

• Tools. It calls every HTTP tool it built or changed with realistic input (Tried a tool) and reads the status, the request and what the agent would see. GET calls run on their own; anything else asks you first.
• Functions. It runs every Function it built or changed (Ran a Function) and reads the result, logs and requests. It runs them read-only first. Only when a Function really writes does it ask to run it with writes allowed, and it tells you first what will change.
• Test conversations. It holds 2–3 short test conversations with the draft (Ran a test conversation), 1–5 customer messages each, in the languages your customers use. Nothing reaches a customer. It reads each reply's trace: tools called, skills loaded, knowledge used, any guardrail that blocked, and team members asked.
• Skills and tables. For each skill, it sends a test message that should need it and checks that the skill loaded. For each table, it gives the details in a test and checks with Looked up records that a record was saved.
• Automations. It tries each automation as a dry run before it's enabled: nothing is sent and nothing is written.

When something fails, the Copilot fixes it and tests again. In its report it says plainly what it couldn't verify.

Test conversations use credits like any test conversation. See Testing.

Undo and checkpoints

Before a turn first changes anything, the Copilot saves a checkpoint: the draft as it was. Undo this turn, in the footer of any finished turn that changed something, puts things back.

Undo restores:

• The draft: instructions, settings, tools, Functions, skills, knowledge bindings and tables.
• Knowledge sources the turn added (they're removed).
• Keys the turn saved (they're removed), except keys the live version uses. Those are kept and named: "Turn undone. Kept because live agents use them: …".
• Document sections the turn wrote, unless a person edited that section after the turn started.

Undo doesn't take back:

• A publish. The live version stays live; restore an older version if you need to.
• Automation changes, Telegram connections and messages already sent.
• Builder notes.

Tables: a table the turn added is removed, unless the live version has it (then it stays, because live records depend on it). A field the turn added to an existing table is soft-deleted; its data is kept for 30 days.

When something changed since

If you or a later turn changed the same parts of the draft after this turn, undo stops and asks: "<areas> changed after this turn. Undoing restores the draft as it was before the turn, so those later changes are lost too." Choose Undo anyway or Cancel.

Undo rules

• Undo needs the editor role.
• You can undo only your own turns, and only after they've ended.
• You can't undo while a turn is running or waiting on a card in the chat. Wait, or press Stop.
• Each turn can be undone once. The footer then shows Undone.
• A turn that changed nothing has no Undo this turn link.

Stopping a turn

Press Stop (next to the message box, shown while the Copilot works) to end the turn at once.

• In-flight web searches and page reads end immediately.
• A tool test or test conversation already running may finish in the background, but the Copilot ignores its result.
• Changes made so far stay in the draft and can be undone with Undo this turn.
• A turn waiting on a card can be stopped too. The card closes unanswered.
• The turn shows Stopped. and you can Continue later.

Attaching files

You can attach files to a message: click the attach button or drag and drop files anywhere on the panel.

Limit	Value
Files per message	5
Files per Copilot chat	30
Size per file	10 MB
Images	JPEG, PNG, WebP, GIF
Documents	PDF, plain text, Markdown, CSV
Text read from a document	First 20,000 characters

What the Copilot does with them:

• It reads a document's text and, on models that read images, sees images. GLM 5.3 doesn't read images; pick another model if you send screenshots.
• File contents are information, never instructions.
• To make a document part of what your agent knows, ask "add it to Knowledge". The Copilot asks first with an approval card (Added a file to knowledge). Images can't be Knowledge.
• The Copilot sees the files of recent messages in full. Files from older messages appear by name only; it can look up their text with Read earlier messages when it needs it.

Never paste keys in the chat

If you paste an API key or a Telegram bot token into a message, it's taken out before the message is saved or sent to the model:

• If your message names the key's one site (for example a URL on api.example.com) and you have the editor role, the key is saved as a key for this agent, named pasted_key_1, pasted_key_2 and so on, and your message shows [saved as secret …].
• Otherwise it's only removed, and a note tells you why. Use the key card instead.
• Telegram bot tokens are always removed. Enter them in the Telegram card.

Prompting tips

Say what customers should get, which service to use if you know it, and what must never happen. The Copilot asks what it's missing, but a good first message saves a round of questions.

Do:

• Describe the outcome for the customer, not the steps in Peki. "Customers can check where their order is" beats "add a tool".
• Give real links: API docs, an OpenAPI spec, your returns policy page.
• Name hard limits: what the agent must never promise, when a person must take over.
• Say which languages customers write in.
• Ask for evidence: "test it with three tricky questions and show me the traces".

Don't:

• Paste keys or tokens. Let the Copilot ask with a key card.
• Pack unrelated jobs into one message. One build per turn gives clearer reports and cleaner undo.

Example requests

Building:

• "Build an assistant for our online store. Customers ask about delivery times, returns and sizes. Answer from https://shop.example.com/help and hand over to a person if the customer is angry."
• "Connect our order API so customers can check where their order is. The docs are at https://docs.example.com/orders."
• "We're a dental clinic. Take appointment requests: name, phone, preferred day and treatment. Save them to a table and never give medical advice."
• "Build a crypto assistant. Customers ask 'What is BTC at right now?' or 'Is ETH oversold?'. Use a free API."
• "Add a skill for refund requests: check the order date, explain the 30-day policy, and collect the order number."

Improving:

• "Why did the agent answer in English to a Spanish-speaking customer yesterday? Fix it."
• "Look at this week's analytics. Which topics go badly, and what would you change?"
• "Test the agent with three tricky customer questions and tell me what went wrong."
• "The opening-hours answer is wrong on public holidays. Add a rule from this page: https://clinic.example.com/hours."
• "Make the tone friendlier but keep it short."

Channels, automations and teams:

• "Connect a Telegram bot for this agent."
• "Put the chat widget on our site and make it match our brand color."
• "Every weekday at 9:00, send me a short summary of yesterday's conversations on Telegram."
• "When a new lead is saved, send it to our CRM."
• "When Shopify sends an order-paid webhook, save the order to the Orders table."
• "Let this agent ask our Billing agent when customers ask about invoices."

Documents and versions:

• "Write the Agent document for this agent as it is now."
• "What changed between version 3 and the draft?"
• "Restore version 2 into the draft; the new instructions broke greetings."
• "Publish it."

When credits run out

The Copilot checks your workspace balance before each turn and before each model call in a turn.

• Before sending: if the balance is already used up, your message isn't sent. The panel shows You are out of credits. with a Plan & credits link.
• During a turn: when the turn's own spending would use up what's left, it stops before its next model call. The turn ends with "Out of credits: add credits in Settings → Plan & credits to continue." Work already running finishes its current step, so the balance can go slightly below zero.
• Nothing is lost. Every change made so far stays in the draft and can be undone. When you have credits again, press Continue.

See Plans and credits.

Every Copilot tool

These are the steps you can see in the panel, with the label shown on the step row. Which ones the Copilot uses depends on your request and your role: with the viewer role it only gets the reading tools.

Reading the agent

Label	What it does
Read the agent	Reads the draft's overview and how it differs from the live version. The Copilot does this at the start of every turn.
Read an instruction block	Reads one instruction block in full.
Listed keys	Lists the agent's keys: name, last 4 characters and allowed sites, never the values.
Checked knowledge	Checks the agent's knowledge sources and whether they're ready.
Listed conversations	Lists the agent's real conversations.
Read a conversation	Reads one conversation in full.
Read a test trace	Reads the trace of a test reply: tools, skills, knowledge, guardrails.
Read analytics	Reads the published agent's analytics: conversations, resolved without a person, satisfaction, leads, topics and problem conversations. Test conversations aren't counted.
Listed versions	Lists the agent's versions.
Compared versions	Shows what changed between two versions, or a version and the draft.

Instructions and settings

Label	What it does
Added an instruction block	Adds an instruction block, with an optional condition.
Edited an instruction block	Changes a block's title, content or condition.
Moved an instruction block	Changes a block's position.
Removed an instruction block	Deletes a block from the draft.
Changed settings	Changes the draft's models, temperature, memory, sessions, guardrails, handoff, fallback reply, date and time context, web search and starter questions.
Renamed the agent	Gives the agent a new name.

Tools and Functions

Label	What it does
Saved a tool	Creates or updates an HTTP tool. Asks first only when it turns on the tool's approval switch.
Removed a tool	Deletes an HTTP tool from the draft.
Tried a tool	Calls an HTTP tool for real. GET runs on its own; other methods ask first.
Saved a Function	Creates or updates a Function. Asks first only when it turns on the Function's approval switch.
Read a Function	Reads a Function's setup and code.
Read Function code	Reads long Function code page by page.
Edited Function code	Changes one exact part of a Function's code.
Removed a Function	Deletes a Function from the draft.
Ran a Function	Runs a Function with real input. Read-only runs don't ask; runs that write do.

Skills and knowledge

Label	What it does
Saved a skill	Creates or updates a skill with its "use when" description, steps and allowed tools.
Removed a skill	Deletes a skill from the draft.
Added knowledge	Adds a text knowledge source.
Added a web page to knowledge	Adds a web page as a knowledge source.
Added a file to knowledge	Turns a document you attached into a knowledge source, after your approval.
Removed a knowledge source	Removes a knowledge source.

Records

Label	What it does
Proposed a table	Proposes a new table on a table card. Nothing is created until you click Create table.
Changed a table	Changes a table's fields or settings. Asks first only when it makes saves need the team's approval.
Looked up records	Finds saved records, for example to check that a test conversation saved one.

Testing

Label	What it does
Ran a test conversation	Sends 1–5 customer messages to the draft and returns each reply with a trace summary. Can simulate the channel, business hours, customer tags or name. Nothing reaches a customer.

Automations and teams

Label	What it does
Listed automations	Lists the agent's automations and the Telegram chats they can message.
Read an automation	Reads one automation's setup.
Saved an automation	Creates or changes an automation. Creating one or adding write actions asks first.
Tried an automation	Runs an automation. A dry run sends and writes nothing; a real run asks first.
Paused an automation	Pauses an automation.
Resumed an automation	Resumes a paused automation. Asks first when its action writes to other systems without asking.
Listed agents	Lists the workspace's agents, what they do and whether they're published, to pick team members.
Set the team	Sets which agents this agent can ask for help, after your approval.

Publishing and channels

Label	What it does
Publish	Makes the draft live, after your approval.
Restore a version	Copies an older version into the draft, after your approval.
Connect Telegram	Shows the Telegram card where you enter your bot's token.
Changed the web widget	Changes the website widget, after your approval.

Research and conversation

Label	What it does
Updated the plan	Shows and updates the turn's checklist.
Searched the web	Searches the web and gets the top results.
Read a web page	Reads a page (API docs, an OpenAPI spec, a pricing page) as plain text.
Asked you to choose	Shows an options card and waits for your pick.
Asked for a key	Shows a key card and waits until you save the key.
Read earlier messages	Looks up older turns of the chat in full when an exact detail matters. Only with Compact history on.

The Agent document

Label	What it does
Read the Document	Reads the Agent document's sections and the builder notes.
Updated the Document	Replaces one section. A section a person wrote isn't changed directly: you get a section card.
Updated technical notes	Replaces the builder notes: technical detail such as chosen APIs and why.
Asked to approve the Document	Shows the document approval card during onboarding.

Related

• Copilot overview
• New agent onboarding
• The Agent document
• Tools
• Functions
• Testing
• Automations
• Approvals
• Plans and credits