skills.rest
ruvnet
ruvnetCOMMUNITY
Explore all skills by this author →
Website𝕏@ruvGitHub

observe-trace

Builds distributed trace trees from agent execution spans to identify bottlenecks.

70.1k|8.4k|Updated Jun 2, 2025
Search Tags:#bottleneck detection#distributed tracing#agent execution#critical path#span analysis#Observability#Claude-Flow
One-click install
npx skills add https://github.com/ruvnet/claude-flow --skill observe-trace
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: observe-trace
Source: https://github.com/ruvnet/claude-flow/tree/main/plugins/ruflo-observability/skills/observe-trace
Command: npx skills add https://github.com/ruvnet/claude-flow --skill observe-trace

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

When multi-agent tasks run, it is hard to see which agents executed, how long each step took, and where delays occurred. This Skill collects trace spans for a task and reconstructs the execution flow so you can diagnose slow or failing agent runs.

Core Features & Use Cases

  • Span Collection: Retrieves all trace spans for a given task ID from the observability memory namespace.
  • Trace Tree Construction: Organizes spans into a parent-child hierarchy and computes per-span durations and the critical path.
  • Bottleneck Detection: Flags spans exceeding p95 duration for their operation type and identifies idle gaps between spans.
  • Use Case: After a swarm task finishes slowly, run this Skill with the task ID to see which agent consumed the most time and where coordination stalled.

Quick Start

Ask the agent to trace the execution of task TASK-123 and show the trace tree with bottlenecks.

Frequently Asked Questions about observe-trace

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I trace agent execution for a task?▼

Provide the task ID and the Skill retrieves all spans from the observability memory namespace, builds a parent-child trace tree, and reports durations, status, and bottlenecks per span.

How do I find bottlenecks in multi-agent task execution?▼

The Skill computes each span's duration, identifies the critical path as the longest sequential chain, and flags spans exceeding the p95 duration for their operation type or gaps suggesting idle time.

Why should I use memory_search instead of agentdb_hierarchical tools for traces?▼

The memory_* tool family routes queries by namespace, which is required to reach the observability namespace. The agentdb_hierarchical-* tools route by tier (working, episodic, semantic) and will not return trace spans.

Can I query trace spans from the command line instead?▼

Yes, run npx @claude-flow/cli@latest memory search with your task query and the observability namespace to retrieve the same span data without invoking the Skill.

What information does the trace report include?▼

The report shows each span's name, agent, duration, and status (OK or ERROR), plus bottleneck flags, total trace duration, and critical path duration, along with a synthesized narrative of the execution flow.

Related Skills

Explore More Software Engineering Skills→
microsoftmicrosoft
190.1k

otel

Instrument OpenTelemetry spans, metrics, and events for the Copilot Chat extension.

Official
Advanced
AesopScottAesopScott

redaction-precompiler

Precompile redaction matchers to reduce latency in privacy-sensitive systems.

Community
Advanced
tsuga-devtsuga-dev
2

tsuga-analyze-trace-latency

Compute p95 latency per span.name to identify slow trace operations.

Official
Intermediate
blackpwnguinblackpwnguin
1

Observability

Stream live PAI multi-agent activity and debugging traces via WebSocket.

Community
Advanced