Results for “traces”

Investigates distributed application performance using PostHog APM (OpenTelemetry span) data via MCP. Use when the user asks about service traces, slow HTTP/database spans, error spans, trace IDs, or span attributes — not AI observability traces or product logs. Uses posthog:query-apm-spans, posthog:apm-trace-get, posthog:apm-services-list, posthog:apm-attributes-list, and posthog:apm-attribute-values-list.

The English summary is being prepared. Showing the original description.

ABSOLUTE MUST to debug and inspect LLM/AI agent traces using PostHog's MCP tools. Use when the user pastes a trace or session URL (e.g. /ai-observability/traces/<id> or /ai-observability/sessions/<id>), asks to debug a trace, figure out what went wrong, check if an agent used a tool correctly, verify context/files were surfaced, inspect subagent behavior, investigate LLM decisions, or analyze token usage and costs. Also use when raw SQL/HogQL against `events.properties.$ai_input` / `$ai_output_choices` returns empty — message content lives only on the dedicated `posthog.ai_events` table.

The English summary is being prepared. Showing the original description.

Compile your local stellar-build usage traces into sharper skills. Use when the user says "optimize my skills", "optimize-skills", "improve my skills from usage", "learn from my traces", "stellar-loop optimize", or wants the learning loop to refine installed skills based on how they've actually been used. DSPy-style prompt optimization over the local trace store at ~/.stellar-build/traces — fully local, reversible.

The English summary is being prepared. Showing the original description.

Append structured execution traces across operational, cognitive, and contextual surfaces with minimal overhead. Load when inspecting agent runs, logging tool calls and observations, enabling post-run debugging, or pairing with structured-planning step IDs. Also triggers on "trace this run", "log execution", "agent observability", "run log", or when fault-localize needs evidence. Default-on during multi-step plans. Traces live at .agent-loom/traces/ — git-ignored by default.

The English summary is being prepared. Showing the original description.

Investigate software errors by tracing code, reviewing recent changes, and reproducing symptoms. Test a specific cause before making a minimal fix, then verify the result with regression tests and a structured debug report.

• Investigating errors and stack traces
• Tracing bugs introduced by recent changes
• Verifying fixes and documenting regression tests

Review Caveman Cloud spending, latency, errors, and potential improvements using current reports and traces, or individual execution records. Produce findings tied to time windows and trace IDs, while keeping measured costs, estimated opportunities, and verified savings separate.

• Understanding which workflows drive LLM spending
• Investigating slow responses and errors
• Reviewing measured costs and verified savings separately

Investigate memory dumps, disk records, and captured network traffic while preserving evidence. The skill guides timeline reconstruction and examination of system traces to identify suspicious activity and produce findings that others can review.

• Preserve evidence before starting an incident investigation
• Inspect processes and connections in memory dumps
• Build timelines from event logs and execution traces

Set up distributed tracing with Jaeger and Tempo to follow requests across services. Examine delays, service dependencies, and error propagation, with guidance on sampling, linking logs to traces, and troubleshooting missing trace data.

• Investigating slow requests across services
• Understanding service dependencies
• Tracing how errors spread

Prepare an evaluation framework before fine-tuning a language model. Build labeled examples, checks for each failure type, and a base-model benchmark, while calibrating model-based judges against human labels to support comparisons after training.

• Build an evaluation set from agent traces
• Create separate checks for each failure type
• Calibrate an LLM judge against human labels

Investigate LLM application failures with Phoenix CLI by reviewing execution records, recording observations, and grouping mistakes into counted categories. Inspect datasets and experiments to identify which failure types deserve evaluation tests first.

• Investigating failures in LLM applications
• Grouping observed mistakes into failure categories
• Choosing which evaluation tests to build first

Improve LLM prompts using Arize production traces, evaluation results, and human feedback. Extract current instructions, identify recurring failures, revise the prompt, and compare experiments to measure changes in output quality and catch regressions.

• Improve a prompt using failed production traces
• Fix responses that use the wrong output format
• Review unsupported answers in retrieval-based responses

