How JetBrains AI Assistant Handles Proprietary Code Privacy and External LLM Data Retention

For Engineering Directors, Chief Information Security Officers (CISOs), and legal compliance leads, integrating AI-assisted developer tooling introduces a major dilemma: developer productivity gains versus the risk of intellectual property leakage and unauthorized model training. A primary concern when adopting JetBrains AI Assistant is whether proprietary code sent to cloud-based Large Language Models (LLMs) might be retained, inspected, or incorporated into training datasets by third-party providers.

This guide provides a comprehensive breakdown of the privacy architecture, data flow, contractual protections, Zero Data Retention (ZDR) policies, and administrative governance mechanisms implemented by JetBrains and its external LLM partners.

Executive Summary: Key Security Facts

• No Training on Customer Code: Neither JetBrains nor its external LLM providers use proprietary code, prompts, or completions to train public or foundational AI models under standard commercial terms.
• Zero Data Retention for Cloud Inference: External LLM providers operate under strict business-to-business agreements prohibiting data retention beyond immediate request processing and transient abuse monitoring.
• Encrypted Transmission: All communication between the IDE, the JetBrains AI proxy infrastructure, and downstream LLM providers is encrypted via TLS 1.2 or higher.
• Internal Vector Processing for RAG: Project vectorization, semantic indexing, and reranking are handled by open-weight models running directly on JetBrains-managed infrastructure, ensuring embedding requests never leave the perimeter to external vendors.
• Strict Enterprise Opt-In Barriers: "Detailed code-related data collection" is disabled by default for commercial and organizational licenses, and individual developers cannot override organization-level policies.
• Granular Code Exclusion Controls: Engineering teams can enforce file- and directory-level exclusions using .aiignore or disable AI capabilities entirely using .noai files.
• Deployment Flexibility: Organizations with air-gapped or strict data residency mandates can deploy on-premises models, connect custom API keys via Bring Your Own Key (BYOK), or rely on fully offline Full Line Code Completion.

1. Request Lifecycle & Multi-Tier Processing Architecture

Understanding how proprietary code is safeguarded begins with the end-to-end request lifecycle:

[ Developer IDE ]
       |
       +---> [ Local Analysis & Filtering (.aiignore / .noai) ]
       |
       +---> [ Full Line Completion (Local / On-Device ML - Zero Network) ]
       |
       v (TLS 1.2+ Encrypted Request)
[ JetBrains AI Platform Proxy (EU / EEA) ]
       |
       +---> [ Semantic Search / RAG: JetBrains-Hosted Embedding & Reranker Models ]
       |       (No embeddings sent to OpenAI, Google, or other external vendors)
       |
       v (TLS 1.2+ Ephemeral API Call)
[ External LLM Subcontractors ]
  (OpenAI, Anthropic, Google Cloud Vertex, AWS Bedrock, xAI)
       |
       +---> [ Ephemeral Inference Execution ]
       |
       v (Output Streamed Back; Zero Model Training; No Data Retention)
[ IDE Result Rendered ]

Context Construction in the IDE

JetBrains AI Assistant does not dump entire repositories into LLM prompts. Instead, it utilizes the IDE's semantic understanding (AST parsing, symbol indexing, dependency graphs) to assemble a targeted context window. This includes:

• The active file and visible code fragment surrounding the cursor.
• Relevant file types, runtime frameworks, and language specifications.
• Explicit user prompts and selected code blocks.
• Filtered semantic context retrieved from project indexes.

JetBrains AI Service as a Secure Proxy

Developer workstations never communicate directly with commercial LLM endpoints using public end-user interfaces. All communication traverses the JetBrains AI Service proxy, hosted within secure data centers in the European Economic Area (EEA). This architectural tier performs essential security functions:

1. Metadata Sanitization: Strips unauthorized identifying telemetry and unneeded local environment signatures before forwarding payloads.
2. Quota & Rate Governance: Prevents denial-of-service abuse and controls model routing.
3. Provider Isolation: Ensures requests are directed strictly through enterprise-grade API agreements rather than standard consumer endpoints.

