Bello

Build a cheaper, more reliable, better coding team from the models you already have.
Codex, Claude Code, OpenAI, Anthropic, OpenRouter, in any mix. Bello puts a supervisor, a reviewer, an adversary, and a local log distiller around the coder, each optional, each on its own model. In our tests, one of the configurations used 66% less Codex usage at the same quality.

Contents

• TL;DR
• Install
• Quick start
• Bello in 42 seconds
• How Bello runs a task
• Results
• Configuration
• License

TL;DR

Bello runs a coding task through a coder and four optional parts: a runtime supervisor, a completion reviewer, an adversary, and a local log distiller. The coder, the supervisor, the reviewer, and the adversary each have their own model and reasoning effort, from a Codex or Claude Code subscription or from an API provider. The four components can be enabled or disabled independently.

In our tests, the Efficient Budget configuration used 66.3% less of the weekly Codex limit than Raw GPT-5.6 Sol XHigh without lowering average quality, and its mean score was 1.45% higher. Sol Ultra C+A raised the mean score over Raw Codex by 26.4%. The log distiller cut subscription usage by 22% on Astra and by 14.8% on Luna.

Install

Python 3.11 or newer, git, and macOS, Linux with the bubblewrap package, or native 64-bit Windows 11 or Server 2022/2025 with the one-time sandbox preparation from docs/windows.md.

pipx install bello
bello doctor

Then add the model sources you want, any one is enough:

• Codex subscription: install the Codex CLI and run codex login.
• Claude Code subscription: pipx install 'bello[claude]' --force, then bello runtime login claude-code. The extra bundles the official Agent SDK and its CLI.
• API providers (OpenAI, Anthropic, OpenRouter, and other Pi providers): Node.js 22.19 or newer, bello runtime install once, then bello runtime login <provider>.
• Log distiller: pipx install 'bello[log-distiller]' --force. The model (599 MB) downloads on the first run with the distiller on. With subscription Codex it also downloads a compatible Codex helper on Apple Silicon, Windows x86_64, and Linux x86_64 (glibc 2.35+); see docs/native-codex-selection.md.

bello doctor shows what is ready, and bello update updates Bello. To run Bello from inside your coding agent, add the plugin, which includes the configuration advisor. For Codex:

codex plugin marketplace add AlexeyKulaev/Bello-codex-marketplace --ref main
codex plugin add bello@bello-marketplace

The same plugin has a Claude Code manifest in plugins/bello.

Quick start

After installing the plugin, open your coding agent in the project that contains task.md. The full start can be a short conversation:

You: Do you see the Bello plugin?

Agent: Yes. I can inspect the task, recommend a configuration, and run it with Bello.

You: Please recommend the best balance of price and quality for completing task.md.

Agent: I recommend Configuration X for task.md. It offers the best balance of price, quality, and time for this task.

You: Thanks. Please run task.md with Configuration X and keep me updated on what is happening.

The agent shows the resolved configuration before launch. Bello then runs the task and writes .supervisor/FINAL_REPORT.md with the result, changed files, checks, and remaining risks.

You can also ask a stronger model to prepare an advisory PLAN.md, then have a less expensive Bello configuration execute it. The coder receives the plan as guidance, while completion review and adversarial testing remain independent.

Bello in 42 seconds

https://github.com/user-attachments/assets/f0324432-f616-45f6-beca-9bd8282f06ef

How Bello runs a task

The coder implements the task in a disposable workspace and runs its own checks. Bello then hands the final patch back to your project. Around the coder, four parts can be switched on or off independently.

• Runtime supervisor. Follows the live run, judges risky commands before they run, redirects the coder when it drifts from the task, and can restart a failing run without losing the workspace. On by default.
• Completion reviewer. Starts with a fresh context, compares the result and its evidence with the task, and returns the work when something is missing or unproven.
• Adversary. Receives the finished result without the development history and tries to break it with edge cases, invalid input, and feature interactions. A separate check confirms its findings before they go back to the coder.
• Log distiller. A ModernBERT model we fine-tuned, running locally, that shortens tool output before the coder and its subagents read it. Reviewers get the undistilled output.

