Skip to main content

​
What Is an AI Player?

PlayerZero’s AI Players acts as your knowledge-rich agents, designed to help you understand, investigate, and solve problems across your codebase and systems. Whether you’re debugging a tricky issue, exploring architecture, or researching historical changes, the AI Player provides fast, context-aware insights. Each AI Player conversation runs as a thread inside a channel — a shared workspace built around a single objective. A channel can hold several threads working in parallel, so an investigation that starts as one question can grow into a coordinated effort without losing context. To use it, navigate to any project in PlayerZero and start a conversation through the free‑form prompt interface.

​
Channels and Threads

A PlayerZero channel is a shared workspace built around a single objective, such as debugging a single support ticket or scoping a change to a specific product feature. Inside a channel, work happens in threads — each thread is its own AI Player conversation with a focus on a single topic, such as understanding steps to reproduce or debating the pros and cons of a technical approach, but threads within a channel all share context with each other to ensure collaborative work happens without context getting lost along the way.
  • Channel — the shared workspace and objective that threads collaborate within. Context, branches, and referenced files are shared across the channel.
  • Thread — an individual agent conversation. A thread can run in Agent Mode or Hive Mode and keeps its own history, context, and sandbox.
  • Coordinator — keeps threads aligned with the channel’s objective, relays context between them, and tracks overall progress.
The side panel lists every thread in the channel, grouped by workflow, so you can see all the work in progress at a glance. Teammate threads created in Hive Mode appear here as first-class entries alongside the threads you start yourself.

​
Working Across Threads

Threads in a channel are not isolated. When you start a new thread, it inherits context from the channel so it can pick up where other threads left off.
  • Inherited context — A new thread carries the channel’s objective and plan, a record of the threads that came before it, and the files those threads referenced.
  • Inherited branches — Starting a new thread from an existing one (using ⌘K or New Thread) carries over the repositories and branches the source thread was working on.
  • Thread-to-thread messaging — Threads can send context and findings to one another, and the coordinator relays updates so work flows across the channel.
A handoff from one thread to another keeps the history it depends on, whether the work moves from investigation to fix or from one team to another.

​
Add Your Attachments to a Thread

You can attach files directly in the prompt window — images, screenshots, PDFs, spreadsheets, source code, and more. Each file uploads to the thread immediately and becomes part of the channel’s shared sandbox, so the agent can read and work from it. PlayerZero supports a broad range of types, including plain text and markdown, data and configuration files, source code, PDF, Microsoft Office, and OpenDocument formats. You can attach up to 10 files per message, and a large block of pasted text converts into a file automatically. Bring your own design specs, logs, spreadsheets, and code into a thread instead of pasting fragments into the conversation. The agent works from the actual documents your team already maintains, and references them as file citations in its responses.

​
Starting Points

  • Access Point: Available on the homepage and within any project view.
  • Use Case: Ideal for open-ended questions, quick lookups, or initiating deep investigations.
  • Behavior: AI builds context from your selected project and branch, then continues to expand the conversation as you refine your queries.
  • Access Point: From any session replay or Debug Report timeline.
  • Use Case: Perfect when you need to investigate user-reported issues with full session, DOM, and trace context.
  • Behavior: Clicking “Find in My Code” or “Debug” launches a chat that’s pre-loaded with session data, related logs, and linked code paths for faster root-cause analysis.
  • Access Point: From any error log, stack trace, or telemetry panel.
  • Use Case: For digging into specific errors or performance alerts without starting a fresh session view.
  • Behavior: AI automatically correlates the log or stack trace with relevant files, recent commits, and known historical issues, so you can jump straight to a potential fix.
  • Access Point: Directly from Pull Request pages in PlayerZero.
  • Use Case: Quickly understand what a PR changes, potential risks, and how it may impact customers.
  • Behavior: AI generates a natural-language summary, identifies impacted areas, and lets you ask follow-up questions about specific functions, modules, or risks.

​
Modes of Operation

  • Purpose: A single focused agent tackles your task directly.
  • Best For: Quick code lookups, straightforward questions, lightweight investigations, and simple edits.
  • Behavior: The AI works the problem itself using code search, file reading, PR history, and other tools. Fast and direct.
  • Purpose: Multiple specialist agents coordinate to solve complex problems.
  • Best For: Debugging, root cause analysis, deep research, multi-system investigations, and test coverage generation.
  • Behavior: The AI designs and deploys a team of specialists — code explorers, tracers, cross-checkers, and integration agents — that work in parallel and cross-check each other’s findings. You can watch their progress in real time via the Hive panel in the side panel.
  • Learn more: Hive Mode

​
Context & Navigation Features

  • Point the agent at specific repositories and branches at any time during your chat.
  • Switch between Git branches at any time during your chat.
  • New Players default to your organization’s configured release branch for each repository. The release branch appears first in the branch picker.
  • The AI keeps your investigation context, analyzing how code and logic differ between versions.
  • Build deeper understanding by layering questions.
  • The AI remembers your conversation history and evolves responses as you refine your investigation.
  • Split into parallel threads to explore multiple topics (e.g., one thread for performance bottlenecks, another for API behaviors).
  • Keeps your original investigation intact while exploring side questions.
  • A persistent workspace tracks:
    • Files you’ve viewed
    • Code patterns analyzed
    • Problems under investigation
  • The AI uses this workspace to maintain continuity across your session.
  • The agent links to the specific files and lines it read or changed, across your repositories and the thread’s sandbox.
  • Click a citation to open the referenced file, so you can verify findings against the actual source.
  • Related steps the agent takes — searches, file reads, edits, and tool calls — are grouped together in the conversation.
  • This keeps long investigations readable, so you can follow what the agent did without scrolling through every individual action.

​
Model Training Dataset

  • Full repository structures and files
  • Branch-specific code and diffs
  • Semantic embeddings of functions, classes, and modules
  • Cross-file dependency mapping
  • Historical changes and commit context
  • Pull from support tickets, bug reports, feature requests, and customer issues
  • Surface historical context for recurring or related problems
  • Correlate reported behavior with relevant code or changes
Leverage session and performance data, including:
  • User session traces
  • Error logs and stack traces
  • Network requests and console logs
  • Performance metrics and usage trends

​
Actionable Outputs

Generate visualizations like:
  • Mermaid diagrams
  • Network and flow charts
  • System architecture diagrams
  • Process workflows for debugging or onboarding
Automatically create:
  • Technical documentation
  • Investigation summaries
  • Troubleshooting guides
  • Structured code analysis reports
Write and deliver:
  • Example code snippets and test implementations
  • Fix and refactor suggestions
  • Executable stubs based on your actual code patterns
Generate structured content to support issue tracking:
  • Bug write‑ups and root cause summaries
  • Feature requirement outlines
  • Problem descriptions for direct ticket creation

​
Get Started

  • Hive Mode — Deploy teams of specialist agents for complex investigations
  • Playbooks — Create and reuse prompt templates across your team
  • Code Simulations — Test scenarios through AI-powered code simulation
  • Usage Analytics — Track questions, simulations, and team activity
  • Knowledge Bases — Upload organizational documents for AI agent reference
  • Monitors — Set up automated checks that run on a schedule and trigger workflows on failure
👉 Setup guide