Sublime Text remains one of the fastest and most lightweight code editors available, but for years AI tooling has been much stronger in editors such as VS Code, Cursor, and JetBrains IDEs.
That is starting to change.
Sublime Text's AI ecosystem is still relatively small, but in 2026 there are several interesting options representing very different ways of coding with AI: autocomplete, LLM chat, pair programming, and external coding agents.
In this article, I compare four of the most relevant approaches currently available for Sublime Text.
Disclosure: I am the developer of Limitcode, one of the tools included in this comparison. I have tried to keep the article focused on each tool's capabilities and the workflow it is designed for.
Quick comparison
| AI assistant | Best for | Chat | File editing | Project-wide access | External agent/CLI |
|---|---|---|---|---|---|
| Limitcode OSS | Native controlled pair programming | Yes | Yes, open files | No | No |
| TermMate | External coding agents | Yes | Through the agent | Yes | Yes |
| OpenAI Completion | General LLM chat and assistance | Yes | Not its primary focus | No | No |
| LSP-copilot | GitHub Copilot autocomplete | Yes | Suggestions | No | No |
The important distinction is that these tools are not trying to solve exactly the same problem.
1. Limitcode OSS — Best for native controlled AI pair programming
Best for: Developers who want AI to read and modify code directly inside Sublime Text without automatically giving it access to the entire project.
Limitcode is an open-source AI pair programming agent built specifically for Sublime Text.
Its approach is deliberately different from fully autonomous coding agents.
Limitcode OSS can only work with files that are already open in the active Sublime Text window. It can read them, modify their contents, and write changes directly back into those files.
It does not silently scan your repository and it cannot execute commands on your machine.
The idea is for the AI to work with you on the code you explicitly choose to expose.
Main features
- Native Sublime Text interface
- Streaming chat
- Persistent conversation history
- Read access to open files
- Direct editing of open files
-
@filereferences - Per-session model and provider switching
- Configurable reasoning effort
- OpenAI
- Anthropic
- Gemini
- DeepSeek
- Ollama
- LM Studio
Ollama and LM Studio also make it possible to use local models without configuring a cloud provider API key.
Limitcode OSS deliberately exposes a small tool surface to the agent.
It can read and edit the code you have opened, but it cannot automatically explore closed files, create arbitrary new files, execute shell commands, or take control of the entire project.
That makes the workflow closer to pair programming than autopilot.
Pros
- Built specifically for Sublime Text
- Native editor experience
- Can read and modify code
- Multiple AI providers
- Local model support
- No external coding-agent CLI required
- Explicit and controlled access to code
- Open source
Cons
- Cannot automatically explore the entire project
- Cannot work with closed files
- Cannot create new files in the OSS edition
- No shell execution
- Relatively new project Choose Limitcode OSS if: you want something closer to an AI pair programmer than a chatbot, but do not want to give an autonomous agent automatic access to your entire development environment.
What about Limitcode Pro?
Limitcode OSS is designed around controlled pair programming.
Limitcode Pro takes the same native Sublime Text experience toward a much more agentic workflow with capabilities including:
- Project-wide file exploration and search
- File creation and editing
- Permission-controlled shell execution
- Web search and page fetching
- MCP
- Skills
- Subagents
- Snapshots for restoring changes
- Automatic management of larger contexts
Everything still runs inside Sublime Text, but the agent can take responsibility for much larger development tasks.
2. TermMate — Best for Claude Code, Codex and external agents
Best for: Developers who want to use powerful external coding agents while keeping Sublime Text as their primary editor.
TermMate takes a very different approach.
Instead of implementing its own agent inside the Sublime Text plugin, it acts as an interface between Sublime Text and external coding agents such as Claude Code, Codex, and Pi Agent.
This gives developers access to much more autonomous workflows while keeping interaction with the agent close to the editor.
Depending on the underlying agent, it can explore a project, modify files, use tools, and handle multi-step development tasks.
TermMate also aims to preserve the Sublime Text experience by using a native interface rather than relying on a heavy webview.
Pros
- Works with powerful external coding agents
- Claude Code and Codex integration
- Suitable for multi-step development tasks
- Keeps Sublime Text as the primary editor
- Interface designed around Sublime Text
Cons
- Depends on external tools
- May require additional installations and authentication
- Behavior depends on the underlying agent
- More moving parts than a self-contained solution
The architectural difference with Limitcode is straightforward:
- TermMate connects Sublime Text to existing external agents.
- Limitcode implements its agent workflow directly inside Sublime Text.
Neither approach is inherently better. They solve different problems.
Choose TermMate if: you already use Claude Code, Codex, or similar external agents and want to integrate them more closely with Sublime Text.
3. OpenAI Completion — Best for general LLM chat and assistance
Best for: Developers who want a flexible LLM assistant directly inside Sublime Text.
Despite its name, OpenAI Completion is no longer limited exclusively to OpenAI.
The plugin can work with different providers and compatible APIs, including configurations using local models.
Its experience is primarily centered around chat: you can talk to a model, send entire files or parts of them as context, receive streaming responses, and display results directly in the editor using Sublime Text phantoms.
That puts it in a different category from tools such as Limitcode or TermMate.
OpenAI Completion is primarily an LLM assistant integrated into Sublime Text, rather than a coding agent whose main purpose is to autonomously operate across a project.
The project also remains actively maintained in 2026, so it should not be confused with the many early ChatGPT plugins that appeared and were later abandoned.
Pros
- Established Sublime Text project
- Chat directly inside the editor
- Streaming
- Files and code snippets as context
- Multiple providers
- OpenAI-compatible APIs
- Can work with Ollama and other local backends
- Native Sublime Text phantoms
Cons
- Primarily chat-oriented
- Not focused on agentic file editing
- Not designed as an autonomous project-wide coding agent
- Can require more configuration than simpler assistants Choose OpenAI Completion if: you mainly want to talk to different LLMs and use your code as context directly from Sublime Text.
4. LSP-copilot — Best for GitHub Copilot in Sublime Text
Best for: Developers who already use GitHub Copilot and primarily want AI-powered code completion inside Sublime Text.
LSP-copilot solves a much more focused problem.
It integrates GitHub Copilot with Sublime Text through the editor's LSP ecosystem and provides AI-generated suggestions while you type.
Its current feature set includes inline completions, phantom completions, panel completions, and chat.
Instead of asking an agent to modify an entire project, Copilot works alongside your normal coding workflow by trying to predict the code you want to write next.
Pros
- GitHub Copilot inside Sublime Text
- Inline AI completions
- Phantom completions
- Panel completions
- Chat
- Integration with Sublime Text's LSP ecosystem
- Less intrusive than a full coding agent
Cons
- Requires access to GitHub Copilot
- Tied primarily to the Copilot ecosystem
- Mainly focused on completions
- Not designed as an autonomous project-wide agent Choose LSP-copilot if: what you primarily want is the GitHub Copilot autocomplete experience inside Sublime Text.
Which AI assistant should you use with Sublime Text?
It mainly depends on how much control you want to give the AI and what you expect it to do.
If you want AI autocomplete while you type, LSP-copilot is probably the most natural choice.
If you want LLM chat with code context and multiple providers, OpenAI Completion offers a more traditional assistant experience.
If you want to use powerful external agents such as Claude Code or Codex from Sublime Text, TermMate provides an interesting bridge between both worlds.
If you want a native agent that can read and modify the code you have explicitly opened without depending on an external coding-agent CLI or automatically accessing your entire project, Limitcode OSS is designed specifically around that workflow.
And if you want to keep Limitcode's native experience while giving the AI significantly more autonomy across complete projects, that is where Limitcode Pro comes in.
Sublime Text's AI ecosystem is finally getting interesting
Sublime Text still has a considerably smaller AI ecosystem than VS Code.
But there is no longer only one way to use AI with the editor.
You can now choose between:
- GitHub Copilot autocomplete
- Chat with different LLMs
- Fully autonomous external agents
- Native controlled pair programming
Sublime Text's plugin API, native views, phantoms, commands, and LSP ecosystem provide enough building blocks for surprisingly capable AI tools without turning the editor into a Chromium-based IDE.
For developers who continue to use Sublime Text because of its speed, simplicity, and lightweight experience, switching editors solely to get modern AI tooling is becoming increasingly unnecessary.
Top comments (2)
For Sublime Text, the best assistant is probably the one that respects the editor's speed. Heavy panels and slow context scans can ruin the reason people use Sublime in the first place.
Totally agree. That's one of the reasons I think AI tooling for Sublime doesn't necessarily need to be heavy.
Most native plugins have a very small impact on the editor itself. The bigger performance cost usually comes from things like external CLI processes, continuous indexing or project-wide context scanning.
You also don't necessarily need all of that to build a capable coding agent. Tools like Pi are a good example of a much more minimal approach to context and tooling.
This actually makes me want to benchmark it properly — Sublime + different AI assistants vs VS Code/Cursor, looking at RAM usage and responsiveness.