DEV Community

Cover image for Vincent 0.10.0: Less Hype, More Reliability for Agentic Development
László Szabó
László Szabó

Posted on

Vincent 0.10.0: Less Hype, More Reliability for Agentic Development

#ai #agents #devtools #opensource

Not every release needs a giant new feature.

Sometimes the most useful release is the one that removes friction from everything you already do.

That is the idea behind vincent 0.10.0.

After several releases that expanded vincent quite aggressively, this one focuses more on:

  • robustness
  • fixing rough edges
  • improving everyday workflows
  • adding familiar developer conveniences

The result is a smaller release on paper, but one that makes vincent noticeably more comfortable to use.

First: what is vincent?

vincent is an open-source tool for running agentic software-development workflows with human control built in.

Instead of treating AI coding agents as isolated chat sessions, vincent gives them structure around:

  • workflows
  • tasks
  • branches
  • retries
  • human approval gates
  • transcripts
  • pull requests
  • containers
  • parallel work
  • cost controls
  • external triggers

The goal is not to remove engineers from the loop.

It is to make agentic development repeatable, observable, and controllable.

Version 0.10.0 mostly improves what working inside that environment feels like.

Skills are now much more natural in chat

Claude Code and Codex increasingly rely on skills to extend what agents can do.

Vincent can now discover those skills and expose them directly inside chat.

Press Tab or F2 and vincent shows the skills available to the current agent.

You can then select one and insert its invocation directly into your message.

Completion also appears automatically while typing things such as:

/review
Enter fullscreen mode Exit fullscreen mode

for Claude Code, or:

$review
Enter fullscreen mode Exit fullscreen mode

for Codex.

Vincent also understands where those skills actually come from.

For example, Codex can expose:

  • repository skills
  • user skills
  • system skills
  • plugin skills

And when a chat belongs to a containerized task, vincent looks at the environment inside the container, rather than incorrectly showing skills from the host machine.

That distinction matters once agents start running in more isolated environments.

Skill execution is visible too

A skill invocation should not disappear into an opaque agent transcript.

In 0.10.0, executed skills are represented explicitly.

Instead of seeing a large dump of skill content — or nothing at all — the transcript can show:

Skill: review
Arguments: ...
Status: completed
Enter fullscreen mode Exit fullscreen mode

or indicate when the skill failed.

That applies both in the TUI and when reading task or chat transcripts later.

For me, this is part of an important principle:

If an agent performs an action, the surrounding system should make that action observable.

@file mentions arrive in chat

This is probably one of those features that feels obvious the moment you use it.

Typing:

@
Enter fullscreen mode Exit fullscreen mode

inside the chat composer now opens a ranked list of files from the chat workspace.

Keep typing:

@auth
Enter fullscreen mode Exit fullscreen mode

and vincent narrows down the candidates.

Select a result, and vincent inserts the reference in the format expected by the underlying agent.

No manually copying paths.

No jumping between terminal panes just to point the model at a file.

There is also a CLI equivalent:

vincent chat files
Enter fullscreen mode Exit fullscreen mode

This is exactly the kind of small quality-of-life improvement that makes conversational coding workflows much less annoying over time.

Work on a branch that already exists

Previously, vincent generally created its own branch and worktree when starting work.

That isolation is useful, especially for autonomous tasks.

But sometimes you already have the branch you want.

Maybe you created it yourself.

Maybe you checked it out and started experimenting manually.

Maybe you want an agent to continue exactly where you left off.

0.10.0 adds support for that.

vincent task add --branch my-feature --existing-branch
Enter fullscreen mode Exit fullscreen mode

and:

vincent chat start --branch my-feature --existing-branch
Enter fullscreen mode Exit fullscreen mode

Vincent can now work directly on that branch.

It also tries to behave conservatively around Git state.

If the branch is safely behind its upstream, vincent can fast-forward it.

If it has diverged, vincent blocks rather than trying to modify it behind your back.

