An IntelliJ IDEA plugin that gives you a standalone YOLO panel — a dedicated tool window (right side, y icon) that lists your AI CLI tools and launches any of them in a real, interactive terminal inside the IDE, with a single click. What makes it different: everything the agent prints becomes clickable — file paths, stack traces, type names, and URLs all turn into navigation links — so you can jump from the agent's output straight to the code.
It is built entirely on public IntelliJ APIs, so it passes JetBrains Marketplace verification and can be published like any normal plugin. It does not hook into or depend on IDEA's built-in Terminal.
A tool window (right side, y icon) that replicates the Terminal's AI Agents experience without touching any internal Terminal API:
- Lists your installed agents — promoted agents (Claude Code, Codex, CodeBuddy, ZCode, …) plus your own custom tools.
Agents that aren't detected on
PATHsimply aren't shown, so the list stays relevant to this machine. - Each row shows the agent's icon, name, and its configured skip flag.
- The dropdown loads instantly from a cached install scan — the detection done on a previous run is reused, and a background re-scan refreshes the list only when the set of installed agents actually changes.
- A YOLO (Skip Permissions) toggle sits in the panel header, left of the settings gear.
A YOLO (Skip Permissions) toggle in the panel header. Turn it on and the next launch starts the agent with its
permission-bypass flag appended — --dangerously-skip-permissions for Claude Code, --yolo for Codex, -y for
CodeBuddy, and so on.
The flag is per agent and fully configurable. The plugin knows the correct flag for 16 common agents and pre-fills it, but every value is editable and nothing is hardcoded at runtime. A few agents (Goose) bypass via an environment variable instead of a flag; those are handled too.
The toggle is off by default and never turns itself on.
Selecting an agent in the dropdown launches it immediately — there is no separate button. The agent opens in a
real, interactive terminal embedded directly inside the YOLO panel: a genuine PTY (via JediTerm + PTY4J, the same
terminal emulator the IDE itself bundles) that renders the agent's TUI in place. Prompts, editors, and your rc-defined
PATH (nvm / fnm / npm global bin, …) all work because the agent runs through an interactive login shell.
- The caret lands in the terminal automatically when an agent launches, so you can type right away.
- Ctrl+C is no longer hijacked by IDEA's Copy shortcut. With the terminal focused, Ctrl+C passes through to the embedded terminal instead of popping IDEA's "Shortcuts conflicts" dialog. Whether it interrupts the running agent depends on the agent's own TUI.
This is built entirely on public APIs: JediTerm and PTY4J are third-party libraries shipped with the IntelliJ Platform (not
@ApiStatus.Internal/@ExperimentalTerminal APIs), so the plugin stays publishable on the JetBrains Marketplace. The IDE's ownConsoleViewis output-only (no interactive input), so a real agent can only live in the panel by embedding a true terminal — which is exactly what this does.
While the agent runs, its output is scanned for references and turned into hyperlinks. Clicking a link jumps you to the right place and auto-hides the YOLO panel so it no longer covers the editor.
| You print… | Becomes a link to… |
|---|---|
src/foo/Bar.kt:42, /abs/Bar.kt:42:13, C:\foo\Bar.kt:7 |
the file at that line / column |
./Makefile:10, ~/x/y.kt:3, file:///abs/x.kt |
the file (home-relative and file:// URIs supported) |
path:12-18 |
the file at the start of the line range |
"/path with space/Bar.kt":5 |
a quoted path containing spaces |
Bar.java:123, Bar.kt:12 |
a bare stack-trace frame |
File "app/main.py", line 42 |
a Python / JS traceback frame |
plugin.xml, build.gradle.kts, README.md |
a bare file name anywhere in the project |
com.foo.Bar / Bar |
the class declaration (qualified or project-local simple name) |
Bar.method / Bar#method |
the specific method / field / inner class |
https://example.com |
the URL, opened in your system browser (panel is not hidden) |
- Line/column navigation works for paths, stack frames, and member references.
- No-extension files (
Makefile,Dockerfile) and Windows paths are handled. - URLs are the exception: clicking one opens your browser but keeps the panel open.
Letting an AI agent run commands and edit files without confirmation can make irreversible changes, execute untrusted code, or expose your system. Those risks come from the agent and the bypass flag itself. This plugin only flips that flag for you — it adds no such behavior of its own, performs no actions on your behalf, and is not responsible for what the agent does. Enable YOLO mode only in environments you trust.
| IDE | IntelliJ IDEA 2023.3 (build 233) or later |
| Dependencies | None beyond the IntelliJ Platform itself — the built-in Terminal is not required |
Build with the standard Gradle task:
./gradlew buildPlugin
# → build/distributions/yolo-{version}.zipBuilding against a locally installed IDEA — by default the plugin compiles against the IntelliJ
SDK pinned in gradle.properties. To build against the IDE on your machine instead, create a
local.properties file at the project root pointing at its installation:
localIdeaPath=/Applications/IntelliJ IDEA.appFrom the Marketplace — search for YOLO in Settings | Plugins and install.
or from website: https://plugins.jetbrains.com/plugin/33442-yolo-ai-agents-extender/
From disk — build or download the yolo-<version>.zip (see Build), then
Settings | Plugins | ⚙ | Install Plugin from Disk… and pick the zip. Restart when prompted.
The exp branch is an alternative, experimental build of this plugin with a different architecture.
Rather than the standalone YOLO panel (this main line), it extends IDEA's built-in Terminal
"AI Agents" dropdown directly — appending your own CLI tools to that menu and adding a "Skip
permissions" (YOLO) toggle to the Terminal toolbar.
It is "experimental" because it hooks internal Terminal extension points
(terminalAgentProvider, shellExecOptionsCustomizer, toolWindowInitializer from
org.jetbrains.plugins.terminal), which are still @ApiStatus.Internal and have no public alternative.
Main (main) |
Experimental (exp) |
|
|---|---|---|
| Integration | Standalone YOLO panel + embedded terminal | IDEA Terminal's AI Agents dropdown |
| Clickable agent output | Yes — file / stack-trace / type / URL links | No (the link filters are not included) |
| APIs used | Public IntelliJ APIs only | Internal Terminal APIs |
| Marketplace | Published | Not published (fails verification) |
| Min. IDE version | 2023.3 (233) |
2026.1 (261) |
| IDE family | All IntelliJ-platform IDEs | IntelliJ IDEA |
Because it depends on internal APIs, the experimental edition is rejected by JetBrains Marketplace verification, so it is distributed from the repository's Releases page instead:
- Check out the
expbranch and build it:git checkout exp ./gradlew buildPlugin # → build/distributions/yolo-<version>.zip - Download the zip from the repo's Releases page, or use the one you just built.
- Install via
Settings | Plugins | ⚙ | Install Plugin from Disk…and restart.
Requires IntelliJ IDEA 2026.1 or later (
since-build 261) with the bundled Terminal plugin
This branch is a divergence for experimentation; the published, supported line remains main.
Settings | Tools | YOLO: AI Agents Extender — or click the gear in the YOLO panel header.
Everything lives in one table. Each row is an agent, and each row carries its own skip flag:
| Column | Meaning |
|---|---|
| Icon | The bundled icon for promoted agents; your file or a default bolt for custom tools. Greyed out in this table when the command isn't on PATH |
| ID | Unique identifier |
| Display name | The name shown in the YOLO panel |
| Command | Executable name — must resolve on PATH |
| Base args | Arguments always passed, space separated |
| Skip flag | The permission-bypass argument, appended when the YOLO toggle is on |
Rows come in two kinds, listed in descending priority:
- Promoted agents (Claude Code, Codex, CodeBuddy, …) — read-only, sorted with Claude Code and Codex pinned at the top, cannot be removed.
- Your own custom tools — fully editable, in the order you created them.
Only the Skip flag is editable on promoted agents. That's deliberate: the plugin should extend the panel, not take it over.
- Skip flags pre-fill themselves. Open the settings and known agents already have the right flag. Type a known ID or command into a new row and it fills in as you go. Values you set by hand are never overwritten.
- Duplicates are caught while you type. A repeated ID or command turns the status line red
immediately, and Apply refuses to save. Commands are compared by executable name, so
/usr/bin/claudeandclaude.cmdcount as the same tool. - Installed agents are detected on each startup. In the background the plugin checks every known agent's command — first on
PATH, then by actually running it once (--version) — and adds the promoted agents it finds installed. This runs on every startup, not just the first, so a tool you install later (e.g. Gemini installed via npm) shows up automatically. It does not auto-discover arbitrary tools you wrote yourself — add those as custom tools. The result is cached so the panel opens instantly afterwards. - Validate checks a row's command the same way (PATH first, then running it once) and downloads its icon URL if it has one.
Flags below are pre-filled. All of them are editable, and this list is a convenience — not the source of truth. What runs is whatever the settings say.
| Agent | Command | Skip flag |
|---|---|---|
| Claude Code | claude |
--dangerously-skip-permissions |
| Codex | codex |
--yolo |
| CodeBuddy | codebuddy |
-y |
| Gemini | gemini |
--yolo |
| Copilot | copilot |
--allow-all |
| Cursor | cursor-agent |
--force |
| Kimi | kimi |
--yolo |
| Qoder | qoder |
--dangerously-skip-permissions |
| Hermes | hermes |
--yolo |
| OpenCode | opencode |
--auto |
| Continue | cn |
--auto |
| Cline | cline |
--auto-approve true |
| Goose | goose |
env GOOSE_MODE=auto — not a flag |
| Kilo Code | kilo |
none — only kilo run accepts one |
| OpenClaw | openclaw |
none — persistent config only |
| Pi | pi |
--approve |
| ZCode | zcode |
none — no launch-time bypass flag |
Anything not listed here works fine as a custom tool; just fill in its flag yourself.
The plugin logs every launch it touches. To see what actually ran, grep the IDE log
(<version> is the IDE's build, e.g. 2026.2):
# macOS
grep "AI Agents Extender" ~/Library/Logs/JetBrains/IntelliJIdea<version>/idea.log
# Linux
grep "AI Agents Extender" ~/.cache/JetBrains/IntelliJIdea<version>/log/idea.log
# Windows (PowerShell)
grep "AI Agents Extender" "$env:LOCALAPPDATA\JetBrains\IntelliJIdea<version>\log\idea.log"An agent is missing from the panel. Its command isn't resolving on PATH. The panel only lists
agents detected as installed; run a settings Validate on the row, or check that the command resolves in the
shell that launched the IDE (the IDE may inherit a different PATH than your interactive shell).
The flag isn't being applied. Confirm the YOLO toggle is on and the row has a Skip flag. The log line for each launch shows the final command, including whether anything was injected.
A printed path / type name isn't clickable. Links only appear when the reference resolves to a real file or class in the current project (so random words aren't linked). Make sure the file is inside a content root and, for type names, that the Java module is enabled.
Settings changes don't take effect. The plugin registers a Configurable, which IDEA cannot
load dynamically. Restart the IDE after installing or updating.