AI coding agents can explore a codebase, modify files, run tests, delegate tasks, and retry failed operations, all within a single session. But when the task finishes, understanding how the agent got there isn't always easy.
A working pull request doesn't tell you how many unnecessary tool calls it took, whether the agent inspected the right files, or why it kept repeating a failed command. The answers might be buried in hundreds of lines of session history.
AgentPlay makes coding-agent sessions easier to inspect by turning them into a visual map and a replayable timeline. It's an open-source tool from Entelligence that supports Claude Code, Codex, Cursor, GitHub Copilot, OpenCode, and Kiro. It runs locally and doesn't require an account or API key.
AgentPlay turns coding-agent session history into an interactive map and timeline.
GitHub: github.com/Entelligence-AI/agentplay
What can you inspect?
AgentPlay processes session data from supported coding tools and gives you two ways to explore it:
- Session map: See the files, directories, tools, subagents, and errors associated with a session.
- Timeline replay: Move through events in sequence and inspect edits, commands, and failures.
- Error analysis: Find recurring failures and repeated commands worth investigating.
- Session filters: Narrow the view by task, model, or subagent.
Together, these views help answer a simple question: what happened between giving an agent a task and receiving its final result?
Three ways to use AgentPlay
Debug failed sessions
When an agent gets stuck fixing a bug, don't immediately restart the conversation. Inspect the session first.
- Find repeated test failures in the Errors view.
- Jump to the corresponding timeline events.
- Check which files the agent inspected and changed.
- Compare retries to see whether anything meaningful changed.
- Use the findings to provide better instructions or take over debugging.
AgentPlay surfaces useful signals across a coding-agent session, from repeated failures and slow tool calls to context compaction, model switches, pull requests, and error patterns.
Repeated failures become easier to investigate when you can jump directly to the relevant events.
Understand subagent activity
When agents delegate work, their final responses can hide a lot of activity. Where the source agent exposes subagent details, AgentPlay lets you inspect individual lanes and their contribution to the larger session.
Use it to investigate:
- What a subagent worked on.
- Whether it encountered errors.
- How its work fits into the main workflow.
- Whether delegation actually helped.
The level of detail depends on the coding agent and the session data it exposes.
Improve agent workflows
A successful task can still involve unnecessary exploration, repeated tool calls, or inefficient retries.
Use AgentPlay to:
- Identify repeated effort that doesn't contribute to progress.
- Compare similar sessions across models or workflows.
- Examine retries, elapsed time, and usage metrics where available.
- Check whether changes to your instructions improve the results.
Keep the task, repository state, and acceptance criteria consistent when comparing runs. Fewer tool calls don't automatically mean a better result, and a longer session isn't necessarily inefficient.
Getting started
AgentPlay requires Python 3.11 or newer. The quickest way to run it is:
uvx agentplay It discovers supported coding-agent sessions on your machine, builds session maps, and opens a local viewer.
A couple of useful commands:
# See detected agents agentplay agents # Process sessions from the last 7 days agentplay --since 7d # Restrict processing to specific agents agentplay --agents claude-code,codex Start with a recent session where you already know the task and outcome. It's easier to recognize missed exploration and repeated failures when you have context.
Best practices and privacy
A few things to keep in mind when using AgentPlay:
- Start with a question. Investigate a particular failure or workflow instead of replaying everything without a goal.
- Review the final diff too. Session history complements code review and testing; it doesn't replace them.
- Change one thing at a time. Improve instructions or verification, then inspect a comparable session.
- Don't overinterpret missing data. Different agents expose different events and usage metrics.
- Check before sharing. Maps can contain repository names, remotes, relative paths, and error details.
AgentPlay processes session data locally by default. Its map format excludes prompt text, assistant responses, file contents, tool inputs and outputs, and command arguments. However, local processing doesn't make every exported artifact safe to publish.
You can disable the optional email signup interaction with:
AGENTPLAY_NO_NETWORK=1 uvx agentplay This disables that interaction, not all possible network activity. Review shared artifacts and use path-redaction options where appropriate.
Explore AgentPlay
Coding agents are becoming capable of handling increasingly complex tasks. Understanding their output matters, but understanding how they produced it matters too.
AgentPlay gives developers a practical way to inspect session history, investigate failures, and improve their workflows without relying on a hosted session-analysis service.
It doesn't replace engineering judgment. It gives you better visibility into the work your agents perform.
Explore the project: github.com/Entelligence-AI/agentplay
