What Kind of Agents Does AgentsView Support? A Complete Guide to the 70+ AI Assistants

AgentsView supports approximately 70 AI coding assistants, ranging from file-based tools like Claude, Cursor, and Copilot to non-file-backed services like ChatGPT and Claude AI, all defined in a static registry in internal/parser/types.go.

AgentsView is a local web viewer for session histories from diverse AI coding assistants. Understanding what kind of agents AgentsView supports requires examining the static registry that catalogs every compatible tool, their storage mechanisms, and identification patterns.

The Agent Registry: Core Configuration in internal/parser/types.go

All supported agents are declared in a static registry located at internal/parser/types.go. The Registry slice contains roughly 70 AgentDef entries, each defining how AgentsView interacts with a specific assistant.

Each AgentDef struct specifies:

• Type: Unique identifier constant (e.g., AgentClaude, AgentCursor)
• DisplayName: Human-readable label (e.g., "Claude Code")
• Storage configuration: Environment variables (EnvVar, DefaultRootEnvVar), config keys, and default directory paths
• IDPrefix: Session identifier prefix (e.g., "codex:" or empty string for Claude)
• FileBased: Boolean indicating whether sessions are stored as local files or remote databases

Here is the registry structure for Claude and OpenClaude:

var Registry = []AgentDef{
	{
		Type:              AgentClaude,
		DisplayName:       "Claude Code",
		EnvVar:            "CLAUDE_PROJECTS_DIR",
		DefaultRootEnvVar: "CLAUDE_CONFIG_DIR",
		ConfigKey:         "claude_project_dirs",
		DefaultDirs:       []string{".claude/projects"},
		IDPrefix:          "",
		FileBased:         true,
	},
	{
		Type:              AgentOpenClaude,
		DisplayName:       "OpenClaude",
		EnvVar:            "OPENCLAUDE_PROJECTS_DIR",
		DefaultRootEnvVar: "OPENCLAUDE_CONFIG_DIR",
		ConfigKey:         "openclaude_project_dirs",
		DefaultDirs:       []string{".openclaude/projects"},
		IDPrefix:          "openclaude:",
		FileBased:         true,
	},
	// ... additional agents follow
}

File-Based vs. Non-File-Backed Agents

AgentsView classifies agents along two dimensions: storage mechanism and identification method.

File-Based Coding Assistants

These agents store session histories as files on disk, typically JSONL or plain-text formats in home-directory subfolders. File-based agents include Claude, OpenClaude, Cowork, Codex, GitHub Copilot, Gemini, Cursor, Kilo, OpenHands, and Aider.

The viewer watches these directories for changes using filesystem events or polling, depending on the agent's configuration.

Non-File-Backed Agents

Some agents store sessions in databases or remote services rather than local files. Non-file-backed agents include Claude AI, ChatGPT, Forge, Piebald, Warp, and Positron.

The NonFileBackedAgents() helper function in internal/parser/types.go returns this subset, which the sync engine handles differently—typically connecting via PostgreSQL or SQLite backends rather than filesystem watchers.

Supported Agent Categories

The registry organizes agents into functional groups based on their integration patterns.

IDE-Integrated Agents

These tools embed directly into development environments, storing sessions within IDE-specific configuration folders. Examples include VS Code Copilot, Visual Studio Copilot, Zed, Antigravity, Antigravity CLI, Shelley, and WorkBuddy.

These agents often require specialized path resolution for platform-specific directories like AppData/Roaming/Code/User on Windows or ~/Library/Application Support on macOS.

Specialized Development Tools

This category includes agents with unique interaction patterns or shallow-watch requirements to minimize filesystem churn. Supported tools include Aider, Reasonix, iFlow, DeepSeek TUI, Qwen Paw, and gptme.

Some use mixed storage strategies or require top-level directory watching only, configured via the AgentDef watch-behavior flags.

How AgentsView Resolves Agents at Runtime

When processing a session ID, AgentsView executes a three-step resolution process implemented in AgentByPrefix (lines 39-60 of internal/parser/types.go):

1. Strip host prefixes: Removes any host~id prefix from the session identifier
2. Match ID prefixes: Compares the remaining ID against each AgentDef.IDPrefix (e.g., matching "codex:" for Codex sessions)
3. Fallback to default: If no prefix matches, defaults to Claude (which uses an empty IDPrefix)

This logic allows AgentsView to route sessions to the correct parser and storage backend automatically.

Listing All Supported Agents Programmatically

You can enumerate all supported agents using the public registry API:

package main

import (
	"fmt"
	"github.com/kenn-io/agentsview/internal/parser"
)

func main() {
	fmt.Println("All agents supported by AgentsView:")
	for _, def := range parser.Registry {
		fmt.Printf("- %s (%s)  file-based=%t\n", def.DisplayName, def.Type, def.FileBased)
	}
	
	fmt.Println("\nNon-file-backed agents:")
	for _, t := range parser.NonFileBackedAgents() {
		if def, ok := parser.AgentByType(t); ok {
			fmt.Printf("- %s (%s)\n", def.DisplayName, def.Type)
		}
	}
}

This script leverages parser.Registry, parser.NonFileBackedAgents(), and parser.AgentByType() to generate a complete inventory of supported assistants.

Summary

• AgentsView supports approximately 70 AI coding assistants defined in internal/parser/types.go
• File-based agents (Claude, Cursor, Copilot, etc.) store sessions as local JSONL files and use filesystem watchers
• Non-file-backed agents (ChatGPT, Claude AI, Forge, etc.) use database storage and require PostgreSQL or SQLite backends
• The AgentByPrefix function resolves session IDs by matching prefixes, falling back to Claude for unprefixed IDs
• The NonFileBackedAgents() helper identifies which agents need database synchronization rather than file watching

Frequently Asked Questions

How does AgentsView identify which agent created a session?

AgentsView examines the session ID prefix using the AgentByPrefix function in internal/parser/types.go. It strips any host prefix, then checks for matching IDPrefix values in the registry. If no prefix matches, it defaults to Claude Code. This allows the viewer to handle mixed session logs from multiple assistants simultaneously.

Can I add support for a new agent to AgentsView?

Yes, but it requires modifying the static Registry slice in internal/parser/types.go. You must define a new AgentDef with the appropriate Type, DisplayName, environment variables, default directories, and IDPrefix. For file-based agents, set FileBased: true; for database-backed agents, set FileBased: false and ensure the sync engine in internal/sync/engine.go handles the storage backend.

Why are some agents marked as non-file-backed?

Non-file-backed agents like ChatGPT, Claude AI, and Forge store conversation history in remote databases or cloud services rather than local files. AgentsView uses the NonFileBackedAgents() helper to route these sessions to PostgreSQL or SQLite backends instead of filesystem watchers, enabling synchronization with external data stores.

What is the difference between Claude and OpenClaude in the registry?

Claude uses an empty IDPrefix ("") and serves as the default fallback agent, while OpenClaude uses the prefix "openclaude:" for explicit identification. Both are file-based agents but store sessions in different default directories (.claude/projects vs .openclaude/projects) and respond to different environment variables (CLAUDE_PROJECTS_DIR vs OPENCLAUDE_PROJECTS_DIR).

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}