Skip to main content

Execution Details

Deep dive into execution timelines, prompts, and AI-powered troubleshooting.

Overview​

The Execution Details page provides a complete picture of what happened during a single agent execution. Use it to understand agent behavior, debug issues, and optimize performance.

Accessing Execution Details​

  1. Go to Monitor > Activity > Agent Activity
  2. Click on any execution row
  3. The details page opens

Execution Header​

The header shows key metrics at a glance:

Status Badge​

  • Success (green) - Completed without errors
  • Failed (red) - Encountered an error
  • In Progress (yellow) - Still running
  • Cancelled (gray) - Was stopped
  • Resume Pending (purple timer) - Queued for automatic retry after a transient failure

Metrics Bar​

MetricDescription
DurationTotal execution time
Input TokensTokens in the prompt
Output TokensTokens in the response
Total TokensSum of input + output
CostCalculated cost

Email Input Section​

Shows the original email that triggered the execution:

Email Headers​

  • From - Sender email and name
  • To - Recipient (the monitored mailbox)
  • Subject - Email subject line
  • Date - When the email was received

Email Body​

The full email content, including:

  • Plain text or HTML rendering
  • Thread history (if included)
  • Attachments list (if any)

VIP Status​

If the sender is a VIP:

  • VIP badge displayed
  • Privilege level shown
  • Notes visible

Execution Timeline​

The timeline shows the sequence of events:

1. Execution Started​

When processing began.

2. Agent Reasoning​

The agent's "thinking" process:

  • How it interpreted the email
  • What it decided to do
  • Why it chose specific actions

What to look for:

  • Is the interpretation correct?
  • Are decisions logical?
  • Does reasoning match instructions?

3. Tool Calls​

Each tool invocation appears as a step:

For each tool call:

  • Tool name
  • Parameters passed
  • Result returned
  • Duration

Example tool call:

search_knowledge_base
Parameters: { query: "return policy", limit: 3 }
Result: [3 documents found]
Duration: 1.2s

4. Response Generated​

The final output:

  • For replies: email content generated
  • For escalations: escalation details
  • For failures: error message

5. Execution Completed​

Final status and total duration.

Request Details​

Full Prompt​

View the complete prompt sent to the LLM:

Includes:

  • System prompt (agent instructions)
  • Email content
  • Thread history
  • VIP status
  • Tool descriptions

Why review this:

  • Verify all context is included
  • Check prompt size (affects cost)
  • Debug unexpected behavior

Available Tools Panel​

The LLM Request preview includes an Available Tools section showing all tools provided to the agent for that request.

Viewing tool details:

  • Click on any tool name (green badge) to open the Tool Schema modal
  • The modal displays:
    • Tool name - The function name the LLM can call
    • Description - What the tool does
    • Parameters - A table showing all parameters with:
      • Name (in green monospace font)
      • Type (string, number, boolean, etc.)
      • Required/Optional indicator
      • Description of the parameter

Why review tools:

  • Verify the right tools are available
  • Check parameter definitions
  • Understand what capabilities the agent has
  • Debug tool usage issues

Messages Array​

The message sequence:

  • System message (instructions)
  • User message (email + context)
  • Assistant messages (responses)
  • Tool messages (results)

Response Details​

Raw Response​

The exact output from the LLM:

  • Complete text generated
  • Tool call requests
  • Any errors or issues

Parsed Output​

Structured view of what the agent did:

  • Tool calls made
  • Parameters used
  • Final response text

AI Troubleshooting​

Using Troubleshoot with AI​

For problematic executions:

  1. Click Troubleshoot with AI
  2. Wait for analysis
  3. Review findings:
    • Root cause identification
    • Suggested fixes
    • Related issues

What AI Analysis Provides​

For Failed Executions:

  • Why the failure occurred
  • What could have prevented it
  • Recommendations for fixing

For Poor Quality Responses:

  • What went wrong
  • Instruction improvements
  • Tool usage suggestions

