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:
- Model access: which models a team, environment or agent may call.
- Guardrails: what a call may contain; personal data masked, pseudonymised or blocked.
- Regions: where a call may be processed.
- Routing and fallback: where an allowed call goes, and what's tried if it fails.
- Budgets and rate limits: how much may be spent, and how fast.
- 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.

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.

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¶
- The words, defined once: Glossary.
- Why it's built this way: The problems we take on.
- One concept at a time: Concepts.