ProxyAI for JetBrains: An Apache-2.0 Copilot Alternative That Talks to Any Model

What ProxyAI solves, and who it is actually for

Most AI coding assistants in JetBrains IDEs lock you to one vendor's model and one vendor's billing. ProxyAI takes the opposite position. The README describes it as "a great alternative to GitHub Copilot, AI Assistant, Codiumate, or any other extension on the JetBrains marketplace," and the differentiator is provider choice: OpenAI, Anthropic, Azure, Mistral, or a self-hosted model for what the README calls "a full offline experience."

The audience follows from that. It is for engineers whose organisation already has an Azure OpenAI deployment, a private inference cluster, or a contractual reason not to send source code to a public endpoint. It is also for individual developers who want to swap models without swapping plugins. The README lists the topics the project is tagged with, including intellij-plugin, pycharm-plugin, codellama, llama and gpt-4, which matches that positioning: the plugin is the constant, the model is the variable.

What it is not is a hosted service with a managed backend. There is no vendor-side proxy in the default path. You bring the key or the endpoint, and the plugin talks to it.

How the plugin is put together: Kotlin, Gradle and a sandboxed IDE

The repository is a Kotlin project built with Gradle. The top level contains build.gradle.kts, buildSrc/, settings.gradle.kts, gradlew and gradlew.bat, plus a src/ tree and two sibling modules, proxyai-telemetry/ and proxyai-treesitter/. The presence of a dedicated treesitter module is the most informative detail in the layout: syntax-aware context extraction is separated from the plugin code rather than buried inside it.

The data flow implied by the README is conventional for an IDE assistant. The plugin gathers context from the editor (referenced files and folders, git history, uploaded images, web documentation), assembles a request, and sends it to the provider you configured. Responses come back as chat text, as inline completion, or as suggested edits that land in a diff view for approval. The README describes auto apply as streaming "AI-suggested code changes directly into your editor" with a diff preview and one-click approve or reject, which means the plugin holds a pending-edit state rather than writing straight to the buffer.

On privacy, the README is explicit that ProxyAI "does not" collect or store sensitive information, and that anonymous usage data is collected only with consent. That is a statement about the plugin, not about your provider. If you point ProxyAI at a hosted model, the request still leaves your machine.

Running ProxyAI locally from source

The README's build instructions clone the repository, pull submodules, and launch a sandboxed IDE through Gradle. Note the submodule step: the repository has a .gitmodules entry, and skipping the update leaves you with an incomplete checkout.

git clone https://github.com/carlrobertoh/ProxyAI.git
cd ProxyAI
git submodule update
./gradlew runIde

On Windows ARM64 the README gives a variant that passes a Gradle property:

./gradlew runIde -Penv=win-arm64

When the sandbox starts, the plugin is already installed in that instance. Logs go to the sandbox directory, and the README shows how to follow them:

tail -f build/idea-sandbox/IU-2026.1/log/idea.log

The path embeds the IDE build (IU-2026.1), so it changes when the target platform changes. If you only want to use the plugin rather than build it, the README points to the JetBrains Marketplace listing at plugins.jetbrains.com/plugin/21056-proxy-ai, which is the supported install path for everyday use.

Where ProxyAI stops being the right tool

The biggest limitation is one the README states as a feature: you supply the model. That means you also supply the API key, the quota, the rate limits and the failure modes. A self-hosted setup gives you offline operation, but the quality of completion and chat is then bounded by whatever model you can run, not by the frontier models the plugin can also reach.

There is a second, quieter constraint. Every feature listed in the README (web search, image chat, git history references, next edits) depends on the provider supporting the corresponding request shape. The README does not publish a compatibility matrix mapping each feature to each provider, so the practical way to find out is to configure a provider and try the feature. Treat the feature list as the plugin's capability surface, not a guarantee that every provider exposes all of it.

The repository's last push was on 2026-05-28, and the most recent release listed is 3.8.1 from 2026-04-30, with 3.7.3-pre and 3.7.2-pre before it. That is a project with recent activity, but it is also a project where pre-release builds appear between stable ones. If you standardise a team on a specific version, pin it. The README does not document a rollback procedure for a bad plugin update, so plan for that gap before you need it.

ProxyAI compared with Continue and other JetBrains assistants

The closest comparison in the same category is Continue, another open-source assistant that also targets multiple providers. The difference is in where the configuration lives. Continue is built around a config file that describes models, context providers and custom commands, and it ships across multiple editors. ProxyAI is a JetBrains-only plugin written in Kotlin, with the provider setup handled inside the IDE's settings UI rather than a portable config file.

That distinction matters more than it sounds. A file-based configuration is easier to review, diff and check into a repository, which suits teams that want the assistant setup to be part of the project. An IDE-managed configuration is easier for an individual to get running and harder to standardise across a team. If your requirement is one configuration that follows the repository, ProxyAI's model is a worse fit. If your requirement is a native JetBrains experience with no external config to maintain, it is a better one.

The other comparison the README invites is against GitHub Copilot and JetBrains AI Assistant. Both are managed services: the vendor picks the model, handles the keys, and bills you. ProxyAI inverts all three. You get provider choice and the option of a self-hosted endpoint, and you take on the operational work that the managed services absorb.

Licence and the cost of keeping up

ProxyAI is Apache-2.0, copyright Carl-Robert Linnupuu. For most teams that is the permissive end of the spectrum: you can use, modify and redistribute it, including in commercial settings, provided you keep the licence and notices intact. It also means there is no dual-licence trap where a feature you rely on sits behind a paid tier of the same codebase. This is a description of the licence text, not legal advice; if you fork and redistribute, have your own counsel read the notice requirements.

The upgrade cost is the part the README does not address. The build targets a specific IDE platform (the log path references IU-2026.1), and a JetBrains plugin has to track platform API changes to keep working. Nothing in the README describes a support window, a long-term release branch, or a compatibility policy for older IDE versions. The CHANGELOG.md file exists at the repository root, which is where release-by-release changes would be recorded, and it is the first place to look before upgrading an IDE or the plugin. Budget for reading it rather than assuming a drop-in update.

Editorial conclusion

Adopt ProxyAI if your team already lives in IntelliJ, PyCharm or another JetBrains IDE and you need provider choice, including a self-hosted endpoint for offline work. Do not adopt it if you want a vendor-managed assistant with no key handling, or if you need a VS Code extension, which the repository does not provide. Before rolling it out, verify that your chosen provider's endpoint and model identifier load in the plugin settings, and confirm which of the documented features (auto apply, next edits, web search, image chat) your IDE build actually exposes. The last push to master was on 2026-05-28, so check open issues against your IDE version before standardising on it.

Frequently asked questions

Official sources

1. carlrobertoh/ProxyAI on GitHub
2. License: Apache-2.0
3. Project website
4. README
5. Releases