Skip to content

How Vidai works

Read this page first. It gives you the one picture the rest of the docs build on. With it in your head, any screen in the Control room makes sense, and you know where a rule belongs before you write it.

In one sentence: every AI call your organisation makes goes through the gateway, and the gateway decides it, sends it on and records it, by the rules you set once in the Control room.

flowchart LR
  subgraph org["Your organisation"]
    direction TB
    team["Teams and sub-teams"]
    person["People"]
    app["Applications"]
    agent["Agents"]
    team --- person
    app --- agent
  end
  subgraph env["Environments: production, staging, Default …"]
    key["Keys"]
  end
  person -- holds --> key
  agent -- holds --> key
  key -- "every call" --> gw
  gw{{"Gateway<br/>checks the key and the rules,<br/>sends the call, records it"}}
  gw --> prov["Providers and their models<br/>OpenAI, Azure, Anthropic, Bedrock,<br/>Gemini, Vertex, your own servers"]
  rules["Rules, set at levels<br/>organisation › environment › team › application › agent › key<br/>model access, guardrails, regions, routing, budgets, rate limits"] -. applied on every call .-> gw
  gw -. "every call priced and recorded" .-> proof["Request logs, cost, audit log, evidence"]

The call

  • A program calls a model with a key, using the SDK it already has (OpenAI, Anthropic or Gemini). The only change to the program is the base address and the key.
  • Every call goes through the gateway. The gateway checks the key and every rule that reaches it, sends the call to a provider, and records what happened.
  • The model's name is one your organisation chooses. An alias can stand for it, so the provider or the version behind the name can change without the program changing.
  • The answer comes back in the program's own SDK format, whatever provider served it, with headers that say which model really answered and the request id to quote.

See Keys, Model names and aliases and Translation between API formats.

Who is calling

  • A key belongs to a person, or to an agent inside an application. Agents are programs: they hold keys but never sign in.
  • Each key is issued in an environment (production, staging, the Default environment everyone starts with), so a test key can't run up production cost or reach production models.
  • People and applications sit in teams, inside your organisation. Teams mirror how the company is run: a department, a client account, a product.

See Organisation, teams and sub-teams, People and roles, Applications and agents and Environments.

What may happen

  • Rules are set at levels: the organisation, an environment, a team, an application, an agent, a key. A rule reaches every key below where it's set.
  • A lower level can tighten a rule, never loosen it. A team can allow fewer models than the organisation, never more.
  • The rules are of a few kinds, all decided in the request path, before the call reaches a model:
  • Rules are gathered into named policies, and a policy can serve a regulation you follow.
  • What applies here shows, for any key, person or team, every rule that reaches it and where it was set.

See Rules at levels and Policies and regulations.

Policies › What applies here for one key: every rule that reaches it, the level it was set at, and why it exists

What it cost, and who pays

  • Every call is priced from the rate card, at the price in force when the call was made, within minutes.
  • Cost lands on the team, application, agent and person behind the key, so Finance can bill from it.
  • Every call counts against the budgets that cover it. A budget can warn, stop calls or send them to a cheaper model.

See Prices and the rate card, Cost and Budgets.

What can be proved

  • Every call has a record in Request logs: who made it, which model answered, what every rule did, what it cost.
  • Every change and sign-in is in the audit log, tamper-evident.
  • With tamper evidence on, records are sealed and signed on both sides, and an auditor can check a report on their own machine.

A call's page in Request logs: who made it, the model asked for and the one that answered, what each rule did, and what it cost

See Request logs and the call record, Audit log and Tamper evidence.

What runs where

Behind it all are a few parts, all in your own infrastructure: the gateway that carries calls, the Control room where you set rules and read what happened, and the database they keep their records in. A change you make in the Control room reaches the gateway within seconds; a call through the gateway shows in Request logs within seconds, and cost totals and the dashboards count it within about two minutes. See The parts.

Where to go next