2. Third-Party LLM Providers and the Zero Data Retention Boundary

Standard consumer interfaces for models like ChatGPT or Google Gemini often permit vendors to use prompts and interactions for model improvement unless explicitly opted out. Enterprise developer tools require a fundamentally different legal and architectural boundary.

Subcontractor Model Roster

As designated in official legal terms, JetBrains AI services utilize selected third-party language model providers as AI subcontractors:

• OpenAI: GPT-family models.
• Anthropic: Claude-family models (connected directly or through AWS Bedrock).
• Google: Gemini-family models.
• Amazon Web Services (AWS): Amazon Bedrock models.
• SpaceXAI: Grok-family models.

In addition to external providers, JetBrains platform-hosted models (such as Mellum, Mellum2, and open-weight models including Qwen-based components) run directly on JetBrains-managed infrastructure, ensuring their inputs and outputs are never exposed to external model creators.

Contractual Zero Training & Ephemeral Retention

JetBrains maintains Data Processing Addenda (DPAs) and commercial B2B contracts with each external provider. These agreements mandate that:

1. No Training on Inputs or Outputs: Vendor models are prohibited from using transmitted code, prompts, or generated suggestions for model training, tuning, or fine-tuning.
2. Zero Commercial Data Retention (ZDR): Prompts and responses exist solely in volatile memory during the round-trip inference cycle. Once generation concludes and the response is streamed back to the JetBrains proxy, the payload is released.
3. No Secondary Sharing: External providers cannot sublicense, monetize, or expose code snippets to third-party evaluators or public indexes.

Isolation of RAG and Vector Embeddings

Semantic search and Retrieval-Augmented Generation (RAG) are critical for project-wide code understanding. JetBrains executes its code vectorization and embedding pipelines internally:

• Models such as Qwen3-Embedding-4B and Qwen3-Reranker-0.6B run directly on JetBrains infrastructure.
• Vector generation requests never leave the internal perimeter to external vendors like OpenAI or Google.
• Your codebase is never indexed on third-party vector databases.

3. Data Collection Governance: Telemetry vs. Detailed Code-Related Data

JetBrains distinguishes between operational telemetry and code-level data collection:

The "Detailed Code-Related Data" Safeguard

JetBrains offers an optional program where developers can donate interaction logs to train JetBrains-owned in-house models (such as Mellum). For engineering leaders, two structural guardrails prevent unintentional exposure:

1. Disabled by Default: Commercial, enterprise, and educational licenses have detailed data collection turned off out of the box.
2. Company-Level Override: Individual team members cannot opt in from their local IDE settings if the organizational account administrator has not granted company-level permission.
3. Never Shared Externally: Even when explicitly enabled, this collected dataset is stored exclusively within the European Economic Area (EEA), accessible only to vetted personnel, and never transferred to third-party model providers.

4. Multi-Layer Enterprise Governance & Access Controls

Engineering leadership can enforce privacy boundaries across four complementary control layers:

[ Layer 1: Organization Admin Console ] ---> Master toggle: Enable/Disable AI across all seats
                                        ---> Hard block on detailed data collection
                                                      |
[ Layer 2: Repository Root (.noai) ]     ---> Complete AI Assistant shutoff for entire project
                                                      |
[ Layer 3: File / Folder (.aiignore) ]   ---> Targeted exclusion of credentials, keys, IP modules
                                                      |
[ Layer 4: Local Inspection Log ]       ---> Developer audit via ai-assistant-requests.md

Layer 1: Centralized Organization Administration

Within the JetBrains Account management portal, enterprise administrators can manage AI deployment across all assigned subscriptions:

• Global AI Toggle: Enable or disable AI Assistant access across the entire organization with a single click.
• Central Policy Lock: Permanently lock the "Detailed data collection" setting to disabled, preventing local developers from modifying their configuration.

Layer 2: Project-Level Disabling via .noai

To block all AI Assistant interactions across a specific project or sensitive repository, create an empty .noai file in the root directory:

touch .noai

