Verdent AI: What It Is, Pricing, and How to Review the Code It Ships

Verdent is an agentic AI coding tool that turns a plain-language goal into a plan, splits it into subtasks, and runs workers on them in parallel. It ships as a desktop app for macOS and Windows, an IDE integration for VS Code and JetBrains, and Verdent Cloud, a browser product for building and publishing web apps. If you are searching for Verdent, you are probably deciding how much of your engineering work an autonomous coding agent can take on.

This guide covers what Verdent is today, how its Plan Mode, parallel workers and built-in Reviewer work, what Verdent costs, and the question most Verdent evaluations skip: once Verdent has written the code and opened the pull request, who reviews it on GitHub? Verdent does review its own changes inside the app. It is not a GitHub code review tool that sits on every pull request, and the two jobs are different.

TL;DR on Verdent

• What Verdent is: an agentic coding suite. Its desktop app breaks a goal into subtasks, dispatches a worker per subtask, and runs as many as it can at once, with progress on a Kanban board.
• Where Verdent runs: a desktop app for macOS and Windows, an IDE integration for VS Code and JetBrains, and Verdent Cloud in the browser. You can also start tasks from Slack, Telegram, Feishu or Discord.
• Verdent pricing: Lite $5/month, Starter $19/month, Pro $59/month, Max $179/month, Teams $20/user/month, Enterprise custom. The free trial includes 100 credits, and one credit is worth about $0.059.
• Verdent does review code, locally. Its built-in Reviewer subagent scans your changes and ranks findings P0 to P2. Verdent's docs describe running it before you open a pull request, not as a reviewer that comments on GitHub PRs.
• Where Macroscope fits: Macroscope is an independent AI code reviewer that installs as a GitHub app and reviews every pull request, including the ones Verdent opens. On Macroscope's own 118-bug benchmark it detected 48.3% of bugs.
• They are complements. Verdent is how the code gets written and self-checked. GitHub PR review is how the team decides it can merge.

What Is Verdent?

Verdent is an agentic coding platform that takes a goal, plans it, and executes the plan with parallel workers that report back for review. Verdent's docs describe the desktop app's Manager as dispatching "a dedicated worker per subtask" and running "as many as possible at once." Finished tasks land in a To Review column with the output, the files touched, and a decision summary.

Verdent's positioning has widened over the past year. Its homepage now leads with "Build Your Product With Plain Words In Minutes" and speaks to founders as much as engineers, and the desktop docs call Verdent "Your AI Technical Co-founder." Verdent Cloud, the browser product, builds web apps and publishes them to a *.verdent.app URL. The developer workflow is still there: Plan Mode, Agent Mode, a Reviewer subagent, git worktree isolation, and an IDE integration for VS Code and JetBrains.

That breadth is why "verdent" is a live search term for engineering teams. It is also why the review question matters. A tool built to let one person ship a lot of code quickly will produce a lot of code that someone has to trust.

Verdent's Products: Desktop, IDE Integrations, and Verdent Cloud

Verdent ships in three surfaces, and the one you use decides how much autonomy Verdent gets.

Verdent surface	What it is	Best for
Verdent desktop	Manager, Kanban, parallel workers	Delegating multi-step work
VS Code, JetBrains	IDE integration	Staying in your editor
Verdent Cloud	Browser app builder	Publishing a web app fast

The desktop app is the core of Verdent today. You describe an outcome; the Manager splits it into stages and subtasks, decides which can run in parallel, and shows progress live on a Kanban board. It asks for decisions inline while the rest of the work continues, and you can trigger tasks from chat apps. The desktop app and the VS Code extension share one credit pool.

Earlier coverage of Verdent described a separate product called Verdent Deck. Verdent's current download page and docs do not list Deck as its own product; the multi-agent workflow now lives in the desktop app.

How Verdent Works: Plan Mode, Workers, and Workspace Isolation

Verdent's workflow is plan, execute, review, and each stage is explicit.

Plan Mode. Verdent's Plan Mode turns a rough idea into an implementation plan through dialogue. It "asks clarifying questions through an interactive questionnaire," and the plan covers goals and scope, component structure, data models and API contracts. You revise the plan in Plan Mode, then switch to Agent Mode to execute. You can also skip the clarifications and let Verdent use its judgment.

