#Follow what an agent did in a run
The thought loop of an agent step shows every tool the agent used during a run, in order, with its times and token usage, including the sub-processes it waited for.
#Open the thought loop
In an instance, select the agent's step and open Agent conversation. The Thought Loop lists the agent's steps from its first to its last. Its header counts the steps of the whole execution and, when the agent used BPMN tools or called its own tasks, its runs and those calls. The agent's final answer sits above the steps.
#See how long it took and how many tokens it used
The header also shows when the agent started, when it finished, how long that took in total, and how many tokens the model read (in) and wrote (out) across all runs. Each run has the same line for itself: its start, its end, its duration and its tokens.
Every tool call shows when it started and how long it ran. A BPMN tool or a task call shows two times instead:
| Time | What it measures |
|---|---|
| Call (synchronous) | From the moment the agent called the tool until its sub-process or task instance was running |
| Run time (asynchronous) | From the start of the sub-process or task until the agent continued with its result |
While the agent is still waiting, the card shows only the call time and that the sub-process is still running.
Times are shown in your browser's time zone. A time on a different day than the agent's start also shows the date. Runs recorded before Chester stored these values show no times or tokens.
#See what was pinned into the task
When the task's instructions pin notes, folders or tools, each run lists them under Pinned, with what the agent got in that run:
| Label | Meaning |
|---|---|
| content given | The note's content was in the prompt |
| given as a reference | A folder, a tool, or a note the agent was pointed to |
| too large, reference only | The note exceeded the size limit and went as a reference |
| unavailable | The vault could not be read in this run |
| invalid, not given | The pin no longer points at anything the task may use |
The pins are resolved again for every run, so a note edited between two runs shows its new content in the later one.
#Tell the kinds of tool apart
An agent can use five kinds of tool, and each has its own icon and colour:
| Kind | What it is |
|---|---|
| Vault | Reading or writing notes in one of the agent's knowledge vaults |
| Adapter | An action of a connected system |
| MCP | A tool of a connected MCP server |
| BPMN tool | A sub-process that the agent starts and waits for |
| Task | One of the agent's own tasks, run as its own instance that the agent waits for |
Each step names the tool in readable form and shows its technical name next to it. Expand a step to see what the agent sent as Input and what came back as Result. A step whose kind is unknown, such as one recorded before tool kinds existed, is shown as a plain tool.
#Follow a BPMN tool
A BPMN tool is not answered straight away. The agent starts the sub-process and pauses until it finishes, then continues in a new run. The thought loop therefore shows:
- a card for the BPMN tool with its status, the Input to the sub-process and what was Returned to the agent;
- a marker after that card, naming the tool the agent waited for;
- the steps that follow under the next run number.
sequenceDiagram
participant A as Agent
participant V as Vault
participant S as Sub-process (BPMN tool)
Note over A: Run 1
A->>V: Read note
V-->>A: Note content
A->>S: Start with input
Note over A,S: Agent paused, waiting for the sub-process
S-->>A: Returned to the agent
Note over A: Run 2
A->>A: Final answer
Show in flow on a BPMN tool card opens that tool's sub-process in the flow list next to it, so you can see which steps it ran. When the agent started more than one sub-process, the flow list below the agent numbers them like any other repeated step, under Activity. Below the numbers, a heading names the one you selected: the tool, whether it is a BPMN tool or a task, which call it was ("Call 1 of 2"), and when it started and returned.
#Follow a task the agent called
A call to one of the agent's own tasks looks like a BPMN tool: a card with the task's name, its status, the Input to the task and what was Returned to the agent, a marker naming the task the agent waited for, and the following steps under the next run number. Show in flow opens the task's own instance below the agent; select its agent step there to read that run's own thought loop. A task call that was refused because the agent nested itself too deeply shows the error as its result and has no instance to open.
#When a BPMN tool card has no link
Chester links a BPMN tool card to its sub-process only when the number of BPMN tool calls in the thought loop matches the number of sub-processes the agent started that were not task calls. If they differ, the card shows no Show in flow button and the flow list shows no heading for those sub-processes, only their numbers. A missing link is shown rather than a guessed one. Task cards are not affected: a task call is always linked to the instance it started.