For High-Cost Executions:

  • What drove up costs
  • Optimization opportunities
  • Model alternatives

Understanding Tool Results​

Successful Tool Calls​

Shows:

  • Parameters sent
  • Result returned
  • How agent used the result

Failed Tool Calls​

Shows:

  • Error message
  • What went wrong
  • Impact on execution

Tool Call Patterns​

Efficient pattern:

1. Search knowledge base → Found answer
2. Reply with answer

Inefficient pattern:

1. Search knowledge base → No results
2. Search again with different query → No results
3. Search third time → Found something
4. Reply with answer

The inefficient pattern uses more tokens and time.

Auto-Resume Details​

When an execution has been checkpointed for automatic retry, the execution details page shows additional resume state information.

Resume State Fields​

FieldDescription
StatusCurrent resume state: pending, resumed, completed, or abandoned
Attempt NumberWhich retry attempt this is (e.g., 2 of 5)
Max AttemptsTotal retry attempts allowed before giving up
Error ClassCategory of the transient error (e.g., balance_exhausted, rate_limit, network)
Original ErrorThe full error message from the failed attempt
Next Retry AtWhen the next retry attempt is scheduled
Progress SummaryA checkpoint summary of what the agent completed before the failure

Using Resume State for Troubleshooting​

The resume state helps you understand:

  • Why the execution paused - Check the error class and original error
  • What work was completed - Review the progress summary
  • When it will retry - Check the next retry time
  • Whether to intervene - If the error class suggests a persistent issue (e.g., balance_exhausted), you may need to top up your LLM provider credits before the next retry

For more about how auto-resume works, see Agent Executions - Auto-Resume.

Debugging with Execution Details​

Step-by-Step Debugging​

  1. Review the input - Is the email what you expected?
  2. Check agent reasoning - Did it understand correctly?
  3. Examine tool calls - Were the right tools called?
  4. Look at results - Did tools return expected data?
  5. Review response - Is the output correct?

Common Issues to Spot​

Misunderstanding the email:

  • Agent reasoning doesn't match email content
  • Wrong entities extracted
  • Context missed

Wrong tool usage:

  • Tool called when not needed
  • Wrong parameters
  • Tool not called when it should be

Response problems:

  • Missing information
  • Wrong tone
  • Incorrect facts

Making Fixes​

Based on what you find:

ProblemFix
Misunderstands email typeAdd examples to instructions
Wrong tool choiceClarify when to use each tool
Missing informationEnsure tool result is used
Wrong response formatAdd format guidelines

Comparing Executions​

Finding Similar Executions​

  1. Note the agent and email type
  2. Go back to execution list
  3. Filter by same agent
  4. Look for similar emails
  5. Compare how they were handled

What to Compare​

  • Did agent make same decisions?
  • Were tool calls similar?
  • Is response quality consistent?
  • Are there outliers?

Exporting Execution Data​

Copying Details​

  • Copy execution ID for reference
  • Copy specific sections (prompt, response)
  • Screenshot for documentation

Using for Training​

Executions can inform improvements:

  • Good examples → Template for instructions
  • Bad examples → What to avoid
  • Edge cases → Add specific handling

Performance Optimization​

Identifying Slow Steps​

Look at timing in timeline:

  • Which tool calls took longest?
  • Was LLM response slow?
  • Any unnecessary waits?

Reducing Token Usage​

Check prompt and response:

  • Can instructions be shorter?
  • Is thread history too long?
  • Are responses verbose?

Improving Success Rate​

For failed executions:

  • Identify common failure modes
  • Add error handling to instructions
  • Consider fallback behaviors

Best Practices​

Regular Review​

  • Review sample executions weekly
  • Focus on failures and outliers
  • Track patterns over time

Documentation​

  • Save good examples as templates
  • Document common issues
  • Share findings with team

Continuous Improvement​

  • Use insights to improve instructions
  • Adjust tool assignments based on usage
  • Optimize based on cost analysis