Parallel workers. In the desktop app, the Manager runs subtasks concurrently, one worker per subtask. Verdent says this lets "a multi-step build that would take a single agent hours" finish in minutes.

Workspace isolation. Verdent "separates parallel code changes at the filesystem level with git worktrees." Each workspace has its own directory, branch checkout and staging state, and a workspace can hold several tasks. You bring work back with "Rebase to main branch."

Git and pull requests. Verdent only commits or pushes when you ask it to. When you ask for a pull request, it writes a description from the branch's commits and creates the PR with the gh CLI.

Rules, MCP and skills. Verdent supports rules for agent behavior, MCP integration for external tools, skills, and bring-your-own-key for model providers.

On benchmarks. Verdent's research team published SEAlign, which Verdent describes as an ICSE 2026 Distinguished Paper. Verdent says a 14B model that does well on coding benchmarks "solves only 2.8% of real engineering tasks," and that SEAlign raised it to 21.8% on SWE-bench Verified. That is a model-training result, not a score for the Verdent product, and SWE-bench Verified measures issue resolution rather than review quality.

Verdent Pricing: Every Plan, Compared

Verdent pricing is credit-based, with one credit worth about $0.059 and, in Verdent's words, "No Markup on Model Costs."

Verdent plan	Price	Monthly credits
Lite	$5/month	Top-ups only
Starter	$19/month	480/month
Pro	$59/month	1,500/month
Max	$179/month	4,500/month
Teams	$20/user/month	480 per user
Enterprise	Custom	Custom

The Starter, Pro and Max credit figures include a 50% bonus that Verdent labels as time-limited: 320, 1,000 and 3,000 base credits respectively. The free trial includes 100 credits. Top-up packs run from 340 credits for $20 to 3,400 credits for $200, and top-ups never expire. Eco Mode lets desktop users continue on lower-cost models after their credits run out, and paid plans include promotional app hosting and storage allowances that Verdent says may change.

The structural point: Verdent Teams is a per-seat product, $20 per developer per month with a credit pool sized per seat. That is a reasonable model for a coding tool, where usage roughly tracks headcount. It is a poor model for code review, where the amount of code to review no longer tracks headcount at all. More on that below.

Does Verdent Do Code Review?

Yes, inside the app. Verdent's built-in Reviewer subagent reviews your changes before you open a pull request, but Verdent's docs do not describe it reviewing or commenting on GitHub pull requests.

Here is what Verdent's Reviewer does, according to Verdent's docs:

• You tag @Reviewer in chat, or the agent calls it as a final verify step after writing code.
• It scans your changes and returns findings ranked P0 (critical), P1 (important) and P2 (suggestion), each with a file, line and confidence score.
• Multi-model review can run one to three models, mixing Claude, GPT and Gemini, at higher cost and latency.
• Review Rules let you write team standards in Markdown. They apply globally across all your projects.
• You select findings and click Fix. If Reviewer judges the changes low-risk, it may select every issue and apply the fixes without asking.

That is a useful pre-push check. Verdent's own guidance is to "Run a review before submitting a pull request. Fix all P0/P1 issues first." It is also a different job from GitHub code review. Reviewer runs on one developer's machine, on demand or inside Verdent's own workflow, under that developer's settings. It does not post on the pull request where the team reviews, it does not run on pull requests that Verdent did not write, and it cannot block a merge.

Why Agent-Written Code Needs an Independent AI Code Reviewer

The more code an agent like Verdent writes, the more the bottleneck moves from writing to reviewing. That is the real constraint on teams adopting agentic coding, and it is why "verdent" and "ai code review" often end up in the same search session.

Three things change when Verdent writes a meaningful share of your code:

1. Volume grows faster than headcount. One engineer running parallel Verdent workers can open more pull requests in a day than they used to open in a week. Human review capacity does not scale with it.
2. The reviewer's prior is wrong. Agent-written code looks polished. It has tests, a clean summary and a PR description written from the commits. That is exactly the code that gets rubber-stamped.
3. Cross-file breakage becomes the dominant bug class. Parallel workers in isolated worktrees each see their own slice. A change that is correct in one workspace can break code another worker changed. The merge is where those bugs show up.