When present, JetBrains AI Assistant completely disengages for that project, disabling chat, contextual completion, and agent operations regardless of individual user license status.

Layer 3: Granular Path Exclusion via .aiignore

When teams want to leverage AI Assistant generally while shielding confidential submodules, proprietary algorithms, or configuration files, they can place an .aiignore file in the project root.

The syntax mirrors .gitignore rules:

# Exclude proprietary algorithmic modules
src/core/crypto/
src/proprietary/trade_engine/

# Exclude secrets and credential configurations
config/secrets/
**/*.env
**/*.pem
**/*.key

# Exclude intellectual property or patent documentation
docs/patents/
internal_compliance/

JetBrains AI Assistant also respects established third-party ignore files present in the root directory, including .cursorignore, .codeiumignore, and .aiexclude.

Layer 4: Transparency & Audit Logging

Developers and security auditors can verify the exact payloads sent to external LLMs during any working session:

1. Press Shift twice in any JetBrains IDE to open the Search Everywhere dialog.
2. Search for and execute Open AI Assistant Requests Log in Editor.
3. The IDE opens ai-assistant-requests.md, showing the raw prompts, file fragments, and system parameters dispatched during that session.

5. Deployment Options for Regulated and Restricted Environments

For organizations operating under stringent regulatory frameworks (such as defense, banking, or healthcare) where cloud LLM interaction is prohibited, JetBrains provides alternative architectures:

Full Line Code Completion (Offline Local ML)

• How it Works: Generates single-line code predictions using compact, in-house neural networks running entirely on the developer's local CPU or GPU.
• Privacy Profile: Requires zero network connectivity. No data is transmitted over the internet, making it compliant with fully air-gapped environments.
• Availability: Bundled natively across modern JetBrains IDEs without requiring an active JetBrains AI cloud subscription.

Bring Your Own Key (BYOK)

• How it Works: Organizations supply their own direct API keys from providers like OpenAI, Anthropic, or Azure OpenAI.
• Privacy Profile: API keys are stored encrypted on the local machine and are never shared with JetBrains. Communication routes under your organization's direct commercial agreement and negotiated DPA with the model provider.

JetBrains AI Enterprise (On-Premises & Private Cloud)

• How it Works: Part of JetBrains IDE Services, providing a self-hosted control plane that connects developer IDEs to internal, private LLMs.
• Privacy Profile: Supports self-hosted open-weight models (via Ollama, vLLM, or LM Studio) or private cloud endpoints (such as AWS Bedrock or Azure OpenAI VPC endpoints). Complete control over audit logs, model routing, and network boundaries.

6. Architecture Comparison Matrix

Conclusion & Recommended Next Steps

JetBrains AI Assistant addresses proprietary code concerns through a defense-in-depth architecture: TLS 1.2+ encrypted transport, isolation via an EEA-hosted secure proxy, strict contractual Zero Data Retention and zero-training guarantees with LLM subcontractors, internal open-weight vector processing, and local file exclusions via .aiignore.

Recommended Rollout Checklist for Engineering Leaders:

1. Verify Account-Level Defaults: Ensure "Detailed code-related data collection" remains disabled across all team seats in the JetBrains Account portal.
2. Standardize Project Ignore Files: Add .aiignore or .noai files to repositories containing sensitive algorithms, patent-pending logic, or compliance-restricted assets.
3. Audit Live Session Requests: Conduct an initial verification by inspecting ai-assistant-requests.md during a pilot evaluation to confirm prompt payload boundaries.
4. Evaluate Deployment Tier: Use standard commercial subscriptions for general enterprise development; select BYOK or JetBrains AI Enterprise with on-premises models for restricted or air-gapped environments.

References

• JetBrains AI Service Providers
• AI Assistant in JetBrains IDEs | IntelliJ IDEA Documentation
• JetBrains AI Terms of Service (AI Assistant, Junie)
• Product Data Collection and Usage Notice
• Frequently Asked Questions About Detailed Code-Related Data Collection
• JetBrains AI Enterprise: Securely leverage the power of AI and unleash developer productivity
• JetBrains Data Processing Addendum