# Codient — A Multi-Model AI Coding Assistant for Your Terminal (and VSCode)

> Source: <https://dev.to/hamidsamak/codient-a-multi-model-ai-coding-assistant-for-your-terminal-and-vscode-22jc>
> Published: 2026-07-28 10:33:32+00:00

Most AI coding assistants lock you into one model and one workflow. **Codient** takes a different approach: it's a command-line tool that drives Claude, ChatGPT, Gemini, and DeepSeek through their actual web sessions — so you use the accounts you already have, switch models per-task, and keep full control over what gets changed in your codebase.

It ships two parts:

Project site: [codient.ir](https://codient.ir)

Instead of routing your code through a paid API, Codient automates a real browser session (via Selenium) against the AI's web UI. That means:

```
CLI Command
   ↓
Python Engine
   ↓
Selenium Automation
   ↓
AI Web UI (Claude / ChatGPT / Gemini / DeepSeek)
   ↓
AI Response Parsing
   ↓ (if AI requests more files → follow-up loop, max 5 rounds)
File System Update / Diff / Backup
```

**Requirements:** Python 3.8+, Google Chrome, and a matching ChromeDriver.

```
git clone https://github.com/hamidsamak/codient.git
cd codient

python3 -m venv venv
venv/bin/pip install -r requirements.txt
```

Add it to your `PATH`

so you can run `codient`

from anywhere:

``` bash
mkdir -p ~/.local/bin
cat > ~/.local/bin/codient << EOF
#!/bin/bash
exec "$(pwd)/venv/bin/python" "$(pwd)/codient" "\$@"
EOF
chmod +x ~/.local/bin/codient

echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc && source ~/.bashrc
```

Using WSL Ubuntu? There's a dedicated

[WSL setup guide]for getting Chrome/ChromeDriver working.

Before using a model, open a browser session and log in once — the session is saved for future runs:

```
codient --browser --model claude
codient --browser --model gemini
codient --browser --model chatgpt
codient --browser --model deepseek
```

Basic usage (default model is DeepSeek):

```
codient "Fix this code" file1.py file2.py
```

Pick a specific model:

```
codient --model claude "Fix this code" app.py
```

Apply changes directly, with an automatic backup:

```
codient --overwrite "Refactor this code" main.py
```

Pass read-only reference files with `--context`

; anything after `--`

is an editable target:

```
codient "Improve architecture" --context utils.py config.py -- main.py
```

If you skip `--overwrite`

, Codient generates a visual HTML diff report instead of touching any files, and opens it in your browser automatically.

If the AI needs to see more files to finish the task, Codient detects that request, looks for the files locally, and — if it can't find one — asks you for the path. This repeats for up to 5 rounds until the AI has everything it needs. In `--non-interactive`

mode (useful for CI or the VSCode extension), missing files are skipped automatically and the AI is told to create them from scratch instead of prompting you.

Keep separate logins for different accounts or purposes:

```
codient --browser --profile work
codient --profile work "Fix this code" app.py
codient --list-profiles
```

Every modified file is backed up before it's touched:

```
codient --rollback main.py
codient --rollback main.py --timestamp 20250101123000
```

The extension is a thin front-end over the same CLI engine. Once installed, open the Command Palette (`Ctrl+Shift+P`

/ `Cmd+Shift+P`

) and use:

Settings you can configure:

| Setting | Default | Description |
|---|---|---|
`codient.model` |
`default` |
`claude` , `chatgpt` , `gemini` , or `deepseek`
|
`codient.proxy` |
(empty) |
e.g. `http://127.0.0.1:8080`
|
`codient.profile` |
`default` |
Chrome profile to use |

```
npm install -g @vscode/vsce
vsce package
code --install-extension codient-*.vsix
```

Codient is still an early, actively developed project — feedback, issues, and stars are very welcome. If you work with multiple AI coding assistants and want one consistent CLI/editor workflow across all of them, give it a try:

There's also a [video walkthrough](https://www.youtube.com/watch?v=7rxg5bH-JLo) covering installation and usage end-to-end.