← Back to overview
IDE Integration

An agent that lives inside PyCharm, not beside it

IDEAgent does not guess at your project from a terminal. It calls the same engine PyCharm uses to understand your code: the symbol index, the inspections, the refactorings and the test runner. Everything it does runs on a machine and network you control.

Where it runs
As a PyCharm plugin, on your workstation and on your own infrastructure
Product telemetry
None. We do not collect usage data from the plugin or the server stack.
Models
Your choice: fully local with Ollama, or your own OpenAI, Anthropic or Google keys

The IDE tools the agent uses

These eight tools connect the agent to PyCharm itself. Each one uses the IDE's own analysis, so results match what you see in the editor, not a separate approximation.

Tool What it does Why it matters
find_symbol Finds where a class, function, method or variable is defined, using the IDE's symbol index. The agent navigates by real definitions, not by text search that can match unrelated names.
find_references Lists the usages of a symbol across the project, resolved by the IDE's index. Skips comments, strings and same-named but unrelated symbols before the agent changes anything.
get_file_problems Runs the IDE's code analysis on a file and returns its errors and warnings, plus the quick fixes available for them. The same inspections you see in the editor check the agent's edits after it makes them.
apply_quick_fix Applies an IDE quick fix to a reported problem, such as adding a missing import. Uses the IDE's fix instead of a hand-written guess. The change stays unsaved in the editor until you save it.
rename_symbol Renames a symbol and updates every usage through the IDE's rename refactoring. If the rename would cause conflicts, nothing changes and the conflicts are listed for review.
safe_delete Deletes an unused symbol. The IDE checks for usages first and refuses if the symbol is still in use. Dead code is removed only when the IDE confirms nothing depends on it. The delete is recorded in Local History.
run_tests Runs tests inside the IDE with the project's interpreter and test runner, and reports results per test. Failures come back with messages the agent can act on. Tests can run on unsaved edits.
vcs_changes Lists the project's uncommitted changes as the IDE sees them: added, modified, deleted, moved and unversioned files, and unsaved editor buffers. The agent reviews what it has touched before anyone commits, including changes not yet saved to disk.
Note on run_tests. Before a run starts, the IDE saves all open unsaved documents. This includes your own unsaved edits, not only the agent's. Save or stash work you do not want included.

Cross-project coordination runs through three separate tools, acp_list_agents, acp_request and acp_report. They are described in Agent Coordination (ACP).

How it differs from CLI agents and JetBrains Air

Several tools now bring coding agents into developer workflows. They make different trade-offs, and the right choice depends on what your team needs. Here is where IDEAgent stands.

Question CLI coding agents JetBrains Air IDEAgent
Where the agent works In a terminal, next to your editor A layer inside PyCharm 2026.3 and other JetBrains IDEs, for running and reviewing agents Inside PyCharm, as a plugin with its own tool window
How it finds code Mostly file reads and text search Uses PyCharm's code intelligence, exposed to agents through the PyCharm MCP server Uses the IDE's symbol index, inspections and refactorings directly
Where code indexing happens Depends on the tool and its account Air Context, a cloud service, computes embeddings of your code on its server and stores them in a vector database. Storage location depends on your account and repository size. Retrieval and the vector index run on your infrastructure, through the RAG server
Model choice Usually the vendor's model Multi-vendor: ACP-compatible agents such as Claude Agent, Codex, Gemini, GitHub Copilot and Junie Local with Ollama, or your own provider keys
Product telemetry Depends on the tool Governed by JetBrains' data handling terms for AI features None. No product-usage telemetry is collected
Cross-project work One session per repository Multi-agent workflows inside the IDE Agents in separate projects coordinate through ACP, with human approval

JetBrains Air and IDEAgent both put agents inside PyCharm, and both give developers a way to review what an agent changes. The main difference is where your code is processed. Air Context builds its index in a JetBrains cloud service. IDEAgent is designed so that the index, the retrieval and the context assembly stay on infrastructure you operate.

The comparison reflects published JetBrains documentation at the time of writing, and it may change as both products evolve. Check current terms before you decide.

Data sovereignty by design

Sovereignty means you decide where your code goes, who can see it, and what is recorded. IDEAgent is built around that principle, and it is explicit about the few connections it makes.

  • Runs on your infrastructure
    The gateway, the MCP server, the RAG server and the vector database run in containers you host. The plugin talks to them over your network.
  • You choose the model
    With Ollama, prompts and code never leave your machine. With a cloud provider, only the context you allow goes to that provider, through your own key.
  • No product telemetry
    We do not collect usage data. The network capture on the Security & Network Transparency page shows which connections the package makes, and why.
  • Optional secret redaction
    Before tool and terminal output reaches a cloud model, detected secrets can be replaced with placeholders. See Egress Secret Redaction.

The connections IDEAgent does make

To be precise, these are the outbound connections the package can make. Each is documented on the security page:

  • Your chosen LLM provider, only when you configure a cloud model.
  • A one-time model metadata check for the local embedding model. No prompts or code are sent. It can be turned off with HF_HUB_OFFLINE=1 and TRANSFORMERS_OFFLINE=1.
  • Web search fallback in the RAG server, used when local retrieval confidence is low. This can be disabled if your policy requires it.

For a fully air-gapped setup, use Ollama and disable the metadata check and the web search fallback. Your security team can then verify the traffic itself.

You stay in control of every change

The agent proposes; you decide. Destructive operations require explicit confirmation, and every change is visible in the IDE before it is committed. Human-in-the-loop (HITL) checkpoints sit in the editor, so you can watch the agent work and step in at any point.

  • Monitor the work live. The agent's edits, test runs and inspection results appear in the IDE as they happen, next to the code you are reading.
  • Compare the diff. Review each change side by side in the IDE's diff viewer, then accept or reject it before it is staged or committed.
  • Local History records the agent's edits, so you can compare and restore earlier states even without a VCS commit.
  • Refactorings and deletes go through the IDE's own safety checks, which refuse unsafe actions and list conflicts.
  • Unsaved changes stay in the editor until you save them.