Skip to content
BlogResearch

Introducing Verso

Octavo Team · 5 min read

Verso 1.5 is a coding model we trained for one job: quick, accurate edits across several files, inside the agent loop. It is in the model picker in Octavo. This post covers why we built it, how we trained it, what we measured and when to pick a frontier model instead.

The name comes from the book. Every leaf has a right-hand page, the one you read first, and a verso, the side behind it. Verso is where this model does most of its work: the reads, searches and small edits between your prompt and the diff you review.

Why speed matters in an agent loop

An agent task is a loop. The agent reads files, searches the codebase index, edits, runs a command, reads the output and edits again. A routine multi-file change takes many model turns, and every turn waits on the model.

Frontier models earn their latency on hard steps: an unclear requirement, a design choice, a bug with little signal. Many steps are routine. Find the call sites. Update a signature. Fix the type error the compiler just reported. On those steps, a few seconds per turn add up to minutes per task, and the person following the agent stops following it.

We wanted a model that keeps routine steps short enough to watch in real time, and accurate enough that you rarely redo them.

How we trained it

We trained Verso with reinforcement learning inside the harness the product uses, with the same tools Agent calls in the editor: read a file, search the index, edit, run a terminal command. What the model learns in training applies directly when you use it.

Training tasks come from permissively licensed open-source repositories. We take a merged pull request, check out its parent commit, write the request as a prompt and hold back the tests the pull request added. Each episode runs in a container with the repository and its dependencies installed. A simplified task looks like this:

task: payments-core/partial-refundsbase: 4f2c1e9          # parent of the merged pull requestprompt: |  Support partial refunds on captured payments.  Reject a refund larger than the amount still captured.visible_checks:  - pnpm typecheck  - pnpm test refundshidden_tests: 6        # added by the original pull request

The reward is short to state. An episode scores when the hidden tests pass and the existing suite still passes. It loses reward for editing test files the task did not mention, for disabling checks and for touching files unrelated to the change. Each turn carries a small cost, so the model learns to finish once the work is done.

Three habits that make it fast

Verso is smaller than the frontier models in the picker, so each token arrives sooner. Most of its speed comes from doing less work per task.

The first habit is writing edits as hunks. Verso sends the lines to replace and their replacement, and the harness applies the change. Rewriting a whole file to change six lines spends time on text that stays the same, and it gives the model hundreds of chances to alter a line by accident.

The second is batching reads. When the model needs three files and a search, it asks for all four in one turn. The harness runs them concurrently and returns the results together, so early exploration takes one or two round trips instead of several.

The third is stopping when the checks pass. The per-turn cost teaches the model to end the task once tests are green, without re-reading files it already changed. The trade-off is that Verso sometimes stops before a cleanup a person would make, such as removing an import the change left unused. Your linter catches most of these.

What we measured

We evaluate on held-out tasks from open-source repositories in TypeScript, Python, Go and Rust. None of these repositories appear in training. Each task is built like a training task, from a real merged change with hidden tests. A task counts as resolved when the hidden tests pass and the existing suite still passes.

We track two numbers per model: the share of tasks resolved, and wall-clock time from prompt to final diff, including the time tools take to run. Every task runs three times, and we report the median.

On the median task, Verso 1.5 finished well before the frontier models we compared. It resolved fewer tasks than the strongest of them. The gap was small on tasks with a clear specification and widest on tasks that needed a design decision, such as where a new module should live.

The set has limits. Well-tested open-source repositories are a narrow sample of the code people work on, and a hidden test checks only what its author thought to check. So we also read diffs: each week, engineers on the team grade a sample of Verso’s results as they would a colleague’s pull request.

When to choose Verso

Pick Verso 1.5 when the change is clear and you want to watch it happen: a signature change across a package, a failing test with a readable error, a follow-up to a review comment.

Pick a frontier model such as Opus 5.5, GPT-6.1 Sol or Gemini 3.1 Pro when the task needs judgment first: a vague requirement, a choice between designs, a bug you cannot reproduce yet.

The two combine well. Write the plan in Plan mode with a frontier model and answer its questions. Then switch the picker to Verso 1.5 and build. The plan carries the decisions, and Verso carries out the edits. Every agent step still has a checkpoint you can rewind to.

If you leave the picker on Auto, Octavo picks a model for each request, and Verso 1.5 is the default for speed-sensitive work. Privacy Mode covers Verso like every other model: with it on, Octavo never stores your code and never trains on it.

The full model list is on the features page.