Bello AI Agent
by Makson1793x more usage on your coding agent, same quality. Have an multi-agent setup in mind? Bello already supports it. Mix models, run agents in parallel, have them check each other’s work, and reduce unnecessary model calls and noisy tool output. Turn on only what you need.
Bello is an open-source ai agent by Makson179, written mainly in Python, with 177 GitHub stars and the MIT license. Its code was last updated Oct 20, 2026. The latest PyPI release is bello 0.8.1, published Nov 6, 2026, with 244 downloads last week.
Contents
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 API-equivalent cost by 22% on Astra and by 14.8% on Luna.
On NetHackers, Bello in Goal mode set the state of the art for the lawful human female Valkyrie. Against Codex Goal on the same model, Bello's best score was 42.18% higher, it reached Codex Goal's final best 4.39 times sooner, and it cost 9.59% less.
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, thenbello 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 installonce, thenbello 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.mdwith 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.
https://github.com/user-attachments/assets/1a61ba61-444f-4347-b12b-e411d12c55c6
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:
| Role | Model |
|---|---|
| Coder | GPT-5.6 Sol |
| Coder subagents, three in parallel | Claude Sonnet, GLM, GPT-5.6 Luna |
| Runtime supervisor | GPT-5.6 Terra |
| Completion reviewer | Claude Fable |
| Adversary | GPT-6 Astra |
| Log distiller | ModernBERT on your machine |
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.
Goal mode
For tasks with a measurable target, bello --task TASK.md --goal (or goal in
bello config) keeps the run going until the completion reviewer accepts the
original objectives. After each successful turn the coder continues toward the
goal right away, and completion review starts only when the coder marks the
work as ready. Completion review is always on in this mode, and completion
returns are unlimited. The reviewer returns work only for a concrete unmet
requirement, such as a score of 65/100 where 70/100 is required, and does not
add requirements or block on polish. The coder keeps a short GOAL_MAP.md of
what it tried, what happened and what is left to try.
Runtime supervision is on by default in Goal mode. Every 20 minutes it checks
progress against GOAL_MAP.md and can send the coder a short suggestion, at
most once every 30 minutes, which the coder is free to ignore.
--no-goal-runtime (or goal-runtime in bello config) runs Goal without
runtime model calls; as with --no-runtime, this also allows network access
inside the sandbox. --goal-adversary-after-returns N starts the adversary
after N completion returns, or as soon as the reviewer accepts, and completion
review then continues until it accepts. Goal is off by default; see
docs/runtime.md.
No Need For Context (NNC)
NNC compresses older conversation history into a summary while preserving the original task, instructions, and a recent tail of complete interactions. It works with Claude Code, native Codex and API providers, for the coder, the reviewer, the adversary and their subagents.
This lets agents continue long-running tasks without carrying the entire
conversation into every subsequent request. NNC is off by default. When it is
on, it summarizes at 244,800 input tokens and keeps a recent tail of about
24,800 tokens by default; both values are configurable with
--context-threshold-tokens and --context-retain-tokens or in bello config.
Whole turns and tool-call groups stay intact, so the tail can be somewhat
larger, and the tail can be at most half the threshold.
--context-retain-percent keeps the older percentage mode. See
configuration and backend details.
Mean observed test-pass fraction (partial evaluation included), historical API-equivalent cost, and solver time; three attempts per setup. Measurements and settings.
Results
Scores are ProgramBench completion scores unless a task has its own evaluator. Raw denotes the baseline without the Bello features being compared.
NetHack: state of the art, and Bello against Codex Goal
NetHackers is a benchmark where a bot plays NetHack on its own. A bot's score is its mean progression over 15 public dungeons, measured by character level and dungeon depth.
Bello in Goal mode, with Claude Opus 5.5 at max as the coder, set the state
of the art for the lawful human female Valkyrie (val-hum-law-fem): 56.628%
against the previous best of 56.600%.
To compare Bello with Codex's own goal mode, we gave both the same task: write
a bot from an empty directory for the dwarf Valkyrie (val-dwa-law-fem), with
GPT-6 Luna at high as the coder and 24 hours per run. Codex Goal ran stock
Codex 0.161 with its built-in goal mode. Bello ran the same coder in Goal mode
with runtime supervision (Luna at max, cheap triage on), completion review,
one adversary pass after three completion returns, and Smart Execution.
Bello's best bot reached 4.21% mean progression against 2.96% for Codex Goal, 42.18% higher. Bello reached Codex Goal's final best in 5:05 against 22:19, 4.39 times sooner, and went on to pass 4%, which Codex Goal did not reach. The whole Bello run, with every supervising role, cost $6.13 in API-equivalent terms against $6.78 for Codex Goal, 9.59% less.
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.
Smart Execution: fewer model calls, lower cost
Smart Execution runs independent tool calls in parallel and delivers results as
they become ready. It is on by default for new configurations;
--no-async-tools or bello config turns it off. The agent can continue other necessary work while commands
run; when it needs to wait, Bello handles the wait without repeated model calls
to check progress. Unlike the log distiller, Smart Execution does not itself
compress tool output.
We compared RAW with Smart Execution on Sonnet 5 and Astra, with three runs per model and setup, twelve in total. The table shows means; times cover the solver.
<picture> <img src="./docs/assets/readme-smart-execution.png" alt="Smart Execution versus RAW: API-equivalent cost falls 30.19% on Sonnet 5 and 31.61% on Astra; solution time falls 50.00% and 15.06%. Mean scores change from 43.98% to 42.37% and from 58.88% to 58.44%. Three runs per model and setup." width="100%"> </picture>| Model | API-equivalent cost, RAW → SE | Solution time, RAW → SE | Score, RAW → SE |
|---|---|---|---|
| Sonnet 5 | $5.45 → $3.81 (−30.19%) | 42:26 → 21:13 (−50.00%) | 43.98% → 42.37% (−3.68%) |
| Astra | $9.37 → $6.41 (−31.61%) | 31:20 → 26:37 (−15.06%) | 58.88% → 58.44% (−0.74%) |
Both models cost less and finished sooner on average, with a small decrease in score. Every Smart Execution run cost less than every RAW run of the same model in this comparison.
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.
| Task | Raw score | Budget score | Change | Raw weekly limit | Budget weekly limit | Raw time | Budget time |
|---|---|---|---|---|---|---|---|
| Revive | 40.990% | 45.530% | +11.08% | 3.2757% | 1.0555% | 24:52 | 1:23:22 |
| JSONSchema | 56.821% | 54.673% | -3.78% | 3.0069% | 0.8138% | 23:34 | 1:20:43 |
| LightningCSS | 60.750% | 60.302% | -0.74% | 6.0281% | 2.2569% | 40:39 | 2:58:52 |
| Miller | 33.839% | 34.684% | +2.50% | 3.3190% | 1.1428% | 24:44 | 1:36:00 |
| All 12 + 12 | 48.100% | 48.797% | +1.45% | 15.6297% | 5.2690% | 28:27 | 1:49:44 |
Scores and times are means over three runs; weekly limit is the sum.
<picture> <img src="./docs/assets/programbench-efficient-budget-quality-cost.png" alt="Efficient Budget quality and weekly limit use compared with Raw GPT-5.6 Sol XHigh" width="100%"> </picture>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.
| Task | Raw completion | C+A completion | Change | Raw time | C+A time |
|---|---|---|---|---|---|
| Solar | 53.13% | 59.00% | +11.05% | 00:32:33 | 02:17:45 |
| Samtools | 51.86% | 63.00% | +21.48% | 00:36:17 | 02:14:40 |
| Rumdl | 55.60% | 81.00% | +45.68% | 01:40:05 | 02:35:41 |
| Mean / total time | 53.53% | 67.67% | +26.41% | 02:48:55 | 07: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 | Raw score | Runtime-only score | Change | Raw time | Runtime-only time |
|---|---|---|---|---|---|
| Marl | 32.91% | 37.91% | +15.19% | 00:58:49 | 00:46:09 |
| Slab | 81.08% | 85.69% | +5.69% | 00:57:26 | 01:04:11 |
| Pinch | 89.25% | 98.00% | +9.80% | 00:40:09 | 00:43:34 |
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). API-equivalent cost fell with both, so the selector works for weak and strong coders alike.
<picture> <img src="./docs/assets/readme-distiller.png" alt="API-equivalent cost versus quality: each model's Raw cost is normalized to 100. Astra XHigh changes from cost 100 and score 62.22% to cost 77.98 and score 60.57%. Luna Max changes from cost 100 and score 56.75% to cost 85.22 and score 55.45%, including runtime." width="100%"> </picture>| Coder | Runs per arm | API-equivalent cost | Score, off to on | Mean solution time, off to on |
|---|---|---|---|---|
| Astra XHigh, runtime off | 3 | -22.0% | 62.22% to 60.57% | 33:04 to 42:10 |
| Luna Max, runtime on | 6 | -14.8% | 56.75% to 55.45% | 1:41:53 to 1:22:38 |
Luna's 14.8% includes the runtime supervisor's API-equivalent cost in the Bello arm. After subtracting the recorded runtime cost, the coder's API-equivalent cost was 25.3% lower. 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, the four switches, Goal mode, Smart Execution,
and No Need For Context. bello --help lists the run flags.
- Providers, sign-in, switches, and the distiller
- Smart Execution
- No Need For Context: optional summarizing of older context for long runs, off by default
- 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.
Bello alternatives
View more →Similar ai agents in Coding Agents, ranked by GitHub stars. Compare licence, recent activity and scan status before you choose.
| Name | Stars | Licence | Last updated | Scan |
|---|---|---|---|---|
| Bello (this page) Makson179 | 177 | MIT | Oct 20, 2026 | Scanned, no flagged issues |
| AutoGPT Significant-Gravitas | 188k | None found | Nov 1, 2026 | Not scanned yet |
| Langchain langchain-ai | 149k | MIT | Nov 1, 2026 | Scanned, no flagged issues |
| Gemini CLI google-gemini | 109k | Apache-2.0 | Nov 1, 2026 | Scanned, no flagged issues |
| MetaGPT FoundationAgents | 71k | MIT | Jan 21, 2026 | Scanned, no flagged issues |
| Oh My Openagent code-yeongyu | 71k | None found | Nov 1, 2026 | Not scanned yet |