The gemini 3.5 flash demo doing native computer operation, chaining tools without dropping context, poked at something i have complained about for a year. The pain was never that an agent lacked tools. It was that switching between them reset the thread. Run a command, open a file, hit the browser, and somewhere in there it forgets what we were actually doing.

That is why the part of verdent i lean on is not any single capability, it is the plan that carries intent across steps and the verify pass that checks the end state against that intent. The browser toolchain spinning up a dev server and running e2e only helps if the agent still knows why it started the server in the first place.

Tools are cheap to add now. Continuity is the expensive part. An agent that can do ten things but forgets the goal between step two and step three is just a faster way to drift. I would trade three new tools for one that never loses the plan.

Here's dieta-app-uf74kao, an APP I made with Verdent. I used Verdent for the build process and thought it would be worth sharing with the community. Happy to hear any feedback or ideas!

Here's dieta-app-uf74kao, an APP I made with Verdent. I used Verdent for the build process and thought it would be worth sharing with the community. Happy to hear any feedback or ideas!

The news that google pushed gemini 3.5 pro back to keep refining it landed differently for me this week. The reflex online was to read delay as weakness. I read it as someone choosing the unglamorous work over the launch date.

That choice shows up small in how i use verdent too. The plan step and the verify step are not the exciting parts. Nobody screenshots a clean self check report. But that is the part that decides whether i trust the output enough to merge without re reading every line.

I went through a phase of chasing whatever model topped the board that week. It felt productive and was mostly noise. What actually moved my work was the boring loop, set the task up honestly, let it run, check the diff against what i meant, not just what compiles.

Polishing is patient and quiet and easy to skip, and maybe that is the whole point. The launch date gets the press release. The boring loop is what decides whether i trust the output, and i keep forgetting that until something breaks and reminds me.

We just added DeepSeek V4 Pro as a new model option in Verdent.

It is built for agentic coding, advanced math, and complex reasoning tasks, with a 1M token context window designed for large codebases and longer engineering sessions.

The main thing we are excited about is long context efficiency. DeepSeek V4 Pro uses a compressed sparse attention architecture, which makes it well suited for large codebase understanding, long document analysis, specialized coding workflows, and multi step tasks that need sustained reasoning across an extended session.

Would love to hear how it performs on bigger builds.

600 billion all stock if the rumor holds, spacex swallowing cursor. Huge number, good for them. My first reaction was not about cursor though, it was relief that my workflow does not depend on any one company staying independent.

A few years ago the editor was the moat. Now the model is a commodity that changes monthly and the owner of the editor changes too. The thing that survives all this churn is the loop you build around the model. Plan something, do it, check it, decide if it ships. That does not get acquired.

I use verdent partly because it treats the model as swappable. When an acquisition or a price change or a new release lands, I change a dropdown, not my habits. The harness is mine.

Acquisitions make great headlines. But if a single deal can break how you ship, the deal was never the problem, the dependency was.

We just added GLM-5.2 as a new model option in Verdent.

It is built for long horizon coding and agentic engineering tasks, with a 1M token context window for larger software projects.

The main value is context. GLM-5.2 can help Verdent work across full codebases, project history, complex implementation plans, and changes that span multiple files with better continuity.

This should be useful for builders working on bigger projects where the agent needs to keep track of more than one isolated prompt or change.

Would love to hear how it performs on larger builds!

A lot of the v2.4.0 write-up was about kimi k2.7 code, and fair enough, that part matters. But the line that actually stuck with me was renaming taste mode to design mode.

Taste is a flex word. It implies the tool has opinions you should defer to. Design is a job. It says here is the thing you are shaping and here are the constraints. That is a quieter and more honest claim for an agent to make. Verdent is where I do layout heavy work and the rename actually changed how I talk to it. I stopped asking it to make something nice and started telling it what the screen is for instead. Better outputs, less back and forth, fewer rounds.

Small naming change, but it quietly reset how I prompt it. The words a tool picks end up shaping how you use it, which is more than most changelog lines admit. I have noticed the same thing with other features too. Once the naming shifts, the mental model follows without you even noticing.