Create shareable links that open specific Arize resources, including traces, datasets, and evaluators. Use IDs from logs or exported data, with suitable time ranges, to direct teammates to the relevant view.

• Share a trace with teammates
• Open an Arize view from IDs in logs
• Link directly to a dataset or evaluator

Add Arize AX tracing to an LLM application, recording how model calls and tool executions connect. Inspect the existing code, select suitable integrations, add instrumentation, and verify that the application runs and traces reach Arize.

• Setting up tracing for an LLM application
• Recording tool inputs and outputs in an agent
• Adding Arize export to an existing OpenTelemetry setup

Diagnose problems in OMC or Claude Code sessions using logs, execution traces, saved state, and focused reproduction. Receive a clear account of the failure, a supported cause hypothesis, and the smallest next corrective action.

• Diagnosing a broken Claude Code workflow
• Investigating unexpected hook or agent behavior
• Narrowing down causes of failing tests or commands

Analyze LLM serving traces to identify GPU time usage, opportunities to run operations concurrently, and known patterns for combining operations. Produce three consistent tables from saved traces or live captures on supported servers.

• Identify GPU operations that dominate inference time
• Compare input processing and token generation
• Trace GPU operations back to Python code

Measure denoising latency in SGLang diffusion models and identify slow operations with profiler traces. Compare performance and output quality on the same GPUs, check existing optimizations, and gather evidence before starting low-level kernel work.

• Measuring diffusion denoising latency
• Ranking slow operations from profiler traces
• Checking whether existing optimizations address a bottleneck

Parse Windows Prefetch files, which store traces of program execution, to extract run counts, timestamps, and referenced files. Build execution timelines and compare findings with other forensic evidence when investigating suspicious software or tool usage.

• Checking whether a suspicious program ran
• Building a timeline of investigative tool findings
• Investigating compression and file transfer tool usage

Analyze Windows Registry files to uncover user activity, installed software, USB connections, and automatic startup entries. Organize these traces into investigation summaries and timelines to help examine suspicious activity and possible malware persistence.

• Investigating suspicious automatic startup entries
• Reconstructing user activity around an incident
• Checking USB device connection traces

Analyze Windows Amcache records to investigate applications, deleted executable traces, and drivers. Extract file details, compare SHA-1 hashes with malware databases, and combine records into a timeline to support incident investigations.

• Investigating traces of deleted executables
• Checking software installed during an incident
• Comparing file hashes with malware databases

Map attacker behaviors and indicators of compromise, or traces of an intrusion, to MITRE ATT&CK techniques. Build coverage heatmaps, compare threat groups, and identify monitoring gaps to guide detection improvements and threat intelligence reporting.

• Mapping attacker behaviors and intrusion traces to ATT&CK techniques
• Visualizing detection coverage with ATT&CK Navigator
• Identifying attack techniques missing from monitoring

Examine Windows shortcuts and Jump Lists, records of recently used files, to reconstruct user activity. Extract paths, timestamps, and device details with LECmd and JLECmd, including traces that remain after target files are deleted.

• Reconstructing file access and program execution timelines
• Investigating access to files that have been deleted
• Examining traces of removable media use

Investigate production issues by searching Datadog logs, querying metrics, and following request traces across services. Compare error counts across time periods, inspect surrounding logs, and manage dashboards through a command-line tool.

• Investigating errors in production
• Comparing error counts across time periods
• Following request traces across services

Design service monitoring dashboards and improve existing alert configurations. Generate Grafana dashboard files and documentation, analyze noisy or duplicate alerts and coverage gaps, and outline how metrics, logs, and request traces fit together.

• Designing monitoring for a new service
• Reducing noisy and duplicate alerts
• Creating Grafana dashboards for different roles

Automate a real browser from the terminal to navigate pages, fill forms, extract data, and investigate interface problems. Use page snapshots to identify controls, and capture screenshots or traces, records of browser activity, for review.

• Automate form filling and submission
• Extract information from web pages
• Investigate UI flows with screenshots and traces