Videos

Brutor.AI Videos

Demos, walkthroughs, and explainers from the Brutor team. Click any tile to play.

Stand-alone Videos

Single demos and walkthroughs. Click a tile to play.

Getting started with the Brutor free trial
Getting Started

Getting started with the Brutor free trial

A quick walk-through of how to download and run the free Brutor.AI trial from trial.brutor.ai — self-host the full platform in your own environment and start governing AI. No credit card needed.

Watch
Brutor AI Platform — Deep-dive for Admins
Product Overview

Brutor AI Platform — Deep-dive for Admins

End-to-end walkthrough of the Brutor AI Platform from the admin console to the User Portal — providers, MCP servers, agent skills, knowledge bases, A2A, guardrails, caching, policy-as-code, RBAC, resource groups, API access, and Mission Control.

Watch
Managing AI Models
Admin How-To

Managing AI Models

How AI models are managed in the admin console: connect providers, add models from the built-in catalog, set API keys, tune defaults, and assign each model to the resource groups whose teams should reach it — the foundation every other governance control builds on.

Watch
Working with MCP Servers
Admin How-To

Working with MCP Servers

Bring tool servers under governance: register an MCP server through the gateway, discover its tools, prompts and resources, bind it to resource groups, and control which capabilities each team can call — then use the tools from the User Portal chat.

Watch

Playlists

Multi-part series that walk a theme end to end. Click a series to see its parts — watch in any order.

6 parts

LLM Governance with Brutor

One OpenAI-compatible API in front of every LLM, MCP, A2A and Skill call your apps and agents make — with guardrails, budgets, RBAC, policy-as-code, a compliance audit trail, cross-vendor cost observability, and out-of-band shadow-AI discovery. Each part walks one capability end to end on a live gateway.

LLM Governance with Brutor — Part 1: Safety & Guardrails
LLM Governance · Part 1

Safety & Guardrails

Prompt injection, PII and secrets — stopped at the gateway. A clean prompt hits the semantic cache, an injection attempt is blocked, PII is redacted on output, secrets are caught, and an LLM-judged semantic policy catches intent the pattern rules miss — every event tagged to your compliance frameworks.

Watch
LLM Governance with Brutor — Part 2: Cost & Limits
LLM Governance · Part 2

Cost & Limits

Make AI spend predictable. Token budgets, per-minute request and token throughput caps, and daily quotas — enforced per team and per model — plus a semantic response cache that turns repeat questions into near-instant, near-free hits. Hit a cap and the gateway refuses the call instead of paying for it.

Watch
LLM Governance with Brutor — Part 3: Access & Resilience
LLM Governance · Part 3

Access & Resilience

Access that’s structural, and uptime that survives a provider outage. Resource-group RBAC (each team reaches only its own models, refused by name), weighted model routing groups, and automatic failover: when the primary returns a 401 the router retries a secondary and the user never notices — both legs on the audit trail.

Watch
LLM Governance with Brutor — Part 4: Govern & Prove
LLM Governance · Part 4

Govern & Prove

Where enforcement becomes evidence. An argument policy denies a destructive SQL tool call, then the policy-as-code lifecycle (export → dry-run → promote a versioned bundle), a compliance dashboard where every call is tagged at write-time (EU AI Act, SOC 2), and the AI Asset Registry fact sheet — one asset’s full governance record.

Watch
LLM Governance with Brutor — Part 5: Observe What You Can't Govern
LLM Governance · Part 5

Observe What You Can’t Govern

The honest boundary. Your people use Claude Desktop, ChatGPT and Gemini on company accounts — traffic no gateway is in the path of. Part 5 imports that usage and cost from the vendor’s analytics API into one ledger: flip Mission Control’s Governed / Observed / All plane and the totals span the whole estate, per product and per person.

Watch
LLM Governance with Brutor — Part 6: Discover Shadow AI
LLM Governance · Part 6

Discover Shadow AI

Find the AI nobody sanctioned. The Shadow AI Discovery SDK: out-of-band collectors and ingest adapters (CycloneDX AI-BOM, Snyk agent-scan / mcp-scan, AgentSonar, SafeDep vet) emit Ed25519-signed discovery events. The platform reconciles each against its route table, flags ungoverned endpoints and agent stacks, then onboards one into governance in a click.

Watch
3 parts

MCP Governance with Brutor

Governing the tool layer: one live MCP server, six tools — filtered per team, argument-checked by real parsers, redacted, rate-limited, approval-gated, intent-judged by an LLM, and fully audited. Three parts, from the everyday golden path to the control room.

MCP Governance with Brutor — Part 1: Golden Path & Guardrails
MCP Governance · Part 1

Golden Path & Guardrails

One server, six tools — filtered per team at the gateway, not in the client. The golden path returns real rows; a destructive DELETE is parsed by a real SQL analyzer and refused even after the user approves it; and a customer record comes back with PII redacted by Microsoft Presidio and leaked credentials masked — every call one audit row.

