Brutor AI Gateway

One API for every model and every modality. Switch providers without changing code.

• 300 preconfigured models across all major providers — OpenAI, Anthropic, Google, Azure, Mistral, and self-hosted via Ollama / vLLM / KServe.
• Every modality through one endpoint — text, image (DALL·E), voice (OpenAI TTS), transcription (Whisper), video (Luma) — same governance, audit, and cost rails for all of them.
• Per-model temperature defaults — set temperature, top-p, and max tokens centrally so every team gets consistent model behavior, no per-call tweaking required.
• Routing groups with weighted load balancing, failover, and cost-based routing strategies.
• Resilience built in — per-model circuit breakers, connect timeouts, retries, and configurable fallback-model chains, so one provider having a bad day doesn’t take your apps down with it.
• Model health checks with configurable intervals and automatic unhealthy-model exclusion.
• Model lifecycle management — provider retirement dates tracked per model, with advance operator alerts so a vendor sunsetting a model never surprises production.
• Batch processing — submit thousands of requests asynchronously at reduced provider cost.
• Secure API key vault — provider keys encrypted at rest, managed centrally, never exposed to users.

Govern every tool your AI connects to.

• 80+ MCP servers ready out of the box. A curated catalog covering GitHub, HubSpot, Slack, Snowflake, Asana, Atlassian, AWS, MongoDB, Postgres, Tableau, Terraform, Grafana and more — one-click enable, no scripting.
• Containerized images mirrored to Brutor’s own registry so production deployments never depend on an external container registry going down.
• Bring your own — add any Docker image, GitHub repo, or remote MCP URL. Mix containerized and remote servers in one governed catalog.
• Virtual MCP aggregation — combine tools from many servers behind one governed endpoint, with per-group filtering and tool renaming. Your agents see one clean toolbox; you keep per-server control.
• Enterprise MCP Registry (Beta) — a standalone registry on the official MCP registry spec: federate public servers, publish your own, and attach governance metadata to every record.
• OAuth proxy handles authentication automatically for Asana, Atlassian, GitHub, HubSpot and every other OAuth-protected server — access tokens stay encrypted at the Gateway, never exposed to clients.
• Kubernetes-ready for production, with built-in system MCPs for Skills and Web Search included in every deployment.
• Capability filtering per resource group — enable individual tools, resources, and prompts so Marketing only sees HubSpot’s contact-list tools while Engineering gets the full GitHub surface.
• Three-state tool approval per MCP tool — enabled (runs immediately), approval-required (blocks pending human review), or disabled (forbidden). Mark trusted tools auto-approve; gate the actions that need a human in the loop.
• Direct function calling supported alongside MCP — use whichever fits the model.

Your documents. Your AI. Governed.

• RAG built into the gateway — no separate vector database to operate, no retrieval code to write. Answers ground automatically for every user in a bound team.
• Upload PDFs, Office documents (Word, Excel, PowerPoint), markdown, HTML, and CSV — documents chunked, embedded, and indexed automatically.
• Sync content from the tools you already use — eight connectors: Confluence, Notion, Google Drive, Slack, GitHub, Jira, SharePoint, and a web crawler. Scheduled incremental sync; synced documents keep their source permissions at retrieval time.
• Hybrid retrieval — semantic vectors plus keyword search, fused for accuracy. Reworded questions and exact part numbers both find the right document.
• Per-resource-group knowledgebases — each team, department, or app gets its own isolated corpus.
• Powered by Qdrant — the same vector engine that drives semantic caching, with per-tenant cryptographic isolation.
• Access-controlled retrieval — only users permitted for a group can query that group’s knowledgebase.
• Source citation on every answer — see exactly which documents grounded each response.
• Full audit trail — every retrieval logged with who queried what, when, and which sources were returned.

Capture your business logic. Let AI follow it — inside Brutor’s sandbox.

