I've released vincent v0.8.0, and this release pushes the project much further toward the workflow I've wanted from coding agents from the beginning:
explore conversationally, then turn that work into controlled and repeatable execution.
Chat first. Workflow when you're ready.
One of the biggest additions is free chat.
vincent can now maintain conversational coding sessions with Claude, Codex and Cursor, each running against its own Git worktree and branch.
But the important part isn't simply having another chat interface.
A chat can now be handed off directly to a task.
The task adopts the same worktree, branch, base revision and existing changes. Nothing needs to be copied or recreated.
That means you can:
- Explore a problem interactively with an agent.
- Inspect or modify the result.
- Decide that the direction is worth pursuing.
- Hand the existing workspace to a structured vincent workflow.
- Let deterministic commands, agents, checks, gates and fan-out take over.
That transition between exploration and orchestration has been one of the missing pieces in agentic development for me.
Fan-out is becoming a real execution graph
v0.8.0 also significantly expands parallel agent workloads.
Fan-out lanes can now depend on sibling lanes using needs:.
They can also be derived dynamically at runtime, allowing a planning step to decide what work should exist rather than requiring the complete graph to be hard-coded in advance.
And with schedule: eager, dependent work can start as soon as its actual dependencies have completed instead of waiting for every unrelated lane in the current round.
This makes workflows such as:
planning → parallel implementation → dependent implementation → integration
much more natural to express.
Importantly, barrier scheduling remains the default because eager scheduling intentionally trades some reproducibility for throughput.
Better observability
Agent orchestration becomes difficult very quickly if you can't answer:
What did the agent actually receive?
v0.8.0 adds a new Step Details view that records the resolved execution context at the time the step runs.
That includes things such as:
- the fully rendered prompt or command
- agent, model and effort resolution
- permission mode
- timeouts
- loop and fan-out context
- rendered conditions
- token usage
- cost
- duration
- exit codes
- failure reasons
This information is recorded when execution happens instead of being reconstructed later from configuration that may already have changed.
For debugging non-deterministic workflows, that distinction matters.
Containers, GitHub and workflow authoring
There is quite a bit more in this release.
Task command/check steps can now execute inside task-scoped containers.
vincent can create GitHub pull requests directly from completed work and display live CI checks inside the task workspace.
The TUI workflow editor has grown from editing a subset of workflow properties into a much more complete structured editor, including nested fan-out lanes, defaults, fields and control-flow settings.
Daemon configuration can also be inspected and edited through the API, CLI and TUI.
Better everyday interaction
A large amount of work also went into making vincent nicer to actually use every day.
Assistant output now has richer Markdown rendering, including tables, links and highlighted code blocks.
There is a raw/rendered toggle and better copy support.
Chat scrolling and navigation have improved.
And there's now a quiet output level for the times when you want to read the conversation rather than every tool invocation behind it.
vincent can also surface real usage quota windows from Codex and Claude Code where those CLIs make the information available.
Where vincent is heading
The individual features are useful, but v0.8.0 is really about the direction of the project.
I don't think agentic software development should be reduced to repeatedly opening a coding agent and writing increasingly elaborate prompts.
There should be a layer around those agents that understands:
- execution
- dependencies
- concurrency
- human gates
- Git state
- retries
- failures
- costs
- provenance
- observability
- recovery
while still leaving room for the interactive conversation that makes coding agents so useful in the first place.
That's the problem I'm trying to solve with vincent.
The complete v0.8.0 release notes are here:
https://lezli01.is-a.dev/vincent/changelog.html
I'd especially love feedback from people already using coding agents for workflows that go beyond a single interactive session.
Top comments (0)