A reviewer inside the agent shares the agent's context and the plan it was given. If the plan was subtly wrong, the code and its tests will agree with each other and still be wrong. An independent GitHub code reviewer starts from the pull request and the repository instead of from the agent's intent.

How Macroscope Reviews the Pull Requests Verdent Opens

Macroscope is an AI code review tool that installs as a GitHub app and reviews every pull request, whoever or whatever wrote it. Verdent, Claude Code, Codex, Cursor or a person at a keyboard: every PR gets the same GitHub PR review, posted where the team already works.

On each pull request, Macroscope reads the surrounding repository, not just the diff, so it can flag when a change in one file breaks code in another. It posts inline findings, an AI PR summary and a GitHub check that you can make required.

On Macroscope's own Code Review Benchmark of 118 real production bugs across 8 languages, each tool reviewed the same bugs replayed as pull requests with default settings:

AI code review tool	Detection rate
Macroscope	48.3% (57/118)
CodeRabbit	45.8%
Cursor Bugbot	42.4%
Greptile	23.6% (on 72 bugs)
Graphite Diamond	18.3%

It is Macroscope's benchmark, so test on your own code too. Separately, Code Review v3 reports 98% review-comment precision, which matters because a reviewer that people learn to scroll past catches nothing.

Verdent vs Macroscope: Different Jobs, Not Competing Tools

Verdent's Reviewer and Macroscope both look for bugs, but they run at different points and for different audiences.

	Verdent Reviewer	Macroscope
Runs	In Verdent, on demand	On every GitHub PR
Reviews	Your local changes	Any PR, any author
Findings appear	In the Verdent chat	Inline on the PR
Can block a merge	No	Yes, as a check
Fixes	One-click, local	Fix It For Me PR
Pricing	Credits; Teams per seat	Per KB reviewed

Use both. Run Verdent's Reviewer before a worker's branch becomes a pull request, then let GitHub code review hold every pull request to the same standard before it merges.

Pricing Models: Why Per-Seat Breaks for Review

Verdent Teams is $20 per user per month. Macroscope has no per-seat fee: code review is billed per KB of diff reviewed, at a rate set by the detection mode.

Macroscope product	Price
Code review, Budget	$0.025 per KB
Code review, Balanced (default)	$0.05 per KB
Code review, Precise	$0.06 per KB
Code review, Ultra	$0.20 per KB
Minimum per review	10 KB, at the mode's rate
Agent and Fix It For Me	$0.01 per credit, 1,000 free/month
Status	$0.05 per commit

A typical 19 KB pull request costs about $0.95 in Balanced mode. Every new workspace gets $100 in usage credit, and Macroscope is free for qualified non-commercial open source. You can cap spend per review and set a monthly budget; see pricing.

Why this matters for teams running Verdent: seat-based pricing assumes code output tracks headcount, and agentic coding tools break that assumption on purpose. If Verdent triples the pull requests one engineer opens, a per-seat reviewer charges the same and a usage-based reviewer charges for the code that was actually reviewed.

Fix It For Me: Closing the Loop Without Leaving GitHub

When Macroscope finds a bug in a Verdent-authored pull request, you do not have to route the fix back through Verdent. Reply to the review comment asking for a fix and Fix It For Me, the AI code fixer, creates a branch from your feature branch, commits the change and opens a PR. It uses your GitHub Actions results to validate the fix, and it can auto-merge once checks pass if you ask it to.

For an agent-heavy workflow, this keeps the fix on the pull request. Nobody has to reopen the Verdent workspace, find which worktree produced the change, and paraphrase the review comment back into a prompt.

Detection Mode: Tuning AI Code Review for Agent-Heavy Teams

If Verdent writes most of your code, you can choose how hard Macroscope looks on each pull request. Detection modes trade recall, precision, speed and cost:

• Budget ($0.025/KB): fast, low-cost feedback for dependency bumps, config edits and generated code.
• Balanced ($0.05/KB, default): the everyday balance of bug detection, precision, speed and cost.
• Precise ($0.06/KB): extra validation to cut false positives, for teams that read every comment by hand.
• Ultra ($0.20/KB): deeper detection for payments, auth and migrations, using more parallel agents.