• Encode your organization’s processes — a skill packages instructions (SKILL.md), scripts, reference files, and templates as one versioned, governed unit.
• Progressive disclosure over MCP — agents discover the skill catalog, load full instructions on demand, then act step by step. A skill costs ~100 tokens of context until it’s actually used, and works from any MCP client.
• The bundle never leaves the platform — agents receive instructions, resource content, and script output, never the code. Scripts run only in Brutor’s isolated sandbox: no network exposure, read-only filesystem, hard timeouts.
• Every step governed independently — guardrails on skill input and output, argument policies, per-skill quotas, and human approval gates. No “approved once, trusted after.”
• Versioned and immutable — skills move through a draft → validated → published lifecycle; a published version never changes, so callers always know exactly what they’re running.
• Author in the Admin UI or sync from GitHub — keep skill bundles in a repo and publish through review.
• Per-group assignment — marketing gets marketing skills, engineering gets engineering skills.

Govern agent-to-agent traffic through the same Gateway.

• Native A2A v1.0 specification — the full open standard, implemented natively in the Gateway. No vendor extensions.
• Inbound and outbound agent traffic — both directions governed: external agents calling into your organization via the Gateway, and your agents reaching out to external agents.
• Signed Agent Cards — published at /.well-known/agent-card/{tenant}/{name}, signed with Ed25519 JWS, RBAC-filtered per caller.
• Streaming, full task lifecycle, push notifications — SSE token streaming, SUBMITTED → WORKING → COMPLETED state machine, push notification configs per task.
• HMAC-signed delegation chains with a policy-enforced depth cap — multi-hop agent calls carry signed provenance so spoofing is impossible, and delegation depth is capped per group and per card.
• Per-card rate limits — frequency caps enforceable per resource group and tenant-wide per agent card, so one chatty partner agent can’t exhaust your capacity.
• Same RBAC, cost ceilings, and audit as LLM traffic — no second control plane to operate. A2A spend attributes back to the calling team like any other gateway call.

See the A2A architecture diagram on the Agents page

Security baked in. Every request filtered. Every response checked.

• Built-in guardrails enabled by default — ML-based PII detection and masking, secrets detection, prompt-injection and jailbreak filtering, toxic-content and banned-word lists.
• Streaming output guarded too — choose buffered release or live interruption per config, so even token-by-token responses can’t leak what policy forbids.
• Semantic policies: govern by intent, in plain English — write a constraint in natural language (“must not exfiltrate customer PII”) and an LLM judge evaluates every governed request against it. Ship in shadow mode to measure, then flip to enforce.
• Argument policies — deterministic analyzers (SQL, URL, shell, path, JSON) inspect tool arguments before they execute: block the DELETE, allow the SELECT.
• Three-state HITL approval per tool, skill, and capability — enabled (runs immediately), approval-required (blocks pending human review), disabled (forbidden). One approval queue covers MCP tool calls and skill calls; same audit trail for human and agent callers alike.
• External guardrail providers — AWS Bedrock Guardrails, Lakera, Microsoft Presidio, OpenAI moderation, or bring your own endpoint — with most-restrictive-action-wins logic.
• Global or per-group application — different teams can have different security profiles.
• Guard every surface that runs through the gateway — LLM input and streaming output, embeddings, image, audio, batch, MCP tool calls, Skills, and A2A traffic.
• API key vault — provider credentials stored encrypted, rotatable, never exposed to client-side code.

Mirror your organization. Govern at every level.

• Hierarchical resource groups — organization → department → team → app → agent.
• Everything scoped to the group — AI models, MCP servers, Skills, Guardrails, Members, API keys, Limits, Governance.
• Resource inheritance — child groups inherit resources from parents unless set to standalone (additive).
• Governance inheritance — the effective policy is always the most restrictive value across the group and all its ancestors.
• Tenant-wide controls per resource — set limits and policies directly on a model, MCP server, or skill that apply across every group, merged most-restrictive with the group’s own rules.
• Agents are first-class members — give an agent its own identity anchored on your IdP, add it to groups like a user, and grant it per-action permissions (allow / deny / approval-required) with default-deny. Full story on the Agents page.
• Policy-as-code export. Export any resource group’s complete configuration as versioned policy-as-code. Edit, review, and re-apply a new version when the setup evolves.
• Per-group usage dashboards — requests, cost, and tokens with model-level and tool-level breakdown.
• 12+ RBAC roles with granular permissions — create custom roles for any access pattern.
• Two authentication paths — Gateway users (portal login) and API keys (agent/app access) kept separate.

