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

> Discover the 70+ AI assistants AgentsView supports, including Claude, Cursor, Copilot, ChatGPT, and more. Get the complete list and learn about file-backed and non-file-backed tools.

- Repository: [Kenn Software/agentsview](https://github.com/kenn-io/agentsview)
- Tags: how-to-guide
- Published: 2026-07-01

---

**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`](https://github.com/kenn-io/agentsview/blob/main/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`](https://github.com/kenn-io/agentsview/blob/main/internal/parser/types.go)

All supported agents are declared in a static **registry** located at [`internal/parser/types.go`](https://github.com/kenn-io/agentsview/blob/main/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:

```go
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`](https://github.com/kenn-io/agentsview/blob/main/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`](https://github.com/kenn-io/agentsview/blob/main/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:

```go
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`](https://github.com/kenn-io/agentsview/blob/main/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`](https://github.com/kenn-io/agentsview/blob/main/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`](https://github.com/kenn-io/agentsview/blob/main/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`](https://github.com/kenn-io/agentsview/blob/main/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`).