And if the branch is already checked out in your normal working copy, vincent can work there directly instead of creating another worktree.

That makes vincent much easier to introduce into an existing workflow rather than forcing every interaction to start from vincent itself.

Multiline chat input

Yes, this deserves its own section.

Chat drafts can finally contain newlines.

Use:

Ctrl+J
Shift+Enter
Alt+Enter
Enter fullscreen mode Exit fullscreen mode

while plain Enter continues to send the message.

It is not a groundbreaking AI capability.

It is also one of those things you immediately miss when a terminal chat does not support it.

/clear is represented correctly

Agent conversations have context boundaries.

The UI should not pretend otherwise.

When /clear is used, vincent now marks that location in the transcript.

Previously, reading an old conversation could make earlier messages appear as though the agent still had them in context.

Now the transcript represents what actually happened more accurately.

That becomes increasingly important when transcripts are used for:

  • debugging
  • auditing
  • understanding agent decisions
  • reproducing failures

Send messages from files or stdin

Large prompts and shell-sensitive commands are another source of unnecessary friction.

Vincent now supports:

vincent chat send --message-file prompt.md
Enter fullscreen mode Exit fullscreen mode

and the same capability when starting a chat.

This also helps with skill invocations such as:

/review
Enter fullscreen mode Exit fullscreen mode

or:

$my-skill
Enter fullscreen mode Exit fullscreen mode

which some shells may otherwise interpret or modify unexpectedly.

It is a small addition, but useful when chat becomes part of a scripted workflow instead of something driven exclusively from the keyboard.

Safer global workflow updates

Vincent already has workflows that can be created and updated with agent assistance.

0.10.0 extends that idea to global workflows.

An update can now produce a proposal rather than silently replacing your configuration.

The workflow waits at an approval gate before installation.

You can inspect the proposal and then explicitly apply it.

vincent workflow ls --global
Enter fullscreen mode Exit fullscreen mode 
vincent workflow apply
Enter fullscreen mode Exit fullscreen mode

That distinction matters to the direction of the project.

I want agents to be able to help operate and evolve the system.

I do not want that to mean quietly giving them ownership of every configuration change.

Automation and control do not have to be opposites.

And a lot of fixes

The release also contains a collection of less glamorous but important fixes.

Among them:

  • containerized chats now see the correct agent credentials
  • skills typed as the first message of a task chat work correctly
  • @something no longer accidentally disables skill completion
  • cleaner Claude Code and Cursor output handling
  • task forms no longer retain stale branch names
  • blank workflow values behave consistently
  • installing vincent skills for multiple agents works correctly
  • example DAG workflows handle unpushed parent branches correctly
  • Windows installation documentation is clearer

None of these make for a dramatic release announcement.

Together, they matter quite a lot.

Why I like releases like this

Agentic development is moving extremely quickly.

It is easy to focus only on capability:

Can the agent do one more thing?

But once these tools become part of everyday engineering, a different set of questions becomes equally important.

  • Can I understand what happened?
  • Can I trust what branch it is touching?
  • Can I see which skill executed?
  • Can I recover the transcript later?
  • Can I move between manual work and agentic work naturally?
  • Does the tool stay out of my way?

That is where a lot of the work in vincent is moving now.

The goal is not simply to give an agent more power.

It is to build a dependable control plane around that power.

Try vincent

If you are experimenting with:

  • Claude Code
  • Codex
  • coding agents
  • multi-step agent workflows
  • human-in-the-loop automation
  • agent-driven pull request workflows

I would love for you to try vincent.

It is fully open source.

👉 GitHub:
https://github.com/lezli01/vincent

👉 vincent 0.10.0 changelog:
https://lezli01.is-a.dev/vincent/changelog.html#0100--skills-and-files-in-chat-and-work-on-an-existing-branch

Feedback, issues, ideas, and contributions are very welcome.

And if you are already building agentic development workflows, I am especially interested in hearing:

What are the small workflow annoyances that bother you most when working with coding agents every day?

Top comments (0)