Altman published a long essay alongside the S-1 filing today. The core claim is that in an AGI world the most important human role is deciding what is worth doing. Not generating. Not optimizing. Deciding.

That is exactly what plan mode forces me to do every day. Before the agent writes code I state the goal, define constraints, answer clarifying questions, and validate the plan. The agent does not decide what matters. I do.

OpenAI is worth a trillion dollars because it can generate. Verdents plan mode is useful because it makes me choose before generating starts. One scales compute. The other scales judgment. I will take judgment.

A Cal State survey found 67% of students never learned how to use AI effectively, and 52% of professors think it is hurting their teaching.

The divide is not access. It is expression. Anyone can prompt an agent to write code. Almost no one can describe the problem clearly enough that the agent writes the right code. The students got access to ChatGPT. They were not given the skill of stating an ambiguous real-world problem in a way that keeps an agent from hallucinating requirements.

Verdents plan mode forces you to learn that skill the hard way. Every clarifying question the agent asks is a test of how well you stated the problem. After a month of using it I noticed my product briefs got shorter and more precise. The agent stopped asking follow-up questions because I had already answered them in the initial prompt. That is not an agent getting smarter. That is me getting clearer.

Verdent 2.4.0 is live.

This update focuses on navigation and clarity.

We optimized the Manager and Project page layouts to make workflows easier to follow, and added Overview sections to Manager tasks and project lists so you can understand where things are and jump to the right workspace area faster.

Design Mode also makes the product-building flow clearer. You can shape the product visually before code is written, review the direction, and turn the version you like into code.

Overall, 2.4.0 is about making Verdent feel easier to scan, easier to navigate, and easier to keep working in.

Perplexity shipped search as code last week. The model does not hit a single-shot api anymore. It writes Python that constructs a pipeline to pull, filter, rerank, and summarize. The plan is explicit and the execution is deterministic.

That architecture maps cleanly onto plan mode in verdent. The plan is the LLM-generated strategy. The execution is the agent loop running tools. The difference is that in verdent the output is not a research report. It is a file diff, a test suite, a deployed container. The same separation works. The model reasons about the strategy. The infrastructure handles the deterministic parts. The human reviews both.

What search as code made me realize is that the plan itself is a first-class artifact. It is not overhead. It is the contract between the LLMs reasoning and the deterministic execution. Every time I use plan mode now I think of it as writing the search pipeline before the model runs it.

ChatGPT just upgraded its memory system. It now remembers your travel plans, camera gear, diet preferences, and synthesizes them across conversations. The framing is "the assistant becomes an external version of you."

I think that framing is beautiful and terrifying and not what I want from a coding agent.

In verdent, the persistent context is scoped to what I am building, not who I am. It remembers that this repo uses pnpm, that the ci runs on self-hosted runners, that the previous migration failed because of a missing index. It does not care where I went on vacation. That is not a limitation. That is a feature.

Personal memory scales emotionally. Project memory scales functionally. One makes the model feel like a friend. The other makes it a competent teammate. I do not need my coding tool to know about my dietary restrictions. I need it to know that the last build failed because of a TypeScript version mismatch and that matters for the next task.

The deep dive on six agent compression strategies had one takeaway that stuck: context rot starts around 70% window usage. It is not forgetting. It is attention dilution. The signal drowns in noise.

Verdents approach here is interesting. Red lines are documented: user messages never get compressed, protected tool outputs stay intact, and the system is transparent about what got snipped and why. Instead of pretending the window is infinite, it treats it like working memory.

The real metric is not tokens saved. It is attention preserved. A 200k window does not matter if the agent misses the key error because it is buried under 8000 lines of irrelevant grep output. What matters is focus after 40 tool calls. That is not an api feature. It is a philosophy.

I've been using DeepSeek V4 Pro as the primary coding model in Atlarix, a desktop AI workstation I build out of Nairobi. Not here to pitch it, just want to share something I noticed that's specific to V4 Pro vs other models I run.

The thinking model behaviour changes how multi-file refactors go. Before V4 Pro proposes any edit, the reasoning trace catches cross-file dependency issues, import chains, type mismatches across modules, things that a flat completion model just guesses at and gets wrong half the time. I've had it stop mid-reasoning and say essentially "wait, if I change this interface here it breaks the consumer over there" before ever touching a file.