Watch
MCP Governance with Brutor — Part 2: Access & Limits
MCP Governance · Part 2

Access & Limits

Who can call which tool, how often — and which calls need a human. Per-team capability filters, a gateway-held approval for send_email (one-shot token; a replay is refused), a per-tool rate limit that refuses the third expensive report of the hour, SSRF protection on fetch_url, and a shell-parser command allowlist on the Ops host.

Watch
MCP Governance with Brutor — Part 3: Govern & Observe
MCP Governance · Part 3

Govern & Observe

Beyond structure: what comes back, and what a call means. Category-aware secrets detection blocks a tool result leaking a GitHub token and an AWS key; an LLM-judge semantic policy blocks a comment-injection the AST parser waves through; Mission Control counts every block on the governance ledger; and the AI Asset Registry plus compliance tagging turn it into auditor evidence.

Watch
4 parts

Agent Skills Governance with Brutor

Agent Skills are reusable, versioned units of work — a SKILL.md prompt plus a sandboxed script — that the gateway hosts, runs, and exposes to agents as governed tools. Four parts: an introduction to the architecture and runtime; a gentle Hello World where an end user simply asks in chat and the AI discovers, loads and runs the skill; then setup and guardrails; then argument policies, per-skill quotas and human approval.

Agent Skills Governance with Brutor — Introduction: Architecture & Runtime
Agent Skills Governance · Intro

Introduction: Architecture & Runtime

What an Agent Skill is, and how Brutor governs it. A skill is a SKILL.md prompt plus a sandboxed script — hosted by the gateway and exposed to agents as a system MCP tool, so the same guardrails, policies and audit trail that govern LLM and MCP calls govern skills too. Covers the two hosting models (upload a package, or sync from GitHub), how a skill executes in the runner, and where each control sits.

Watch
Agent Skills Governance with Brutor — Part 1: Hello World
Agent Skills Governance · Part 1

Hello World

The gentlest possible start. Publish a skill and assign it to a workspace, then a Sales rep simply asks the portal chat for a greeting — and the AI works through progressive disclosure: it discovers the skill, loads its instructions, runs the sandboxed script to gather system information, and renders the greeting template. The rep never sees a tool or a script, and every step is a separate, access-scoped, audited call.

Watch
Agent Skills Governance with Brutor — Part 2: Setup & Guardrails
Agent Skills Governance · Part 2

Setup & Guardrails

Configure a skill, decide who can run it, then watch the gateway govern every call. Config-first: the skill catalog, binding skills to a resource group with keys and members, and the guardrails and argument policy bound to that group. Then live — a read-only report runs (202, async, audited); the same call from a team without access is denied; PII in a skill’s input is blocked before the sandbox runs; and PII in its output is redacted. Every outcome a full audit row.

Watch
Agent Skills Governance with Brutor — Part 3: Policy, Limits & Approval
Agent Skills Governance · Part 3

Policy, Limits & Approval

The deeper controls, enforced live. An argument policy parses a skill’s SQL input into a syntax tree and refuses a destructive write with the exact rule that fired; a per-skill daily execution quota returns a clean 403 on the run past the cap; and a high-blast-radius skill is parked as PENDING until a human approves, with a one-shot token that releases exactly one execution — each refusal on the record and tagged to your compliance frameworks.

Watch
5 videos

Agent Governance with Brutor

The finale, where the model, tool and skill stories come together. One example agent system — the ACME Revenue Copilot — modelled as an AI System (an ISO 42001 AI system; in Brutor a resource group of type ai_system) that owns every resource it uses. An introduction sets up the system and the concepts, then four standalone demos govern it: the AI System itself, identity & authorization, the A2A network, and observability.

Agent Governance with Brutor — Introduction: The AI System
Agent Governance · Intro

Introduction: The AI System

Where the model, tool and skill series come together: an agent is all of those at once, acting on its own — an AI System in the ISO 42001 sense. Meet the example ACME Revenue Copilot with a full architecture diagram, then the core concepts: identity vs. signed cards, allow / deny / approval authorization layered with an LLM-judged intent policy, and the governed agent-to-agent network.

Watch
Agent Governance with Brutor — Part 1: AI Systems
Agent Governance · Part 1

AI Systems

One agent system, one AI-System resource group that owns every resource it uses — the reasoning model, the MCP tool server and the Agent Skills system server that runs skills as tools, a published skill, the agent identity and its peer cards. The key distinction, made explicit: an identity is the caller; a card is a signed listing of a callee — all access-controlled to the one system, with its guardrails and policies attached.

Watch
Agent Governance with Brutor — Part 2: Identity & Authorization
Agent Governance · Part 2

Identity & Authorization

Give every agent an identity, then authorize what it may do. Open the Data Export Worker — a machine principal with a SPIFFE workload subject and a default-deny baseline — and read its grants like a sentence. On the wire: an ungranted tool is refused 403 before it runs, an approval-required tool parks at 202 with a poll URL, and the granted call just works — each an audit row carrying the identity, the decision and the grant.

