The era of training is stabilizing. Most models are brute-forcing most benchmarks to the point that they become irrelevant. We think that this issue is caused by one big problem. There is too much paper but nothing to concretize them. Instead we prefer training to death the biggest model possible.

One model to rule them all, they say.

We think, among others, that maybe connecting smaller models, making deep recursive thinking like humans do, may be a good idea.

After all, Poetiq tried it, and it worked very well on tests like ARC-AGI. Why not apply the same principles to real-world applications, like development?

If nature made us think like that, there is maybe a reason; we try to turn LLMs into builders, not overtrained monsters.

"A model answers a question. Brio solves a problem." would describe what we try to build.

High-level reasoning is expensive. Raw execution shouldn't be.

Brio rejects the "One Model to Rule Them All" dogma. We treat intelligence as a tiered supply chain. Our kernel routes tasks to the most efficient model for the specific node in your graph, balancing latency, cost, and perplexity.

Instead of burning budget on a monolithic call, Brio orchestrates a symphony of specialized weights:

• The Sprinters (Execution & Syntax): For high-speed code generation and formatting, we leverage hyper-optimized, low-latency models like Devstral 2 2512 or GLM 4.7. Fast, cheap, and brutally effective at following instructions.
• The Thinkers (Strategy & Verification): When the system needs to architect a solution, audit code for security, or reason through ambiguity, it escalates to heavy lifters like Claude 4.5 Opus.

Result: You get some of the reasoning depth of a frontier model with the throughput and cost-efficiency of a lightweight runner. Cool enough?

Although it's not as magical as just running Claude Opus 4.5 24h/24h, you will still have money on your bank account at the end of the month.

We provide the primitives. You define the physics.

While we offer robust presets (like the classic Architect → Builder → Critic loop), Brio enforces no specific topology. You are free to structure the "Service Mesh of Minds" exactly how your domain requires. That means you can experiment with however you think "reasoning the good way" is.

The Brio Kernel is a blank canvas for directed acyclic graphs (DAGs) or recursive loops:

• The Linear Factory: Researcher → Summarizer → Formatter
• The recursive Loop: Coder ↔ Tester (Repeat until 0 errors)
• The Council: 3 separate Agents propose solutions → 1 Judge synthesizes the best.

Whether you need a simple linear pipe or a complex, self-healing swarm, Brio's strictly headless architecture adapts to the shape of your problem.

LLMs are brilliant, but they’re also chaotic. They hallucinate, they confidently suggest rm -rf / is a good idea at debugging your frontend, and they don’t care about your uptime. We didn't build Brio to just "chat" with your machine; we built it to be a craftsman that respects the system it’s working on.

Our architecture is built on three non-negotiable pillars:

• Headless by Default: We build kernels, not chatbots.
• Safety First: Intelligence without containment is a hazard.
• Lean Core: We reject bloat. We build precise tools for precise work.

We are looking for engineers who are bored with prompt engineering and ready to contribute to the mechanization of reasoning.

If you care about:

• Distributed Systems & Graph Theory
• Sandboxing & Security
• High-Performance Orchestration
• The mechanization of reasoning

You are home.