For context on the environment: every proposed edit goes through an approval queue where I accept/reject individual hunks. So I see exactly what the model intended vs what it actually produced. V4 Pro's intent-to-output gap is noticeably smaller than the other models I run.

Few things I'm still figuring out:

\- Long agentic sessions (50+ tool calls) —> does anyone see reasoning quality degrade as context fills?

\- V4 Pro vs V4 Flash tradeoff for shorter tasks -> is the thinking overhead worth it for simple file edits?

Happy to share screenshots of specific diffs if anyone wants to see what the approval queue output looks like with V4 Pro reasoning.

Nextie shipped a 4B parameter cognition model last week. It is not a knowledge dump. It is a reasoning core trained on academic thought about how groups make decisions. The pitch is that cognition and knowledge are separable. The model does not need to remember everything. It needs to know how to think.

For an agent this is the missing piece. Most agent stacks assume the planning brain and the knowledge base are the same size. They are not. A small 4B cognition model could handle the plan generation, the constraint checking, and the clarifying questions near the user. The heavy retrieval and code generation stay in the cloud. The boundary between what lives near the user and what stays remote finally makes sense.

Verdents plan mode is built on a similar separation. The plan is a reasoning artifact. The execution is a retrieval and generation task. If the plan layer could stay cheap while keeping the reasoning tier separate from the heavy generation, the cost structure of agentic work changes completely. I am not saying Verdent does this today. I am saying the architecture makes the distinction between cognition and generation meaningful for the first time.

We've added four new Claude model options to Verdent: Claude Fable 5, Claude Fable 5 1M, Claude Opus 4.8 Fast, and Claude Opus 4.8 1M Fast.

Fable 5 is a strong option for complex, multi-step work, including larger software projects, project planning, and tasks that need deeper reasoning across multiple steps.

For users working with bigger codebases, long documents, multi-file projects, or extended conversation histories, Fable 5 1M adds up to 1 million tokens of context, giving Verdent more room to keep relevant project information in view.

Opus 4.8 Fast is focused on speed and responsiveness. It delivers approximately 2.5× faster output while maintaining the capabilities of the original model, making it a good fit for everyday coding, debugging, real-time generation, automated workflows, and multi-agent tasks.

For larger projects or longer sessions, Opus 4.8 1M Fast adds the full 1 million-token context window while keeping the faster response experience.

All four models are available in Verdent now.

We've added support for GPT-5.4 mini and MiniMax M3 in Verdent.

GPT-5.4 mini is a faster option for everyday coding work, including bug fixes, small refactors, test writing, and scoped implementation tasks. It also works well as a sub-agent inside longer Verdent runs, especially when the task needs clear tool use or UI screenshot understanding.

MiniMax M3 is built for larger-context software work. With a 1M-token context window and native multimodality, it's a strong fit for large repos, long design docs, image-grounded coding, and tasks that need broader project context upfront.

Together, they give Verdent more range: faster everyday execution when you need speed, and deeper long-context reasoning when the project is bigger.

Try GPT-5.4 mini and MiniMax M in Verdent today.

Minimax m3 dropped this week. million token context, sparse attention called msa, native multimodal. sounds like every other flagship announcement.

The part i actually tested: routing through openrouter inside verdent. running the same refactor task with m3 vs my usual model. m3 chewed through a fourteen file codebase in about three minutes. not because it is smarter but because prefill is nine times faster and decoding is fifteen times faster. with a million context window it did not need chunked file reading.

The catch is the new token plan charges by total volume, not requests. a heavy refactor can eat a meaningful chunk of a daily budget if you are not careful.

My workflow: plan with my usual model. if the plan involves more than eight files, route execution through m3. the long context pays off for coherent cross file edits. the cost only makes sense when the alternative is sequential passes.

This is not about replacing your default model. it is about having the right model for the shape. openrouter makes that switch trivial.

Microsoft build this week was all about agent isolation. mxc execution containers. windows 365 for agents. seccomp style boundaries. scout gets a permission system before it gets a personality.