Agent-written pull requests are not all the same. A Verdent worker that bumped a dependency belongs in Budget; one that touched your billing code belongs in Ultra.

Approvability: Clearing the Safe Pull Requests

Once Verdent produces pull requests continuously, the constraint is not only finding bugs but clearing the routine changes fast. Approvability evaluates whether a pull request is low-risk enough to merge without a human reviewer (such as documentation, tests, and code behind a disabled feature flag) and approves the safe ones while sending anything risky to a person.

That is the other half of scaling agentic development. Verdent removes the writing bottleneck. Approvability removes the "somebody has to click approve on 40 trivial PRs" bottleneck.

Custom Checks: Enforcing Standards Across Every Agent

Verdent's Review Rules shape what Verdent's Reviewer checks on your machine. They do not apply to pull requests Verdent did not write. Check Run Agents are custom AI checks, one Markdown file each in .macroscope/check-run-agents/, that run as GitHub check runs on every pull request, whoever opened it.

The difference is scope. A Verdent rule lives in one developer's settings. A Check Run Agent lives in the repository and gates what merges. If a standard must hold across human PRs, Verdent PRs and PRs from other coding agents, it belongs at the repository level. More detail is in Check Run Agents: custom AI checks on pull requests.

Verdent Alternatives and Adjacent Tools

If you are comparing Verdent, you are probably also looking at other coding agents and at AI code review tools. Keep them in separate columns.

Coding agents that overlap with Verdent include Claude Code, Codex, Cursor and OpenCode. All of them write code and run tests, and all of them have the limitation any in-agent check has: it is not an independent review on the pull request. Our guide to reviewing code from Claude Code, Codex, Cursor and OpenCode applies to Verdent output too, and running coding agents in parallel in the cloud covers the parallel workflow Verdent's Manager is built around.

GitHub code review tools include Macroscope, CodeRabbit, Greptile, Cursor Bugbot and Graphite Diamond. See CodeRabbit alternatives, Greptile alternatives, and the roundup of the best AI code review tools for GitHub.

Getting Started: Verdent for Writing, Macroscope for Reviewing

Adding the review layer takes a few minutes and changes nothing about how your team uses Verdent.

1. Keep Verdent however you run it: desktop app, VS Code, JetBrains or Verdent Cloud.
2. Install Macroscope as a GitHub app and pick your repositories.
3. Ask Verdent to open a pull request. Macroscope reviews it automatically, posts a PR summary, and comments on any correctness issues it finds.
4. Pick a detection mode per repository, and make the Macroscope check required if you want it to gate merges.
5. Turn on Approvability so trivial pull requests stop queuing behind risky ones.

New workspaces get $100 in usage credit, and qualified non-commercial open-source projects are free.

The Short Version

Verdent is a serious agentic coding tool: plan before code, parallel workers in isolated worktrees, and a built-in Reviewer before you push. If the writing bottleneck hurts your team, Verdent is worth evaluating, and the desktop Manager's parallel execution is the most interesting part of it.

What Verdent does not do is sit on your GitHub pull requests as an independent reviewer for the whole team. The system that wrote the code should not be the only system deciding it is correct. That gap widens as agent output grows, which is the same trend that makes Verdent attractive.

Verdent writes. Macroscope reviews. Teams getting real leverage from agentic coding tend to have both.

Frequently Asked Questions

What is Verdent?

Verdent is an agentic AI coding suite. Its desktop app for macOS and Windows takes a plain-language goal, breaks it into subtasks, and runs a worker on each in parallel, with progress on a Kanban board and finished work in a To Review column. Verdent also has an IDE integration for VS Code and JetBrains, and Verdent Cloud, a browser product that builds and publishes web apps.

How much does Verdent cost?

Verdent Lite is $5 per month, Starter $19 per month with 480 credits, Pro $59 per month with 1,500 credits, Max $179 per month with 4,500 credits, Teams $20 per user per month with 480 credits per user, and Enterprise is custom. The Starter, Pro and Max figures include a time-limited 50% credit bonus. The free trial includes 100 credits, one credit is worth about $0.059, and top-ups run from 340 credits for $20 to 3,400 credits for $200.