Watch
Agent Governance with Brutor — Part 3: The Network (A2A)
Agent Governance · Part 3

The Network (A2A)

Agents calling agents, safely. Signed Ed25519 cards verified against a published key, per-system access (an outside key is refused), guardrails both ways (inbound PII blocked at the door, outbound redacted on the wire), a per-AI-System egress policy that denies a PII-classified capability outright, and a cryptographic delegation chain with a depth cap that refuses a forged hop — every call on the audit log.

Watch
Agent Governance with Brutor — Part 4: Observability
Agent Governance · Part 4

Observability

You can’t govern what you can’t see. The AI Asset Registry now inventories the whole picture — models, MCP servers, skills and cards, and the AI System and agent principals themselves — each with a one-page fact sheet. Mission Control counts every guardrail block, the AI System’s own Usage tab rolls up every surface into one combined view, and delegation graphs reconstruct each multi-agent workflow as a named, signed tree.

Watch
7 videos

AI Systems Assurance with Brutor

Getting an agent into production is the easy part. Being allowed to leave it there is the hard part. This series is about the lifecycle of a deployed AI System — what it actually did, whether it is still alive, whether its behaviour has drifted and why, what it was allowed to do and who signed it off, and whether a change is safe to ship. The introduction assumes long IT experience and no AI background; the six demos each prove one guarantee on a live agent system.

AI Systems Assurance with Brutor — Introduction: Can You Leave It Running?
AI Systems Assurance · Intro

Introduction: Can You Leave It Running?

Written for people who have run IT systems for years and are new to the AI stack. Five terms that carry everything (and why you cannot assertEquals an LLM), why deterministic-era monitoring misses AI failures — every dashboard green while an agent loops, a provider updates the model under you, or a scheduled system goes silent — and the four guarantees: bounded, alive, non-drifting, doing its job. Every mechanism has an ancestor you already trust.

Watch
AI Systems Assurance with Brutor — Part 1: The Run Ledger
AI Systems Assurance · Part 1

The Run Ledger

A run is an end-to-end task, not a request. Fourteen model calls and six tool calls to answer one billing question is one job — and that is the unit that matters. Runs assembled from the signed call chain with no instrumentation in the agent, honest terminal states (a policy block is governance, not failure), and the number nobody else can compute: cost per task the system actually finished.

Watch
AI Systems Assurance with Brutor — Part 2: Liveness
AI Systems Assurance · Part 2

Liveness

The only signal that fires on the absence of traffic. A system that stops calling is invisible to every request-driven dashboard — zero errors, because zero traffic. Set an expectation, let Brutor learn the real cadence from history (sized on the p95 gap, so occasional long pauses do not page anyone), and walk the detectors: silence, missed schedule, volume collapse, stall, hard-fail cliff — with strict anti-noise rules.

Watch
AI Systems Assurance with Brutor — Part 3: Drift with a Cause
AI Systems Assurance · Part 3

Drift with a Cause

Detecting change is table stakes; naming the cause is the product. Brutor learns what normal looks like from each system’s own history — robust statistics, sustained-change requirements, and no alerts at all while a system is still learning. When behaviour moves, the finding leads with the likely reason (the provider shipped a point release at 13:52) and terminates honestly at unexplained. Severity ranks by consequence, not p-value.

Watch
AI Systems Assurance with Brutor — Part 4: Contracts & the Gate
AI Systems Assurance · Part 4

Contracts & the Gate

Enforcement was never the gap — proof was. A contract is a hash-pinned, versioned snapshot of every control that applies to a system, generated from the resolved live configuration (never hand-authored) and stamped on every run. Versions are append-only, the diff separates widened from narrowed permissions, and the lifecycle stage becomes a gate that shows its evidence checklist before you click, not a red toast after.

Watch
AI Systems Assurance with Brutor — Part 5: Replay & the Closed Loop
AI Systems Assurance · Part 5

Replay & the Closed Loop

Your audit log is an eval dataset. Replay freezes a stratified, rarest-first suite from real recorded runs and re-evaluates every hop’s authorization under a candidate configuration — dispatching nothing, so it cannot call a tool or spend a token. Then the closed loop: a response policy that tightens autonomy automatically on drift, with the blast radius shown before you arm it and restore always human.

Watch
AI Systems Assurance with Brutor — Part 6: Health & the Assurance Report
AI Systems Assurance · Part 6

Health & the Assurance Report

One number, worst-of, always decomposable: health is the minimum of liveness, behaviour, reliability, cost and conformance — because a cheap, fast, dead system is not 80 % healthy, and unknown is never green. Conformance compares declared intent against observed traffic. And the Assurance Report collects all four guarantees into one immutable artifact, ending with what it does not cover — which is why an auditor believes the rest.

Watch
/start the conversation/

AI is everywhere in your organization — your control over it will be too.

Download the free trial, or book a 30-minute demo with our team.

Scroll to Top