---
title: "How to see what all your AI coding agents are doing at once · Cork"
description: "See every AI coding agent's status in one place: Claude Code agent view, Cursor's Agents Window, git worktree checks, OpenTelemetry, and a team-wide view."
canonical: "https://corkcli.com/blog/see-what-all-ai-coding-agents-are-doing"
last_updated: "2026-11-14"
published: "2026-10-03"
author: "Kevin Vera"
---

# How to see what all your AI coding agents are doing at once

See every AI coding agent's status in one place: Claude Code agent view, Cursor's Agents Window, git worktree checks, OpenTelemetry, and a team-wide view.

By Kevin Vera · October 3, 2026 · [Guides](https://corkcli.com/blog/c/guides) · 6 min read

To see what all your AI coding agents are doing at once, use each tool's own overview first (Claude Code's `claude agents` screen, Cursor's Agents Window), add a git-level check that shows every branch and worktree in the repo, and stream telemetry if you need numbers across a team. Each of those answers "which agents are running and are they stuck." None of them answers "which agents are about to touch the same code," which is the question that matters once agents share a repository, so the last section covers that layer.

## Start with each tool's own dashboard

### Claude Code: agent view

Claude Code's agent view lets you "dispatch and manage multiple Claude Code sessions running in the background from a single screen." Open it with:

```bash
claude agents
```

Each session is a row with a status (working, needs input, idle, completed, failed, stopped), a name, a one-line summary of its current activity, its age, and optionally the status of a linked pull request. Sessions are grouped so the ones that need you come first: Pinned, Ready for review, Needs input, Working, Completed.

You can start background sessions from your shell and they appear there:

```bash
claude --bg --name "flaky-test-fix" "investigate SettingsChangeDetector"
```

Useful keys: `Space` peeks at a session without attaching, `Enter` attaches, `Ctrl+S` switches grouping between state and directory. The docs list two limits worth knowing: background sessions run on your machine and stop if it shuts down, and running ten agents uses roughly ten times the quota of one.

Inside a single session, `/list-agents` (also `/peers`) lists the subagents, agent team teammates, and other Claude Code sessions that Claude can message.

### Agent teams

If you use Claude Code's experimental agent teams, the lead's terminal lists teammates in a panel below the prompt. Arrow keys select a teammate, `Enter` opens its transcript, and `Ctrl+T` toggles the shared task list, which shows each task as pending, in progress, or completed.

### Cursor and Codex

Cursor's Agents Window is its agent-first interface for running agents "across repos and environments, including local, cloud, remote SSH, and more," and it is where Cursor's parallel agents and worktrees live. The Codex app supports parallel chats and worktrees as well. Each of these shows its own agents; none shows the others.

## Add a git-level view that covers every tool

Whatever started an agent, its work ends up in git. Three commands give a tool-neutral picture from the repo itself:

```bash
# Every checkout of this repo and the branch it is on
git worktree list

# Uncommitted changes in one worktree, without leaving your terminal
git -C .claude/worktrees/feature-auth status --short

# Recent commits across all local branches
git log --all --oneline --since="2 hours ago"
```

`git worktree list` is especially useful when agents create worktrees for you: Claude Code puts them under `.claude/worktrees/<name>/` on branches named `worktree-<name>`, and background sessions dispatched from agent view move into worktrees there automatically before editing.

A quick loop that prints the dirty files per worktree:

```bash
git worktree list --porcelain | awk '/^worktree /{print $2}' | while read -r wt; do
  echo "== $wt"; git -C "$wt" status --short
done
```

If two worktrees list the same file, two agents are editing it.

## Stream telemetry when you need a team view

For a team, the per-machine screens above do not add up to one picture. Claude Code can export OpenTelemetry metrics and events to your own backend:

```bash
export CLAUDE_CODE_ENABLE_TELEMETRY=1
export OTEL_METRICS_EXPORTER=otlp
export OTEL_LOGS_EXPORTER=otlp
export OTEL_EXPORTER_OTLP_PROTOCOL=grpc
export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4317
```

Metrics include `claude_code.session.count`, `claude_code.token.usage`, `claude_code.cost.usage`, and `claude_code.lines_of_code.count`, tagged with attributes such as `session.id` and `user.email`. Setting `OTEL_METRICS_INCLUDE_REPOSITORY=true` (Claude Code v2.1.269 or later) adds the repository name and owner from the `origin` remote. That gives you a near real time chart of who is running agents, on which repo, and how much they cost. It does not tell you what code each agent is in.

## What these views miss

Every view above is organized by agent or session. The question that prevents wasted work is organized by code:

- Is anyone else changing `billing/invoice.ts` right now?
- Did someone just rename a function my agent is about to call?
- Which agent, on which teammate's machine, owns the refactor I am about to collide with?

Agent view can tell you an agent is "Adding swept-AABB checks to CollisionSystem." It cannot tell a second agent, about to edit `CollisionSystem`, that the first one is in there. Telemetry tells you lines changed, not which symbols. And each tool's dashboard stops at its own agents and your own machine.

| View | Shows | Misses |
|---|---|---|
| `claude agents` | Status and activity of your Claude Code sessions | Other tools, other people, overlap in code |
| Cursor Agents Window | Your Cursor agents | Claude Code and Codex agents, overlap |
| `git worktree list` + `status` | Dirty files per checkout | Intent, uncommitted work on other machines |
| OpenTelemetry | Sessions, tokens, cost, lines per user and repo | Which code each agent is touching |

## How Cork helps

Cork adds the view organized by code, across tools and machines. Cork is the [coordination layer](https://corkcli.com/blog/coordination-layer-ai-coding-agents) for multiplayer coding agents: it keeps Claude Code, Codex and Cursor agents, on one machine or across a team's machines, from overwriting each other on one codebase, and hands each agent what the others already learned.

For this problem specifically:

- **Live awareness:** when another agent changes code yours depends on (a rename, a new signature), your agent hears it on its next step, whichever tool either agent runs in.
- **[Write gate](https://corkcli.com/blog/write-gate):** an edit against code another agent is changing right now is held until your agent has their version.
- **Team dashboard and live code graph** (cloud plans): one place to see the repo and the work happening in it.
- **`recap`:** an MCP tool that reports what happened and what it cost.

Hooks in Claude Code, Codex and Cursor run this with no extra model calls. Cork Free covers unlimited agents and repos on one machine with no account; the paid plan ($20 a month per 100 agent hours, pooled across the workspace) adds teammates' machines so agents across the team see each other. Install it once for every repo on the machine:

```bash
curl -fsSL https://corkcli.com/install.sh | sh
```

## Frequently asked questions

### How do I see all my Claude Code sessions?

Run `claude agents` to open agent view, which lists every background session with its status, current activity, and age. Inside a session, `/list-agents` shows the sessions Claude can message.

### Can I monitor Claude Code, Cursor, and Codex agents in one dashboard?

Not with the tools' own views, which each show only their own agents. Git commands work across all of them for committed and on-disk changes; a coordination layer such as Cork covers live work across tools.

### How do I know if two agents are editing the same file?

Check `git status` in each worktree (the loop above does it in one go). If the same path appears in two lists, two agents are on it. A write gate stops the second edit before it happens instead.

### How do managers see AI agent activity across a team?

Export Claude Code's OpenTelemetry metrics to your observability stack, tagged by user and repository, or use your plan's analytics. Those show usage and cost; they do not show which code each agent is in.

## Sources

- <https://code.claude.com/docs/en/agent-view>
- <https://code.claude.com/docs/en/agent-teams>
- <https://code.claude.com/docs/en/cross-session-messaging>
- <https://code.claude.com/docs/en/worktrees>
- <https://code.claude.com/docs/en/monitoring-usage>
- <https://cursor.com/docs/agent/agents-window>
- <https://learn.chatgpt.com/docs/windows/windows-sandbox>
- <https://git-scm.com/docs/git-worktree>

## Related reading

- [Pre-commit checks for code written by AI agents](https://corkcli.com/blog/pre-commit-checks-ai-generated-code): Pre-commit checks for AI-written code: git hooks, the pre-commit framework, secret scanning, and agent hooks in Claude Code, Codex and Cursor.
- [Setting up Claude Code multi-agent work on Windows (Git Bash and PowerShell)](https://corkcli.com/blog/claude-code-multi-agent-windows-setup): Run several Claude Code agents on Windows: install, Git Bash vs PowerShell, worktrees, hooks in either shell, agent teams, messaging and WSL, per the docs.
- [Git worktrees for parallel AI coding agents: setup and limits](https://corkcli.com/blog/git-worktrees-parallel-ai-coding-agents): Set up git worktrees for parallel AI coding agents like Claude Code and Codex: exact commands, environment setup, cleanup, and what worktrees do not solve.
- [Setting up Cork for a team of five](https://corkcli.com/blog/cork-team-of-five-setup): Set up Cork for a five-person team running Claude Code, Codex and Cursor agents: install, login, agent hours, AGENTS.md, working habits, and what it costs.

[All articles](https://corkcli.com/blog.md) · [Cork in Markdown](https://corkcli.com/index.md) · [llms.txt](https://corkcli.com/llms.txt)

This page in HTML: https://corkcli.com/blog/see-what-all-ai-coding-agents-are-doing