Responsible AI.

We built the whole company on one premise: AI is only useful if you can trust what it does. These are the principles we hold ourselves to.

Don’t trust one model

A single model fails quietly and confidently. A wrong answer looks exactly like a right one. So on anything that matters, our agents are built not to trust one. That means checking a decision against ground truth, real verifiable facts rather than the loudest answer or a popular vote, and putting the highest-stakes work past a second model drawn from a different failure family that must produce a concrete reason to block it before it ships. One model’s blind spot is the other’s easy catch. Extending that cross-family check to every routed decision is the layer still being widened (◷).

The smallest sufficient model

Routing selects the smallest model family that survives verification for a task, and escalates only when a critic produces a concrete refutation. Scale is the last resort, not the first.

In practice this is a cascade: a lighter model attempts the work first, and its result is checked against executable ground truth, a check that is cheap because the machine, not another model, produces the verdict. Only a concrete failure escalates the task to a heavier model. The heavy model is the exception the light one earns, not the default.

We publish no energy figures because we do not measure energy yet. The claim we can stand behind is architectural: verification lets smaller models do work that would otherwise default to larger ones.

A human owns the consequences

Where an agent’s action has real-world consequences, a person signs off before it happens. Our one live agent works this way today, and it’s the standard every agent we build has to meet.

We mark what’s real

We separate what is running (✅) from what is planned (◷), everywhere on this site. We don’t publish capabilities we don’t have, and we don’t dress up benchmarks or invent numbers.

We measure ourselves honestly

We hold ourselves to keeping score of our own hits and misses against real outcomes, and we’d rather show what didn’t work than hide it. That record is what makes the systems better over time.

What went wrong, and what changed: the errata →

Open about the thinking, private about the build

We publish our reasoning: the ideas, and the failure modes we design around. We keep the specific implementation private. That’s to protect what we’ve built, not to avoid scrutiny: we welcome technical and financial diligence, and we go deeper in private with serious partners.

An honest limit

These are young systems. They make mistakes, and the architecture exists precisely because they do. We’re not claiming the problem is solved; we’re claiming we’re careful about it, and honest when we fall short.

Concerns about how we build or run our systems? Write to hello@bunbunlabs.com.