Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    Freebies — Agent Log Parser

    1

    Parse agent logs to detect circular reasoning loops, tool latency bottlenecks, and token consumption metrics.

    Free

    Security scanned
    Freebies — Agent Log Parser

    Freebies — Agent Log Parser

    Example session with this skill installed

    Analyze the agent logs in ./logs/execution-trace.jsonl. I need to know why the file_search tool is taking so long and if there are any repeating loops.

    • Read your context and instructions
    • Compiled the freebies

    I have parsed the execution trace from ./logs/execution-trace.jsonl. The analysis identified a specific bottleneck in the file_search tool and one circular reasoning loop during the indexing phase.

    Agent Execution Analysis Report

    MetricValueStatus
    Total Tool Calls42Nominal
    Total Token Usage18,450Within Budget
    Circular Loops Detected1Critical
    Avg. Tool Latency1.8sNominal
    Max Tool Latency12.4s (file_search)Warning

    Latency Distribution

    • read_file: 150ms (avg)
    • list_dir: 210ms (avg)
    • file_search: 12.4s (max) - Bottleneck detected during deep recursive globbing.

    Circular Reasoning Detection

    Found 1 loop at Step 14-18. The agent attempted to call edit_file on config.json four times with identical original_text blocks, receiving a "no changes detected" error each time without updating its reasoning strategy.

    Token Utilization

    • Input Tokens: 12,200
    • Output Tokens: 6,250
    • Step 12 (Reasoning): Highest single-step consumption (2,400 tokens).

    Next steps

    1. Review the file_search implementation to limit depth or exclude node_modules.
    2. Update the system prompt to handle "no changes detected" errors to break the edit_file loop.
    3. Check config.json permissions to ensure the agent has write access.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Debugging autonomous agents is difficult when execution traces are thousands of lines long. This skill parses agent logs to pinpoint exactly where tool calls fail, why reasoning loops occur, and how much each step costs in tokens.

    What it does

    • Log Parsing reads and structures JSONL and OpenTelemetry traces from agent runs.
    • Loop Detection identifies circular reasoning where agents repeat failing tool calls with identical arguments.
    • Performance Analytics calculates tool latency distributions and execution time per step.
    • Cost Tracking measures token utilization across the entire execution sequence.
    • Optimization Reporting generates summaries of failed calls and dead-end iterations.

    How it works

    1. Ingest Logs by pointing the skill to your local execution trace files or JSONL logs.
    2. Analyze Traces to extract tool call sequences, timestamps, and reasoning patterns.
    3. Scan for Faults including circular logic, high-latency bottlenecks, and token spikes.
    4. Generate Report containing a structured breakdown of agent performance and failure points.

    Frameworks & tools

    Built for the AAIF agentskills.io Open Standard. Compatible with Claude Code, Agent SDK v0.3+, Gemini CLI, Cursor, Windsurf, and OpenClaw. Works with JSONL and OpenTelemetry formatted logs.

    Why this beats prompting it yourself

    Generic prompts often miss subtle circular reasoning loops or fail to calculate precise latency distributions across large log files. This skill uses a deterministic workflow designed specifically for the Domain 06 MCP agents swarm scope to ensure no execution bottleneck is overlooked.

    Use cases

    • Debugging agent "hallucination loops" where the model gets stuck in a tool-call retry cycle.
    • Identifying slow MCP server tools that are bottlenecking multi-agent swarm performance.
    • Auditing token consumption to find expensive reasoning steps that need prompt optimization.
    • Post-mortem analysis of failed autonomous task runs to prevent future regressions.

    Known limitations

    Confined to the local project workspace. Does not support real-time streaming log analysis or remote cloud logging providers directly.

    Restricted to local workspace files. No support for remote log streaming or direct cloud provider integration. Requires logs in JSONL or OpenTelemetry format.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 1 day ago

    • Free with an Agensi account

    Requires

    File System Read/Write (strictly scoped to current project workspace `./`).
    Zero global installation or elevated privileges required.
    Linux only

    Permissions

    Read Files

    Target Use Cases: - Analyze this AI agent execution log for circular loops. - Parse agent tool call traces and identify token waste. - Diagnose why an autonomous agent got stuck in a loop.

    Listed1 day ago

    What's inside

    Frequently Asked Questions

    This skill automates the tedious process of reviewing thousands of lines of execution traces to find circular reasoning loops, high-latency tool calls, and hidden token costs that are often missed during manual review.

    It is built for the AAIF agentskills.io Open Standard and works seamlessly with tools like Claude Code, Agent SDK v0.3+, Gemini CLI, Cursor, Windsurf, and OpenClaw, provided they export logs in JSONL or OpenTelemetry formats.

    The skill is designed to run within your local project workspace; simply point it to your existing trace files or JSONL logs to initiate the analysis and generate a performance report.

    Yes, by measuring token utilization across every step of the execution sequence, it pinpoints exactly which reasoning steps or tool calls are driving up your API costs.

    Currently, this tool is designed for post-run post-mortems and local analysis; it does not support real-time streaming or direct integration with remote cloud logging providers.

    You receive the full skill package compliant with the Domain 06 MCP agents swarm scope, including all necessary logic to detect faults and generate optimization reports within your supported environment.

    New in Agents & Orchestration