Framework-tagged compliance evidence, generated automatically — from EU AI Act to ISO 42001.

• Complete audit trails — every admin action, AI interaction, and tool call logged with who, when, and what.
• Proxy logs with full request/response bodies — filterable by user, group, model, server, and date range.
• Drill-down from summary views to individual interaction detail.
• Policy-as-Code lifecycle — export any resource group’s complete configuration as versioned YAML; validate → dry-run → apply → rollback. Governance ships with your code instead of drifting in a wiki.
• ISO/IEC 42001 support — a first-class “AI System” object, Annex A control coverage with live auto-derived evidence, and a Statement of Applicability your auditor can actually read.
• AI Asset Registry with per-asset fact sheets — one inventory of every model, tool, skill, and agent, each with a live dossier of usage, guardrail events, and compliance activity. Snapshot it for immutable point-in-time audit evidence.
• EU AI Act Article 9 support — guardrails, resource groups, and access controls enforce risk-management policies as code.
• EU AI Act Article 12 support — traceability and automatic record-keeping with 6-month log retention.
• Framework-tagged evidence for HIPAA, SOC 2, and GDPR Article 30 — written the moment a control fires, on top of the data governance, access controls, and audit trails your compliance team needs.

Your fastest, cheapest LLM call is the one you never make.

• Two-layer caching — Redis for exact-match lookups, Qdrant vector store for semantic similarity matches.
• Semantic matching — recognizes when reworded prompts ask the same thing, not just byte-identical queries.
• Provider prompt caching managed too — per-provider prompt-cache capabilities tracked and configured centrally, so long system prompts get the provider-side discount where one exists.
• Per-resource-group isolation — one group’s answers never leak into another group’s responses.
• Configurable similarity thresholds per group — tune the trade-off between hit rate and answer precision.
• Configurable TTLs — from minutes for fast-moving data to days for stable reference content.
• Surfaced in Mission Control — cache hit rates, cost saved, and latency improvements visible in real time.

Stop runaway invoices. Then cut the bills that do remain.

• Per-group budget limits — daily dollar caps, token limits, request limits for both LLM and MCP.
• Real-time enforcement — exceed a limit and the next request is blocked (HTTP 429).
• Cost the AI you buy, not just the AI you build — import usage and spend from vendor consoles (Anthropic, OpenAI, Google, Microsoft) into the same dashboards, so closed-app AI spend finally sits next to gateway spend in one cross-vendor view.
• Batch processing support — route non-urgent workloads through provider batch APIs at up to 50% lower cost.
• Semantic cache — exact-match plus similarity caching across the AI surface. Same question worded differently? Cached response. Typically 20–40% off token spend.
• Smart model routing — route each call to the cheapest model that meets policy. Premium tiers reserved for queries that actually need them. Typically 30%+ savings.
• Usage dashboards at every level — organization-wide, per-team, per-model, per-tool.
• Cost attribution — see exactly which group, user, agent identity, or API key generated each cost.
• Webhook alerts for proactive budget management — send budget-threshold notifications to any endpoint you already monitor.

Real-time dashboards. Complete audit trails. Nothing hidden.

• Mission Control dashboard — dedicated Cost, Governance, Agents, Usage, and Reliability tabs: spend burn-down vs budgets, guardrail blocks and policy denials over time, per-agent activity, P99 latency, cache stats.
• Per-agent allow / block / shadow controls — the “agent kill-switch”: see what every agent is doing and stop one in a click, from the same screen.
• Governed and observed traffic side by side — filter every view by plane: traffic enforced inline by the gateway vs. vendor usage imported for visibility, including shadow-AI discovery signals.
• Infrastructure health — real-time status of every MCP server and AI model, reachable or not.
• LLM economics — token costs, average cost per request, model-level cost comparison.
• Alert system — usage-limit breaches, unhealthy models, with acknowledgement workflow.
• Bring your own observability stack — native OpenTelemetry hooks plug into Prometheus, Grafana, Loki, or any OTel-compatible backend you already run.