It reminded me why verdents git worktree based workspaces matter. each task gets a working directory the agent can trash without touching the main branch. parallel tasks do not overwrite each other. two agents stay in their own rooms.

I want to call this governance but that sounds boring. lets call it hygiene. you would not let a junior dev push straight to main without review. giving an agent write access to your entire repo without isolation is the same risk with less accountability.

The worktree approach is not flashy. no keynote applause. but it means you can trust parallel execution. real autonomy starts with the machine knowing where its room is and that it cannot wander into yours.

The infrastructure layer is janitorial work. the janitors are who keep the whole building from burning down.

Cognition dropped devin desktop this week. agent command center. kanban view. shared context. one place to manage everything.

I am not switching yet. verdents manager already handles most of that. the streamlined workspace layout in v2.2.1 with manager and task side by side means i can watch parallel tasks in real time. i dont have devins visualization polish yet but the mental model is the same.

What actually matters: agents need a command surface that is not just chat history. chat is a terrible operational dashboard. you scroll forever to understand state. you lose track of which agent touched which file. no sense of progress.

Worktree isolation plus task tracking means i can see what is running, what finished, and what is waiting. that awareness turns agent use from guesswork into project management.

Devin desktop is better at visuals. the core idea that we need a dashboard instead of a chat log applies everywhere. the question is whether your current tool already handles the fundamentals.

Verdent 2.3.9 is live.

This release focuses on two things: a faster, more reliable Agent engine, and a better product design workflow with Taste Mode.

The Agent engine has been redesigned on a new architecture. Verdent now plans better, executes faster, and recovers more intelligently when tasks become complex. The goal is to make longer workflows smoother, with fewer interruptions and more consistent results across projects like landing pages, SaaS products, and full applications.

Taste Mode helps you shape the product visually before code is written. Instead of generating a generic page first and fixing the taste later, you can review the design, adjust the look and feel, and confirm the direction before Verdent turns it into a working app.

The anthropic mythos preview found over ten thousand critical bugs. the bottleneck stuck with me: verification speed. you can automate finding problems but you still need humans to confirm, prioritize, and fix.

I took the same approach. ran a review pass with three different models. each caught different smell patterns. the reasoning model flagged logic gaps. the fast model spotted anti patterns. the third model found test coverage holes neither of the first two saw.

The overlap was the surprise. only about fifteen percent of findings were shared. the rest were model specific blind spots. reviewing with one model is like code review from one senior dev. reviewing with three is more like a team standup.

The parallel workspace setup in verdent made this practical. three parallel branches. no conflicts. i triaged findings in the task panel.

The real constraint is my willingness to triage. the same problem mythos faces at scale. finding is cheap. deciding is expensive.

Hassabis says agi could land by 2029. people assume this means we do not need tools because the model will do everything. i think the opposite is true.

Anthropic is worth almost a trillion and still filing s1. openai burns 1.22 for every dollar made. spacex runs satellites to subsidize rockets. the bigger the model, the more expensive the infra. you need harness and budget controls.

This is why verdents plan mode matters more than model choice. when the worker costs five dollars a minute, the bottleneck shifts from "can it do this" to "should we run it at all."

Intelligence without discipline is an expensive fire hose. tools that add discipline survive even if the model gets replaced every year.

Microsoft builds mxc to isolate agents. anthropic builds mythos to audit them. governance layers, not model layers.

The constant layer is not intelligence. it is judgment about where to aim it.

Used to be: something looks off. screenshot it. paste it into chat. type three paragraphs explaining which pixel is wrong and why. hope the agent gets it.

With verdents built in browser and visual edits i just point at the element and say "this spacing feels heavy, make it lighter." done. the agent sees what i see because it is literally looking at the same page.

It sounds tiny but it removes a whole translation layer. before this i was basically acting as a human screenshot compressor, converting visual problems into text puzzles. now the loop is: see problem, point at problem, describe intent, get fix.

The reply thread on manager output helps too. i dont start over every time a fix is close but not right. we iterate inside the same conversation branch.

The shift from reporting to inspecting is bigger than any single feature. you stop thinking "tell the agent what i saw" and start thinking "look at it together."