Does Verdent do code review?

Yes, locally. Verdent has a built-in Reviewer subagent that you call with @Reviewer, or that the agent calls as a final verify step. It returns findings ranked P0 to P2 with confidence scores, can use up to three models, and can apply fixes in one click. Verdent's docs describe it as a check to run before you submit a pull request. They do not describe it commenting on GitHub pull requests or running on PRs that Verdent did not write.

Is Verdent's Reviewer a replacement for a GitHub code review tool?

No. Verdent's Reviewer runs inside one developer's Verdent session, under that developer's settings, and reports in the chat. A GitHub code review tool runs on every pull request regardless of author, posts findings where the whole team reviews, and can be a required check. Run Verdent's Reviewer before you push, and keep an independent AI code reviewer on the pull request.

What happened to Verdent Deck?

Verdent Deck was the name used at launch for Verdent's multi-agent desktop experience. Verdent's current download page and docs do not list Deck as a separate product. Parallel execution now lives in the Verdent desktop app's Manager, which dispatches a worker per subtask and tracks them on a Kanban board.

What are the best Verdent alternatives?

For agentic coding, the closest Verdent alternatives are Claude Code, Codex, Cursor and OpenCode. Verdent's distinguishing choices are the clarifying-question Plan Mode, a Manager that runs parallel workers, and git worktree isolation. If what you need is a reviewer for the code your agents produce rather than another code writer, that is a different category: Macroscope, CodeRabbit, Greptile and Cursor Bugbot.

Can Macroscope review pull requests that Verdent opens?

Yes. Verdent creates pull requests with the GitHub gh CLI when you ask it to, and Macroscope reviews every GitHub pull request regardless of author. Pull requests from Verdent get the same GitHub PR review as anyone else's, which matters on teams where some engineers use Verdent, some use Claude Code, and some write everything by hand.

Why do parallel coding agents produce cross-file bugs?

Because isolation is both the feature and the failure mode. Verdent's git worktree isolation keeps parallel changes from colliding on disk, which is valuable. The side effect is that each worker sees its own slice and not what the others changed. A change that is correct in one workspace can break code another worker touched. A GitHub code reviewer that reads the surrounding repository on each pull request is how you catch that before merge.

How much does Macroscope cost compared to Verdent?

They price on different axes because they do different jobs. Verdent Teams is $20 per user per month. Macroscope has no per-seat fee: code review is $0.05 per KB in the default Balanced mode, with Budget at $0.025, Precise at $0.06 and Ultra at $0.20 per KB, and a 10 KB minimum per review billed at the mode's rate. A typical 19 KB pull request costs about $0.95 in Balanced. Agent and Fix It For Me use credits at $0.01 each with 1,000 free per month, and new workspaces get $100 in usage credit.

What does Verdent's SWE-bench Verified number mean?

Verdent's research team reports that its SEAlign training method raised a 14B model from 2.8% on real engineering tasks to 21.8% on SWE-bench Verified, work Verdent describes as an ICSE 2026 Distinguished Paper. That is a research result about training a model, not a score for the Verdent product. SWE-bench Verified also measures whether an agent can resolve an issue, not whether a reviewer catches bugs. Code review tools are measured on bug detection and comment precision instead.

What are the best CodeRabbit and Greptile alternatives for Verdent users?

If your team runs Verdent and reviews on GitHub, Macroscope is the usage-based option: no per-seat fee, billed per KB reviewed, with the highest detection rate in Macroscope's own 118-bug benchmark. See CodeRabbit alternatives and Greptile alternatives for full comparisons. Macroscope is GitHub-only, so teams on GitLab or Bitbucket should check that first.

Should I use Verdent and an AI code reviewer together?

That is the setup we recommend for teams adopting agentic coding seriously. Verdent removes the writing bottleneck, and an independent AI code reviewer keeps it from turning into a reviewing bottleneck. In practice: keep Verdent as it is, use its Reviewer before pushing, add Macroscope as a GitHub app, choose a detection mode per repository, and turn on Approvability so trivial pull requests clear without waiting for a person.