augment.vim keeps the chat, drops inline completions

The headline feature was removed before you install it

The most important line in this README is a status notice rather than a feature description. Inline code completions have been sunset and no longer function, and the README says so twice: once in the project status box and again in the quick tour, adding that older documentation or options may still reference them.

What remains is a chat client. The plugin provides multi-turn chat conversations tailored to your codebase, and it shares the same underlying context engine that powers the Augment plugins for VSCode and IntelliJ. The context comes from your workspace rather than from the buffer you happen to have open.

The project status box also defines what the team will do next. The plugin is in maintenance mode: the Augment team takes care of bug fixes and security patches, and small feature requests will be considered. That is a narrower commitment than a normal feature roadmap, and the release list backs it up. Two releases appear, v0.48.1 and a v0.48.0 marked as a prerelease, both dated 2026-06-09, and the last push was on 2026-06-10.

For an editor user, that means you are adopting a chat interface with a settled feature set, not an early experiment, and also that any gap you hit will not be fixed by a new release cycle unless it counts as a small feature request.

Three version floors decide whether the plugin will load

The getting started steps set explicit minimums, and each one is a real installation dependency rather than a suggestion.

For the editor itself, Vim requires version 9.1.0 or newer and Neovim requires version 0.10.0 or newer. The README warns that the plugin may require a newer version than what your system ships by default, which is a common trap on long-lived Linux distributions and on macOS, where the system Vim is often several major versions behind.

The third dependency is the one most Vim plugin users will not expect: Node.js, version 22.0.0 or newer, is a required dependency. That is a large runtime to install for what a user might assume is a pure Vimscript plugin, and it means the plugin will not work on a locked-down machine without Node.js.

The repository layout explains where the code lives. There is an autoload/ directory, a plugin/ directory, a lua/ directory and a dist/ directory, alongside doc/, CHANGELOG.md and LICENSE.md. The dist/ and lua/ directories point to a build that ships prebuilt JavaScript or Lua artifacts, which is how a plugin that talks to a hosted service usually handles the network side.

The service itself is also a requirement: the README asks you to sign up for a free trial of Augment and then sign in from the editor with the :Augment signin command. No configuration file replaces the account.

Two plugin managers, one line of configuration

Manual installation is documented for both editors, with the clone target changing to the pack directory of the editor in use. The advantage of a package manager is that updates arrive with the rest of your configuration, so that is the route most users will take.

With Vim Plug, the plugin is added as a single line:

        Plug 'augmentcode/augment.vim'

With lazy.nvim the same repository goes into the plugin table:

        { 'augmentcode/augment.vim' },

After the plugin is present, the sequence is the same on both editors: add workspace folders to your configuration, start the editor, and run :Augment signin to authenticate against the Augment service.

One timing detail matters and is easy to miss. The g:augment_workspace_folders option must be set before the plugin is loaded, so a setting added to a config file after the first start will not take effect until the next launch. The README confirms that after adding a workspace folder and restarting vim, the output of :Augment status includes the syncing progress for that folder, which gives you a way to confirm the setting was picked up rather than assuming it worked.

Workspace folders decide how much of your repository the service sees

Workspace folders are the mechanism that turns the chat from generic into codebase-aware. Adding your project root as a workspace folder lets Augment use context from across the project rather than only the open file, and the README says this improves the accuracy and style of chat responses.

The configuration is a Vim list, and paths can be absolute or relative to your home directory:

let g:augment_workspace_folders = ['/path/to/project', '~/another-project']

Exclusions work through a .augmentignore file placed in the root of a workspace folder, and the README describes it as treated similarly to a .gitignore file, so you add patterns such as a directory name to exclude it. The finer behaviour of that file is pointed at external documentation rather than spelled out here, which is worth reading before you rely on subtle patterns.

There is a performance reason to use .augmentignore rather than leaving it out. Augment excludes ignored files and directories from its filesystem watcher, so listing large directories reduces the number of file watches registered with the operating system. If the system file-watch limit is reached, for example fs.inotify.max_user_watches on Linux, Augment logs a warning that is visible through :Augment log and keeps syncing the directories it is already watching. The symptom of hitting the limit is therefore a quiet one: the plugin still works, but part of your tree is not being indexed.

The command set is a chat surface with Neovim-only extras

Everything the plugin exposes runs through the :Augment prefix, and the README lists the commands with a short comment for each:

:Augment status        " View the current status of the plugin
:Augment signin        " Start the sign in flow
:Augment signout       " Sign out of Augment
:Augment log           " View the plugin log
:Augment chat          " Send a chat message to Augment AI
:Augment chat-input    " Compose a chat message in a floating window (Neovim only)
:Augment chat-new      " Start a new chat conversation
:Augment chat-toggle   " Toggle the chat panel visibility
:Augment help          " List the available commands, or `:Augment help <command>` for details

Responses arrive in a separate chat buffer with markdown formatting. A conversation carries history, so follow-up questions keep the context of earlier exchanges. You can send a message directly with :Augment chat and a question, or select text in visual mode and type :Augment chat followed by your question so the selection becomes part of the request.

Neovim users get one extra affordance. :Augment chat-input opens a centered floating window with a markdown scratch buffer for composing longer prompts, opens in insert mode, and shows its key bindings in the title: <C-s> or <CR> submits, <Esc> or <C-c> cancels. If the input window is already open, running the command again refocuses it instead of replacing what you typed. In Vim the command falls back to the standard input() prompt with no behavior change. The plugin defines no default mapping for it, so you add your own:

nnoremap <leader>ai :Augment chat-input<CR>
vnoremap <leader>ai :Augment chat-input<CR>

Note that :Augment chat-new clears the chat history, which matters if you have been building up a multi-turn thread you still need.

Where the chat plugin approach stops being the right one

There is a clear case against this plugin, and it is the one the README states first: if your goal is inline completions as you type, this plugin no longer provides them. Any workflow that depended on ghost text suggestions has to move to a different editor or a different tool entirely.

The second case is about the cost of the dependency chain. Running a chat client inside Vim requires Node.js 22 or newer, an Augment account, and a synced workspace. A team that already does assistant work outside the editor, in a terminal or in a browser, gets none of the incremental benefit from this plugin beyond context that the editor hands over, while taking on the runtime dependency and the sync step. The difference in approach is exactly that: an editor plugin keeps the assistant next to the buffer and reads your selection and workspace directly, while a standalone client keeps the editor free of a large runtime and reads only what you paste or point it at.

The third case is organisational. Maintenance mode plus a custom license means you inherit responsibility for the parts you depend on. The repository carries a LICENSE.md rather than a standard MIT or Apache file, and the README does not describe the terms, so a legal review of that file is the sensible first step for a company rather than an assumption about permissiveness.

One more limitation is operational rather than legal: the plugin depends on a hosted service for the model and for the context engine, so the chat path needs network access to that service and inherits its availability and its data handling.

Editorial conclusion

augment.vim is a reasonable pick for a Vim or Neovim user who wants codebase-aware chat without leaving the editor, and a poor pick for anyone who still wants inline completions or for a team that needs a plugin with an active feature roadmap. Before adopting it, verify that your editor version meets the floor (Vim 9.1.0 or Neovim 0.10.0) and that Node.js 22 or newer is available, because the plugin depends on it, then confirm your repository is worth syncing by adding its root as a workspace folder and checking the syncing progress in the output of :Augment status. Given that the last push was on 2026-06-10 and the project states it is in maintenance mode, plan to own any local fixes you need.

Frequently asked questions

Official sources

1. augmentcode/augment.vim on GitHub
2. Issues
3. Project website
4. README
5. Releases