Agent Workbench Plugin

Vision: AI-First Workflow UX

The Agent Workbench plugin reimagines the IDE experience around AI-assisted development. Rather than treating AI as an add-on feature, the plugin creates a seamless workflow where developers can:

Start conversations naturally - Begin coding discussions from any context in the IDE
Maintain persistent threads - Keep conversation history organized and accessible across sessions
Navigate AI interactions - Browse, search, and resume previous conversations efficiently
Integrate with development flow - Connect AI assistance directly to code navigation, editing, and debugging

The goal is to make AI assistance feel like a native part of the development environment, reducing context switching and keeping developers in flow.

Global Prompt Palette

Use Cmd+\ (macOS) or Ctrl+\ (Windows/Linux) to open a centered prompt palette from anywhere in the IDE.

The palette:

Defaults to Codex (provider-extensible).
Captures invocation context (selection/caret snippet, file, symbol, project).
Falls back to last selected editor context when invoked outside editors.
Uses invocation-derived context chips; add extra details directly in prompt text.
Sends the composed first prompt into a newly opened chat session.

Architecture

The plugin provides two complementary views for working with AI-assisted development:

┌─────────────────────────────────────────────────────────────────────────────┐
│                              IntelliJ IDEA                                  │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│   ┌─────────────────────────────────┐   ┌─────────────────────────────────┐ │
│   │      PROJECT FRAME              │   │    AI-CHAT DEDICATED VIEW       │ │
│   │  (traditional development)      │   │   (task orchestration)          │ │
│   │                                 │   │                                 │ │
│   │  ┌────────┐ ┌────────────────┐  │   │  ┌────────┐ ┌────────────────┐  │ │
│   │  │ Agent  │ │                │  │   │  │ Agent  │ │                │  │ │
│   │  │Sessions│ │     Editor     │  │◄─►│  │Sessions│ │   Chat Panel   │  │ │
│   │  │  Tool  │ │                │  │   │  │  Tool  │ │                │  │ │
│   │  │ Window │ │                │  │   │  │ Window │ │  • Status      │  │ │
│   │  │        │ │  • Navigate    │  │   │  │        │ │  • Input       │  │ │
│   │  │Projects│ │  • Edit        │  │   │  │Projects│ │  • History     │  │ │
│   │  │  └─Th. │ │  • Debug       │  │   │  │  └─Th. │ │                │  │ │
│   │  │    └─… │ │  • Review VCS  │  │   │  │    └─… │ │                │  │ │
│   │  └────────┘ └────────────────┘  │   │  └────────┘ └────────────────┘  │ │
│   └─────────────────────────────────┘   └─────────────────────────────────┘ │
│                                                                             │
│   Why dual views?                                                           │
│   • Work on multiple tasks in parallel — see status of each                 │
│   • AI isn't "there" yet — you still review, read, understand code          │
│   • Not vibe-coding — we use AI in production, need to know how/why         │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

The Agent Threads Tool Window organizes conversations by project:

Projects
├── project-a
│   ├── Thread: "Add caching layer"     [done]
│   └── Thread: "Fix auth bug"          [needs input]
│       └── sub-agent: "research"
└── project-b (not open)                [Connect]
    └── Thread: "Refactor API"          [inactive]

Specifications

Detailed requirements and testing contracts are documented in spec/.

Core Contracts - Canonical cross-feature contracts: identity, command mapping, shared editor-tab actions, and shared visibility primitives.
Agent Threads Tool Window - Provider aggregation, load/refresh lifecycle, deduplication, and project/worktree tree behavior.
Agent Threads Visibility and More Row - Deterministic visibility rendering and More-row precedence rules.
Agent Chat Editor - Chat tab lifecycle, persistence/restore, lazy terminal initialization, titles/icons.
Agent Chat Dedicated Frame - Dedicated-frame mode routing, lifecycle, shortcut semantics, and filtering.
Codex Sessions Rollout Source - Rollout-default Codex discovery, watcher semantics, backend selector, and app-server write interoperability.
Agent Sessions New-Session Actions - New-thread UX, provider/YOLO selection, creation dedup, pending-thread rebinding.
Global Prompt Entry - Global shortcut entrypoint, centered popup UX, context capture, and launch bridge flow.
Global Prompt Suggestions - Context-derived seed prompts, prompt-panel suggestion UI, async refresh semantics, and Codex polishing.
Testing Contract - Coverage ownership matrix and required contract test suites.

Test All

Run all Agent Workbench tests with:

bash

./tests.cmd '-Dintellij.build.test.patterns=com.intellij.agent.workbench.*'

Troubleshooting Codex + ijproxy Launch

When diagnosing a Codex thread started from Cmd+\ or Ctrl+\ that falls back to shell tools instead of ijproxy, collect a fresh idea.log from IDE startup through one repro and enable these categories in Help | Diagnostic Tools | Debug Log Settings:

#com.intellij.agent.workbench.sessions.launch.config.backend.AgentWorkbenchProjectLaunchConfigLogCategory for .agent-workbench.yaml discovery, parsed config summaries, shim preparation, and provider launch augmentation.
#com.intellij.agent.workbench.sessions.service.AgentSessionLaunchService for sanitized new-thread launch handoff summaries.
#com.intellij.agent.workbench.codex.common.CodexAppServerClient for Codex app-server startup summaries and forwarded stderr.
#com.intellij.mcpserver.impl.McpServerService:trace for IDE MCP server and session startup.
#com.intellij.mcpserver.impl.McpSessionHandler:trace for MCP tool list updates and actual tool calls.
Optional: #com.intellij.mcpserver.impl.util.network.RoutingContext:trace for stdio and session transport issues.
Optional: #com.intellij.mcpserver.ToolCallListener:trace for extra per-tool activity.
Optional: #com.intellij.mcpserver.impl.ReflectionToolsProvider for MCP tool discovery and loading issues.

Interpret the logs like this:

If the launch-config category never reports a resolved config for codex, agent-workbench did not apply .agent-workbench.yaml augmentation.
If the launch-config logs look correct but CodexAppServerClient shows startup or stderr failures, the problem is before MCP tool calls.
If McpSessionHandler shows session traffic and tool calls, ijproxy was available and shell-only behavior is model-side rather than missing transport.