From Pilot to Production: Enterprise AI Agents with Agno and Brick

How to run production-grade, EU-sovereign AI agents using the Agno framework on Regolo’s zero-data-retention inference — with brick-complexity-pro as your intelligent routing layer.

Recent industry data shows that while 78% of organizations run active AI agent pilots, only 14% reach production scale – the blockers are always the same: compliance, observability, cost control, and infrastructure ownership.

For European companies, the bar just got higher, as of August 2, 2026, the EU AI Act is fully enforceable: transparency obligations under Article 50 apply, and the Commission can investigate and fine GPAI providers — with penalties up to €15M or 3% of global turnover. If your agents touch customer data, your inference layer is now a compliance surface.

This guide shows a production architecture that solves both problems at once:

Everything stays in EU datacenters, no prompt data is retained or used for training, and you get a full audit trail for your AI Act documentation.

Architecture overview

┌─────────────────────────────────────────────────────────┐
│                     AgentOS (Agno)                      │
│  FastAPI runtime · sessions · RBAC · OpenTelemetry      │
└────────────────────────┬────────────────────────────────┘
                         │
              ┌──────────▼──────────┐
              │   Agno Agent(s)     │
              │   tools · memory    │
              └──────────┬──────────┘
                         │ OpenAI-compatible API
              ┌──────────▼──────────┐
              │ brick-complexity-pro│  ← routing meta-model
              │  (Regolo hosted)    │
              └──────────┬──────────┘
                         │ classifies: complexity + capability
        ┌────────────────┼────────────────┐
        ▼                ▼                ▼
   small tier        mid tier         frontier tier
 (gpt-oss-20b)   (Llama-3.3-70B)   (qwen3.5-122b)
        └────────────────┴────────────────┘
              All inference: EU, ZDR, green energyCode language: Bash (bash)

One ingress model decides, per request, which model tier handles the task. Simple classification or extraction calls never burn frontier-model tokens; hard reasoning never gets under-powered by a small model.

1. Project setup

# setup local env
mkdir agno-regolo && cd agno-regolo && python3 -m venv .venv && source .venv/bin/active

# Install modules
pip install agno openai python-dotenvCode language: Bash (bash)

# Create new file .env
REGOLO_API_KEY=your_regolo_virtual_key

# Create new empty file 
touch main.pyCode language: Bash (bash)

Get your key from the Regolo dashboard (Virtual Keys section) – We expose an OpenAI-compatible endpoint at https://api.regolo.ai/v1, so Agno’s OpenAILike class connects natively — no adapters, no proxies.

2. Basic agent on Regolo

# in main.py file

from os import getenv
from dotenv import load_dotenv
from agno.agent import Agent
from agno.models.openai.like import OpenAILike

load_dotenv()

agent = Agent(
    model=OpenAILike(
        id="glm5.2",
        api_key=getenv("REGOLO_API_KEY"),
        base_url="https://api.regolo.ai/v1",
    ),
    markdown=True,
)

agent.print_response("Summarize the key obligations of EU AI Act Article 50.")Code language: Python (python)

You can choose among a wide list of open source models available in API here.

3. Configuring brick-complexity-pro

brick-complexity-pro is the hosted, production version of Brick, Regolo’s open-source Mixture-of-Models router (Apache 2.0, github.com/regolo-ai/brick-SR1). Instead of generating answers, it reads each incoming prompt, computes two signals — a complexity grade (easy / medium / hard, based on semantic demand rather than length) and a capability vector — then dispatches the request to the best-fit model in Regolo’s hosted pool.

Key specs:

Property	Value
Model ID	brick-complexity-pro
Endpoint	https://api.regolo.ai/v1 (OpenAI-compatible)
Context window	100K tokens (15K max output)
Pricing	$0.12 / 1M input · $0.46 / 1M output — the lowest-priced model on Regolo
Capabilities	Tool calling, vision
Data policy	EU region, zero data retention, no training

Recommended Agno configuration

Point your agent at brick-complexity-pro exactly like any other model — the routing happens server-side:

from os import getenv
from agno.agent import Agent
from agno.models.openai.like import OpenAILike

agent = Agent(
    model=OpenAILike(
        id="brick-complexity-pro",
        api_key=getenv("REGOLO_API_KEY"),
        base_url="https://api.regolo.ai/v1",
    ),
    tools=[...],            # tool calling is supported through the router
    markdown=True,
)Code language: Python (python)

Hybrid topologies: routed + pinned models

In multi-agent systems, don’t route everything. A pattern that works well:

• Orchestrator / user-facing agent → brick-complexity-pro (complexity varies, quality matters)
• Extraction / classification sub-agents → pinned to a small model like gpt-oss-20b (deterministic task, fixed schema — skip routing overhead)
• Evaluation / revalidation agents → pinned to a frontier model like qwen3.5-122b (accuracy is the whole point)

orchestrator = Agent(
    model=OpenAILike(id="brick-complexity-pro", api_key=key, base_url=url),
    ...
)
extractor = Agent(
    model=OpenAILike(id="gpt-oss-20b", api_key=key, base_url=url),
    ...
)Code language: Python (python)

Why this pays off

Brick’s routing decisions add only ~20 ms of latency (the complexity classifier is a LoRA-tuned Qwen3.5-0.8B) and the open-source router has demonstrated cost reductions between 4.71x and 22.15x versus always-on frontier models, while matching or exceeding single-model accuracy. At enterprise volumes, this is the difference between an agent that finance approves and one that stays a pilot.

---

4. Production hardening with AgentOS

A model config is not a production system. Agno ships AgentOS, a FastAPI-based runtime that turns your agents into a governed service:

