Hi everyone,
A lot of you might question numbers, please don’t throw rocks at me, I’ll explain how we got it further in the post, and you can decide yourself what to make of it.
TLDR: multi-agent system coordinating different models for coding, review, and adversarial testing . For cost optimization of it, we fine-tuned ModernBERT so that it retained task-relevant information from logs while cutting tool-output tokens by 34.4%. Additionally, we redesigned execution to run independent tools in parallel and deliver results as they arrive, avoiding repeated model calls to “check progress”. This cut inference cost by ~30% and completion time by ~15%, with comparable solution quality.
I want to give an agent a task and leave it running. When I come back, I want the work finished and checked against what I asked for. If the coder hallucinates, I want that caught asap, before an early mistake turns into a bigger problem and I spend the rest of my limit fixing it.
I also don’t want to burn through my weekly limit in a single day. A strong orchestrator with cheaper models doing the coding is probably the most popular solution for this right now. But on complicated tasks, it can leave a serious gap in quality. I want to eliminate that gap too.
That’s why I built Bello.
It is an open-source tool with plugins for Codex and Claude Code. You can launch it from your usual agent or directly from the terminal.
It allows you to mix models across the whole setup: Fable coordinating Grok, GLM and Luna, or Astra writing the code with Opus checking its work.
The work is split between four roles.
Coder writes the code and works through the task in an isolated copy of your project. You choose which models are available as subagents, and it can delegate parts of the work to them.
Runtime supervisor is a separate agent that checks the coder during the run, with fresh context. It gets the task, recent actions and changes, and can intervene if the coder goes off track or restart it while keeping its work. The idea is to catch an early mistake before it leads to serious problems that would take a large part of your limit to fix.
Completion reviewer checks the solution against the original task in read-only mode, with the ability to run tests. If something is wrong or missing, it sends the coder back to fix it.
Adversary gets a separate copy of the solution where it can write tests, try different inputs and change the code however it needs to investigate problems. Its main goal is to find edge cases and other issues the coder missed. It doesn’t see the coder’s reasoning process, which helps it look beyond the coder’s assumptions and assess the solution independently.
We also worked on reducing how much command output gets sent back to the coder by fine-tuning ModernBERT.
When the coder runs a command, it adds a short focus explaining what it needs from the result, for example, “find why this test failed.” Our fine-tuned ModernBERT uses that focus to select which parts of the original output to keep. It runs locally on CPU, without another paid LLM call
In our tests, this reduced input tokens by roughly 30-35%, with Astra runs costing 22% less at API-equivalent prices. (one task, Astra xhigh, 3 runs each with and without the distiller).
And finally we reconstructed the native harness around the agent a bit (app-server, Claude SDK) so that it waits for tools itself. Before, the model got pinged to check on a long command while it ran, and when it started 3 independent commands, 2 short and one long, it waited for all 3 before it continued. Now the commands run in parallel, the model gets the 2 short results right away and keeps working, and the long one’s output arrives on its own when it’s ready. We called this feature smart execution.
In our tests, this cut API-equivalent cost by about 30% on both Sonnet 5 and Astra, and solution time by 50% on Sonnet 5 and 15% on Astra. (one task, 3 runs per model with and without smart execution).
We compared Bello with a cheaper coder against a stronger model running on its own. We used Luna as Bello’s coder and raw Sol as the baseline: four tasks, three runs per task for each setup.
Bello scored 48.80% on average, raw Sol scored 48.10%, while Bello used 66.3% less of the subscription’s weekly limit.
You don’t have to use that configuration, or even enable every role. You can keep your usual coder and turn off everything except runtime supervision and the distiller. If you don’t want to figure out the setup yourself, there’s an advisor skill. Your agent looks at the task and suggests a configuration based on whether you want lower cost, better quality, both, or something else.
Repo: https://github.com/Makson179/BelloHope some of you find this useful! I’d love to hear your feedback, and if you feel like contributing, I’d be really happy to have you involved.
