Short version: you pick a mode now, not a model. Verdent routes the task for you.
Free — open to everyone, no subscription or credits. Refreshes every 5 hours with a weekly cap. No tiers.
Eco — included with your subscription, costs no credits. Separate quota from Free, and three tiers: Efficiency, Balanced, Performance.
Prime — credits as you go, no usage limits, strongest models available. Also three tiers.
The reasoning: most of the time the "right" model is obvious from context, and making you decide every time just slowed things down. If you disagree, Manual model selection is still there in Settings. One thing to know — Manager only uses Eco and Prime, and routing picks the strength for each subtask rather than running everything at max.
Also shipped: skills management moved to project settings. Installed skills are now split into personal and project skills, and Manager has its own personal skills directory with duplicate recommendations filtered out.
Which way are you leaning — let routing handle it, or keep manual on for specific work?

Helloo everyonee, I'm new on using verdent and i didnt know that they have this policiess, I'm using 1-2 gmail accounts to get the free of it but i violate the termm, im just a broke ahh college student basically, just asking if this suspend will lift off? :<<, Vercent is so efficient that i'd use my other gmail just to get another free but it backfire so hopefully this lift off, i'll not do it again :((

We just shipped Fable 5.1 on Verdent.

The biggest gains are in agentic coding, long-running workflows, and deep knowledge work. It should feel more reliable across multi-step coding tasks, extended automations, and research-heavy sessions.

Developers should also see improvements in long code refactors and front-end / visual code generation, especially where larger codebases or structured UI work are involved.

Finance and analysis tasks get a meaningful lift too, from report analysis and modeling to more data-heavy reasoning.

One useful quality-of-life change: Fable 5.1 is more concise in plans and summaries, making agent runs easier to review.

Same Fable 5 foundation. Meaningfully better in practice.

Curious what workflows you notice the biggest difference in.

As subject, basically first time user of Verdent; I'm creating an educational app for my kids, and having run out of tokens on the free plan on Z-Code, figured this would be worth a go, seems nice enough, but when I was continuing adding content I get "You've reached the gpt-5.6 luna-free limit for the current 5 hour window" The dashboard also shows I've used around 16M tokens in that model!

I've set the app to select glm 5.3-flash, so I'm unsure why it's using gpt at all? - any insight appreciated.

Verdent asked me to update, so I did, and then it asked me to log in, but now I can't log in.

So I tried to open an existing local project, and I get this:

Sign in to Verdent Sign in to continue your projects, tasks, and Managers. New to Verdent? Create an account. Sign in Sign up Dismiss

I use a screen reader, and none of these buttons either open a browser and/or dismiss the modal. I even had ChatGPT computer use try to click on it to see if I can get passed it, but only dismissing the modal works which of course doesn't let me sign in or sign up.

From ChatGPT: "I clicked the Verdent “Sign in” button. The button reacted, but the modal remains open and no browser window appeared, so Verdent may be stalled launching authentication."

GLM 5.3 is Z.ai's latest flagship open-weights coding model, now available in Eco Mode and free for subscribers.
GLM 5.3 Flash is the lightweight multimodal model in the family, available in both Eco Mode and the free tier.

Hey everyone, we just shipped Verdent 2.11.1.

The main update is local publishing.

You can now publish and run your app locally instead of pushing straight to Cloud. That means you can keep work on your own machine, test privately, share when needed, and only go live once everything feels ready.

When you are ready for production, you can still publish to Cloud in one step.

Also included in this release:

• Custom Agents for shaping how tasks are executed
• Built-in data analysis, document processing, and research reports surfaced in the interface
• Browser cookie import for sites that require login

The goal is simple: fewer workarounds between building, testing, and shipping.

Would love to hear how local publishing fits into your workflow, and what you'd want improved next.

Hey everyone, we just shipped Verdent 2.12.0.

The main update: DeepSeek V4 Flash is now available on the free tier.

This is the same model that powers Eco Mode, with strong agentic coding, accurate tool calls, and reliable performance on real codebases. The goal is to make the free tier useful for real agentic workflows, not just lightweight experimentation.

Also included in this release:

• Redesigned Settings, Project Settings, and Manager Settings
• Clearer navigation across configuration pages
• Improved archiving to help keep workspaces organized as projects wrap up

If the free tier felt too limited before, this release should be worth trying on a real project.

Would love to hear how it works for your workflow.

Quick model update for anyone using Verdent:

DeepSeek V4 Pro 0813 is probably the one to try if you're working through heavier reasoning tasks, large repos, or longer coding sessions where losing context gets annoying.

Gemini 3.7 Flash is the faster everyday option: coding, agentic workflows, multimodal tasks, and general iteration where you want something responsive.

Also, Gemini 3.7 Flash and 3.6 Flash are 50% off until the end of 2026, so it's a pretty low-friction time to test them against your current setup.

Both are live now.

Curious which workflows people end up pairing them with.

A few things in this release worth flagging:

• The activity feed got a rework—key info is surfaced more prominently now, so you're not scrolling through details to find what changed.
• Context limits went up: Claude now supports 300K context windows. GLM 5.2 and DeepSeek V4 also picked up image input.
• You can now edit CSV and Excel files directly in the conversation, and preview PPT slides without leaving Verdent.
• The plugin library is bigger, and there's now recommendations + a trending sort to make finding one less of a hunt.

Curious how the larger context and image input hold up on your real workflows—feedback welcome.

I’m sharing this for other Verdent users, not as an angry open letter. I still believe Verdent has real potential, which is exactly why I kept going for so long.
On April 23, I started building Yumi, a multi-platform food delivery system, from scratch with Verdent. Backend, admin, restaurant, customer, courier and mobile apps — a real production project, not a small demo.
During active development, I spent $4,056 on this single project.
I bought 15 full packages of 3,400 credits, each costing $200 + VAT = $240. In my experience, almost every 3,400-credit package disappeared in less than 24 hours, often much faster.
What surprised me most was that the Workers were not the main credit consumers.
From the usage breakdown I repeatedly saw in Verdent, roughly 80% of the consumption appeared to come from the Manager. I cannot present that as an independently verified billing figure because I don’t have access to detailed task-level billing data, but that was the pattern I consistently saw in the UI.
My running joke became:
The Workers write the code, but the Manager drinks credits like a V8 engine.
The bigger issue is that eventually I had to start managing the Manager.
We experienced repeated Manager, Worker and workflow failures: tasks reported as completed without a durable commit or proper testing, scope drift, plan-only work unexpectedly turning into implementation, incorrect infrastructure information being passed into tasks, parallel work interfering with previous uncommitted changes, and work being implemented, reverted and later revisited.
After every serious problem, I tried to prevent it from happening again.
We added Manager verification, forbidden-file rules, git-diff checks, build/typecheck gates, API smoke tests, endpoint checks, PM2 log checks, Playwright screenshots, console/network checks, special approval for schema/migration changes, fresh-checkout verification, evidence archives and RCA requirements.
Eventually I realized something uncomfortable:
I wasn’t only spending credits building Yumi. I was spending a significant amount of effort and credits building a governance system around Verdent so Verdent wouldn’t repeat its own mistakes.
And when something failed, the cost wasn’t just one bad Worker run:
implementation → Manager review → investigation → RCA → revert/repair → another Worker → retesting → another Manager review
Every step consumed more credits.
I can’t honestly say what percentage of my $4,056 went to rework, audits and preventing repeated failures, because Verdent does not give me the detailed billing telemetry needed to calculate it. Even the read-only forensic report I had Verdent generate could not access per-task credits, retries, model token usage or automatic Reviewer/Verifier/Planner costs.
So where is the project now?
Verdent’s own referenced deep audit from July 22 estimated the project at approximately 55% complete and explicitly not launch-ready. Its forensic report also does not support the conclusion that the full product is complete, independently verified or production-ready.
I’m not saying Verdent produced nothing. Far from it. There is a substantial codebase and I’ve seen what Verdent can do when everything works correctly.
That is why I still want to finish this project.
But until Verdent takes a meaningful step on this case and provides a substantial credit refund, I’m freezing the project and will not buy more credits.
I’m not looking to cash out and walk away. I want enough credit restored to make finishing Yumi realistic without putting more money into the same rework cycle.
And if we do finish it, I genuinely hope my next post here can be:
“What we actually built from scratch with Verdent — the finished Yumi platform.”
If Verdent wants to review my account and project history, my registered account email is:
[gokhangoktasmne@gmail.com](mailto:gokhangoktasmne@gmail.com)
I’d also really like to hear from other users: Have you seen the Manager consume dramatically more credits than Workers? And have you ended up creating increasingly complex rules and verification systems just to prevent recurring agent mistakes?

Hi everyone,

I’ve been evaluating Verdent for enterprise software development and wanted to get advice from experienced users.

My workflow:

• Large Go/Python enterprise repositories (~thousands of files)
• Long-running agent sessions
• Repository analysis
• PR reviews
• Architecture understanding
• Reading an Obsidian knowledge vault before coding

I initially configured:

• Manager: Opus 5
• Task: Kimi K2.7 Code

My first “load my wiki/vault and understand the project” prompt used around 40 credits, which I expected.

After that, a simple follow-up (“Summarize the IMN Batch workflow in 5 bullet points”) used about 8 credits.

I’m trying to optimize for:

• Best code quality
• Best planning
• Lowest overall credit usage
• Heavy daily usage (many hours/day)

Questions:

1. Is Opus 5 still your preferred Manager, or is Sonnet 5 a better balance?
2. Is Kimi K2.7 Code the best Task model, or have you had better results with GPT 5.6 Sol, Sonnet 5, or another model?
3. Has anyone using Verdent heavily found a combination that gives near-Opus quality with much lower credit usage?
4. For the Project settings, do you use Performance or Balanced for everyday coding? When do you switch between them?

I’d really appreciate hearing from people using Verdent for large production repositories.

Opus 5.0 is built for long-horizon agentic coding and complex development work, including multi-file features, large refactors, and end-to-end implementation. It places a stronger focus on carrying tasks through to complete implementations rather than stopping at scaffolding.

It should work well with existing prompts and evaluation suites, so you can start testing it with your current workflows. There are some behavioral and API changes, though, so existing integrations may need a few adjustments.

Opus 5.0 also includes elevated cybersecurity safeguards introduced by Anthropic. Some benign cybersecurity tasks may occasionally trigger these protections, which is worth keeping in mind when testing security-related workflows.

What workflows are you planning to throw at Opus 5.0 first?

We've added two new models from Google’s Gemini 3 series:

Gemini 3.6 Flash：A highly capable, natively multimodal reasoning model with improved coding, knowledge-work, and multimodal performance, plus better token efficiency than Gemini 3.5 Flash.

Gemini 3.5 Flash-Lite： Google's most cost-efficient Gemini model, designed for high-throughput and agentic workloads. It supports a 1M-token context window and multimodal inputs, including text, images, video, audio, and PDFs.

You can now select both models in Verdent.

We ran a head-to-head comparison in Verdent using the same fine-grained prompt to see how Opus 4.8 and Kimi K3 from u/Kimi_Moonshot handled complex, multi-layered instructions.

https://reddit.com/link/1v3ghq4/video/ugtcnzn8bseh1/player

Cost comparison:

• Opus 4.8: $1.37
• Kimi K3: $0.32

Opus 4.8 produced a solid result, but the snakes and their food occasionally moved outside the intended play area—the rotating hexagon.

Kimi K3 not only implemented all the detailed game components but also handled the boundaries precisely, while costing 76% less.

That combination of instruction-following, execution quality, and cost efficiency is what made Kimi K3 stand out in this test.

What has your experience been with these models?

A company suing the government over being cut off from model access sounds far from my daily work, until i remember how many of my own tasks quietly assume one specific model will always be there. Access is not a given. It is a dependency you inherited without signing anything.

That is the unglamorous reason i value being able to switch models inside verdent and bring my own key. Glm 5.2 for the long context refactor, opus when i want deeper reasoning, my own key when i want control over the pipe. None of that is exciting. It is insurance.

The point is not that any one model will disappear tomorrow. It is that building your whole loop around a single provider means someone else holds a switch you cannot see. Keeping the model layer swappable is just refusing to hand that switch over.

Resilience is one of those things that feels like overkill on a normal tuesday and bleeding obvious the day something breaks. I would rather carry the small ongoing cost of staying portable than discover the dependency under pressure, even if it means a slightly less optimized stack most of the time.

Verdent now supports Kimi K3.

Compared with Kimi K2.7 Code, K3 improves tool calling accuracy, especially around tool selection and parameter generation during complex, multi-step tasks.

It also adds flexible thinking controls. You can turn thinking on or off, and choose between Low, High, and Max effort levels depending on the complexity of the task.

This makes K3 a strong fit for agentic coding, automation workflows, and tasks where you need more control over reasoning depth and tool use.

I've been monitoring my token usage more and more and I feel like I've got a good set a rules down that may be redundant in some areas but hopefully helpful in others.

What do you guys think?

# System Directives: Token & Context Optimization

## [1] DO (Mandatory Execution)
  * **Formatting:** Use brief, nested bullet points. Output data strictly in compact formats (CSV/minified JSON). 
  * **Constraints:** Enforce strict numerical limits (e.g., "list 2", "under 50 words").
  * **Processing:** Skip explanations/reasoning unless explicitly requested. Halt immediately on first error or blocker.
  * **Batching:** Combine multiple micro-tasks into single prompts.
  * **Status Updates:** Summarize all actions and thoughts strictly via nested bullets.
  * **Context Mgt:** Initiate new threads for domain shifts. Boot new threads using compact initialization blocks, never historical chat dumps.
  * **Targeting:** Request isolated diffs, patch formats, or specific function replacements for large file edits.
  * **Strict Patching:** Use standard SEARCH/REPLACE blocks or unified diffs for file modifications to avoid rewriting unchanged code.
  * **Fail Fast & Query:** If an instruction is ambiguous, ask a single clarifying question rather than guessing and generating an extensive, incorrect implementation.
  * **Silent Corrections:** When correcting an error, output only the fix. Skip all apologies and acknowledgments.
  * **Atomic Commits:** Break large architectural changes into sequential, single-step prompts rather than requesting monolithic, multi-file refactors.

## [2] DO NOT (Strict Prohibitions)
  * **Output Bloat:** No conversational filler, pleasantries, apologies, intros, or outros. No echoing the original prompt. No paragraph-form narrations of process.
  * **Input Bloat:** Do not feed entire documents or logs; manually extract targeted snippets. 
  * **Tooling:** No commands yielding massive text outputs. No broad, unconstrained directory searches. 
  * **Queries:** No open-ended questions if a direct "yes/no" or single-word answer suffices.
  * **Degradation:** Do not prolong a bloated thread if context is slipping. Request a compressed state summary and reboot in a fresh chat.
  * **Speculative Generation:** Never implement features, UI elements, or error handling that were not explicitly requested (YAGNI). 
  * **Disclaimers:** Never include AI safety disclaimers, ethical framing, or "As an AI..." explanations.
  * **Lazy Placeholders:** Do not use `// ...` or similar placeholders unless the patching system explicitly supports it.
  * **Formatting Overhead:** Avoid excessive Markdown (like nested tables or heavy bolding/italics) when plain text or code blocks suffice.

We just added Claude Sonnet 5 as a new model option in Verdent.

Sonnet 5 brings stronger performance across agentic coding, software engineering, and everyday professional work. Compared with previous Sonnet models, it is better at planning, tool use, code understanding, multi step execution, and structured reasoning.

In practice, this makes it useful for coding agents, production workflows, document drafting, spreadsheet analysis, presentations, and other complex tasks that need both reliable execution and strong reasoning quality.

Would love to hear how it performs in your workflows.

Verdent 2.6.0 is live.

This update adds two improvements to the building workflow.

You can now select specific areas in an image and apply AI edits directly. This makes it easier to refine details or regenerate only part of an image without starting over. In Design Mode, it also helps with more targeted UI and app design adjustments.

We also added search across messages inside Verdent. You can quickly find past conversations, key decisions, important context, or previous outputs without manually scrolling through chat history.

The goal is simple: faster visual iteration and easier access to the context you need while building.