AI Code Review That Respects Your Work and Your Privacy

Most AI code review tools poll providers or phone home every time you type. AzMX AI does neither — it runs a real PTY terminal, a CodeMirror editor, and approval-gated agents on your machine with no telemetry. If you need ethical, privacy-respecting AI code review, this is the tool.

Code review is the most effective way to maintain quality, catch bugs, and share knowledge. But most AI-assisted review tools come with compromises: they require cloud access, log your diffs, or inject notifications that break flow. AzMX AI takes a different approach — it integrates code review directly into a terminal-based agent that respects your privacy and your workflow.

Why Most AI Code Review Tools Miss the Mark

Existing tools like GitHub Copilot, Cursor, or Claude Code embed review into their chat or diff panels. They are convenient, but they often phone home for every suggestion. For developers working on proprietary code, under tight security policies, or offline, this is a non-starter. Tools like Tabnine and Codeium offer local modes, but they still depend on a model server — either cloud or self-hosted. AzMX AI is the only tool we know that runs fully offline with no telemetry out of the box, using your own keys (BYOK) or local models via LM Studio or Ollama.

How AzMX AI Handles Code Review

AzMX AI is a native ~7 MB desktop app for macOS, Windows, and Linux. It combines three core components: a real PTY terminal (xterm.js + portable-pty), a CodeMirror 6 editor with per-hunk AI diffs, and an approval-gated agent that can only execute commands or apply changes after you confirm. Code review is just one of the many tasks this agent can perform — but it does it uniquely well.

Approval Gates for Every Diff

When you ask the agent to review a recent commit or a set of changes, it does not blindly modify files. Instead, it generates a diff (using git diff HEAD~1 or your specified range), analyzes each hunk, and presents its findings as a structured review. You see the exact changes the agent proposes — especially if it suggests refactoring or fixes. You must approve each hunk (or the whole review) before anything is applied. This eliminates the trust issue: you are always in control.

Project Memory via AZMX.md

The agent reads a file called AZMX.md in your project root. This file acts as project memory — you can specify coding conventions, style rules, testing expectations, and even personal preferences (e.g., "Prefer const over let" or "All new features must include unit tests"). The review process uses this context to tailor its suggestions. If your team uses Semantic Versioning, you can add a rule to check that version bumps are correct. This makes the review consistent across commits and contributors.

Setting Up a Code Review Workflow

Here's a practical walkthrough to integrate AI code review into your daily development loop.

Step 1: Install and Configure Models

Download AzMX AI from azmx.ai/download. On first launch, you can either configure a BYOK provider (OpenAI, Anthropic, Google, Groq, xAI, Cerebras, DeepSeek, NVIDIA NIM, Azure OpenAI, Sarvam) or connect to a local model server (LM Studio or Ollama). For offline reviews, local models are the best choice — they do not require network access, and they never log your data.

Add your API keys in Settings (no account required, no telemetry). The only network call the app makes on its own is a signed updater check for binary integrity.

Step 2: Write Project Memory (AZMX.md)

In your project root, create an AZMX.md file with review guidelines:

# AZMX Project Memory
## Code Review Rules
- Check for unused imports and dead code.
- Verify that all public functions have docstrings.
- Ensure error handling uses proper logging, not print statements.
- Confirm that tests are present for new logic.
- Review diff size: commits over 500 lines should be split.

The agent reads this file automatically and applies the rules during reviews.

Step 3: Run a Review on the Latest Commit

Open the terminal in AzMX AI and run:

azmx review diff HEAD~1

The agent fetches the diff from git, analyzes each hunk, and displays a structured review in the terminal output. Each suggestion is accompanied by a proposed code change. You see the exact diff with color-coded hunks (green for additions, red for deletions). The agent pauses and waits for your approval before applying any changes.

Step 4: Approve or Reject Hunks

For each hunk, the agent shows a prompt: "Apply this change? (y/n/diff)". You can type y to accept, n to reject, or diff to see the full diff again. If you reject, the hunk is skipped. If you accept, the change is applied inline to the file. The agent never modifies files without your explicit permission.

Security and Privacy by Default

AzMX AI ships with a built-in deny list: it refuses to read, write, or display contents of .env, .ssh directories, credential files, and other sensitive paths. You cannot accidentally expose credentials during a review. This is enforced at the agent level, not just in the UI — the agent understands these restrictions.

For teams with stricter needs, you can extend the deny list by editing a configuration file. The agent respects file system permissions and will refuse commands that violate your rules.

Comparison with Other AI Code Review Tools

Let's be honest about alternatives:

• Cursor and Claude Code — excellent editors but send code to their servers for every suggestion. No offline mode. They are great for prototyping, less for security-sensitive reviews.
• Aider and Cline — work in terminal, support local models, but require you to manage the agent context and have no built-in approval gates for individual hunks. Aider's commit-based editing is faster but riskier.
• Continue, Windsurf, Tabnine, Codeium — offer local inference options, but their code review features are often secondary to autocomplete. They do not have project memory files.
• GitHub Copilot and Sourcegraph Cody — tightly integrated with cloud services. Excellent for quick questions but lack true offline review flow.
• Tabby — fully self-hosted, but it is focused on code completion and chat, not per-hunk review with terminal access.

AzMX AI is the only tool that combines PTY terminal access, approval-gated diffs, project memory, and fully offline operation in a single ~7 MB package. It is not better for everyone's use case — if you need cloud-based async reviews with multiple participants, a dedicated platform like GitHub Actions or a pull request bot may be better. But for a developer who wants a focused, privacy-first, approval-gated review loop inside their terminal, it is uniquely suited.

Advanced: Sub-Agents for Multi-Stage Reviews

AzMX AI supports sub-agents — you can spawn a secondary agent dedicated to reviewing code style while the main agent handles logic. For example:

azmx sub-review --type style --target ./src/main.ts

The sub-agent runs in its own context, following a separate set of rules (you can pass a different AZMX.md path). It returns its findings independently. This is useful for large projects where you want separation of concerns: one agent checks formatting, another checks security, another checks consistency with the architecture document.

Extending with MCP

AzMX AI speaks MCP (Model Context Protocol) over both stdio and HTTP. You can build your own review bots that connect to the agent. For instance, a security-focused MCP server could scan for vulnerable patterns and feed results back into the review queue. Everything stays local unless you explicitly configure otherwise.

The Bottom Line

AI code review does not have to mean sacrificing privacy or accepting noisy notifications. AzMX AI gives you a clean, honest tool that respects your work. It runs offline, uses your own models, and never touches your network without your approval. If you want a code review workflow that is ethical, efficient, and terminal-native, give it a try. Download from azmx.ai/download or read more in the documentation.

The code review process is better when you are in control. AzMX AI puts that control back in your hands.