• 50+ pre-built REST/SSE/WebSocket endpoints — sessions, runs, memory, knowledge, metrics
• JWT-based RBAC and multi-tenant isolation — per-team access control without custom middleware
• OpenTelemetry tracing and run history — every agent step is logged, timed, and auditable
• Agentic memory — user-specific facts stored and recalled across runs, with inspectable storage

from agno.os import AgentOS

agent_os = AgentOS(agents=[orchestrator, extractor])
app = agent_os.get_app()Code language: Python (python)

The tracing layer doubles as your AI Act evidence base: run logs, model routing decisions, and data-flow records are exactly what transparency documentation and internal audits require.

---

5. Compliance checklist (EU AI Act + GDPR)

Running this stack gives you the following out of the box — document each point in your technical file:

• Data residency: all inference on Regolo runs in EU datacenters
• Zero data retention: prompts and responses are not stored or used for training
• Traceability: OpenTelemetry traces + AgentOS run history for every agent execution
• Human oversight: Agno supports human-in-the-loop tool approval for high-impact actions
• Model documentation: open-weight models in the pool (Llama, Qwen, GPT-OSS, Apertus) come with published weights and cards
• Transparency (Art. 50): agents identify as AI systems; synthetic outputs are marked in your application layer

---

6. Putting it together

# main.py 

from os import getenv
from dotenv import load_dotenv
from agno.agent import Agent
from agno.models.openai.like import OpenAILike
from agno.os import AgentOS
from agno.tools.duckduckgo import DuckDuckGoTools

load_dotenv()

REGOLO = dict(
    api_key=getenv("REGOLO_API_KEY"),
    base_url="https://api.regolo.ai/v1",
)

orchestrator = Agent(
    name="orchestrator",
    model=OpenAILike(id="brick-complexity-pro", **REGOLO),
    tools=[DuckDuckGoTools()],
    enable_agentic_memory=True,
    markdown=True,
)

extractor = Agent(
    name="extractor",
    model=OpenAILike(id="gpt-oss-20b", **REGOLO),
)

agent_os = AgentOS(agents=[orchestrator, extractor])
app = agent_os.get_app()Code language: Python (python)

Deploy behind your existing auth, point your product at the AgentOS endpoints, and you have an agent platform that is fast, cheap, auditable, and fully European.

---

What is brick-complexity-pro?

brick-complexity-pro is a hosted semantic routing model by Regolo.ai. Instead of generating answers, it reads each incoming prompt, classifies its complexity (easy, medium, or hard) and capability requirements, then dispatches the request to the best-fit model in Regolo’s hosted pool. It is the production endpoint of Brick, Regolo’s open-source Mixture-of-Models router.

How do you configure brick-complexity-pro in Agno?

Use Agno’s OpenAILike class with id="brick-complexity-pro", base_url="https://api.regolo.ai/v1", and your Regolo API key. Regolo exposes an OpenAI-compatible API, so no adapters or proxies are needed — the routing happens entirely server-side, and the agent code stays unchanged.

What is the difference between auto and max routing modes in Brick?

In auto mode, Brick dynamically selects the best model tier per request and falls back to another model if the chosen one fails — ideal for production traffic. In max mode, every request is routed to the strongest model in the pool — recommended for evaluation harnesses, regression suites, and accuracy-critical validation runs.

Is Agno compatible with Regolo.ai?

Yes. Regolo.ai exposes an OpenAI-compatible endpoint at https://api.regolo.ai/v1, and Agno supports any OpenAI-compatible provider through its OpenAILike model class. Setting the base URL and API key is the only configuration required; streaming, tool calling, and structured outputs work natively.

How much does brick-complexity-pro cost?

brick-complexity-pro is priced at $0.12 per million input tokens and $0.46 per million output tokens, making it the lowest-priced model on Regolo.ai. It supports a 100K-token context window, 15K max output tokens, tool calling, and vision. Routing decisions add only about 20 ms of latency.

How much can semantic routing reduce LLM inference costs?

Brick, the open-source router behind brick-complexity-pro, has demonstrated inference cost reductions between 4.71x and 22.15x compared to sending every request to a frontier model, while matching or exceeding single-model accuracy. Savings come from serving easy and medium requests with smaller, cheaper models.

Does Regolo.ai comply with GDPR and the EU AI Act?

Regolo.ai runs all inference in EU datacenters on renewable energy with a zero-data-retention policy: prompts and responses are never stored or used for training. Combined with Agno’s OpenTelemetry tracing and run history, this provides the data residency, traceability, and documentation needed for GDPR compliance and EU AI Act transparency obligations.

What is AgentOS in Agno?

AgentOS is Agno’s production runtime: a FastAPI-based service that exposes agents through 50+ pre-built REST, SSE, and WebSocket endpoints. It includes session management, JWT-based RBAC, multi-tenant isolation, OpenTelemetry tracing, and agentic memory — the infrastructure layer required to move agents from prototype to governed production systems.

When should you pin a model instead of using brick-complexity-pro routing?

Pin a specific model when the task is deterministic and its complexity is known in advance — for example, schema-constrained extraction on a small model like gpt-oss-20b, or evaluation and revalidation on a frontier model like qwen3.5-122b. Route through brick-complexity-pro when request complexity varies, as with user-facing orchestrator agents.

Does brick-complexity-pro support tool calling and vision?

Yes. brick-complexity-pro supports both tool calling and vision, so Agno agents using tools — web search, code execution, knowledge bases — work through the router without changes. Tool-call requests are dispatched to pool models that support function calling.

---