Confirmed problems go back to the coder, and the number of review and adversary rounds is a setting. Roles can use different providers, including API providers such as OpenAI, Anthropic, and OpenRouter, and the coder, the reviewer, and the adversary can also delegate work to subagents with their own models. For example, when these models are available in your accounts:

You do not have to pick all of this by hand. The advisor in the Codex and Claude Code plugins reads the task and the repository and recommends one complete setup for the priority you name. Every setting is also in bello config.

Results

Scores are ProgramBench completion scores unless a task has its own evaluator. Raw means a model run through Codex alone, without Bello.

Four models, raw and with Bello

Three ProgramBench tasks (Solar, Samtools, and Rumdl), four models, each run raw and through Bello: 24 runs in total. Sol ran at xhigh here.

Bello scored higher with every model. The gap is 13.6 points on Luna, 9.5 on Terra, 6.5 on Sol, and 6.0 on Astra. Solutions for all 24 runs.

Efficient Budget: less usage at the same quality

Efficient Budget uses GPT-5.6 Luna at xhigh for the coder, the completion reviewer, and the adversary, and Luna at high for runtime supervision with cheap triage on. It allows one completion return before one adversary pass. The baseline is Raw GPT-5.6 Sol XHigh.

Across four tasks with three runs per task and system, Budget used 5.27% of a weekly Codex limit against 15.63% for Raw, which is 66.3% less. Its mean score was 48.80% against 48.10%, 1.45% higher. Runs took longer: 1:49:44 on average against 28:27.

Scores and times are means over three runs; weekly limit is the sum.

Solutions and checksums. Per-run rows.

Sol Ultra C+A: higher quality for more time

With GPT-5.6 Sol at ultra, one completion review and one adversary pass raised the mean completion score on Solar, Samtools, and Rumdl from 53.53% to 67.67%, which is 26.41% higher than Raw Codex. Total time across the three tasks rose from 2:48:55 to 7:08:06.

Run-level scores and times. Solutions.

Runtime-only: supervision alone

With only the runtime supervisor on, Bello scored higher on three custom tasks built from long specifications with contradictions and late corrections, in about the same time as Raw Codex. Each task has its own evaluator on a 0 to 100 scale. On the shorter ProgramBench tasks (Solar, Samtools, and Rumdl) the average gain was about 2%.

Task briefs, tests, and evaluator outputs.

Log distiller: less tool output for the coder

The distiller is a ModernBERT-base encoder with a small token-selection head, about 149 million parameters. In the coder pipeline, each tool call carries a short focus written by the coder, what it wants from the result, and the distiller uses that focus to decide which parts of the output to keep and which to drop. It keeps original text and writes no summary. It runs on your CPU, so logs stay on your machine and no paid model call is added. The task file, reads of instruction files such as README or AGENTS.md, and command help pass through unchanged.

We measured it on the JSON Schema task with the same coder model, with and without distillation, on a weaker model (GPT-5.6 Luna) and on a frontier model (GPT-6 Astra). Usage fell with both, so the selector works for weak and strong coders alike.

Luna's 14.8% includes the runtime supervisor's usage in the Bello arm. After subtracting the recorded runtime cost, the coder alone used 25.3% less. Scores were 1.3 to 1.7 points lower with the distiller on.

Model on Hugging Face. Solutions and checksums.

Results for the older 4C+A+2C schedule (four completion reviews before the adversary and two after) are archived in the 0.5.2 README.

Configuration

bello config                      # interactive editor, saves .supervisor/config.json
bello runtime models              # models and reasoning efforts your accounts can use
bello --task TASK.md --adversary  # run flags override the saved settings for one run

The editor covers the model and reasoning effort of each role, subagent pools and concurrency, review budgets, and the four switches. bello --help lists the run flags.

• Providers, sign-in, switches, and the distiller
• Native Codex distiller setup
• Windows sandbox

License

Bello is released under the MIT License. See LICENSE. The distiller model is distributed separately under Apache 2.0.

Contributions require signing the project CLA. A bot will prompt you on your first pull request, and you only sign once.