Skip to content

Agents, tooling & delegation

VitruAI runs on agents — AI workers with a brief and a set of tools. Your firm starts with two built-in agents, you can add discipline specialists and your own custom agents, and the Coordinator delegates work to specialists in parallel through Orbit.

The built-in agents

Every firm is provisioned with two agents at creation:

QAQC Coordinator

The agent you talk to for verification. It's shared with every member. The Coordinator:

  • Scopes your request (a full sweep vs. specific elements).
  • Decides which disciplines and rules apply.
  • Spawns discipline specialists in parallel (see Delegation with Orbit) and collects their findings.
  • Assembles a single, decisive report.

It doesn't run rules itself — it orchestrates. It can read the model to resolve specific elements for targeted checks.

The Setup agent

The maintainer's agent, shared with owners and admins. It's how you shape what VitruAI checks and how. On first run it offers four starting points:

  • "Refine our firm's QA constitution" — shape your firm-wide QA principles.
  • "Set up a project from my open BIM model" — read the open model and scaffold a project.
  • "Add discipline specialist agents" — create Structural, MEP, and other specialists.
  • "Author the QA rules for this project" — write, validate, and promote rules.

The Setup agent can do things ordinary chat can't: create projects, create discipline specialists, and author/compile rules. See Authoring checks and Working with workspaces.

Spinning up agents

There are two ways new agents come into being:

1. Discipline specialists (via the Setup agent) — recommended. Ask the Setup agent to "add a Structural specialist" (or MEP, façade, accessibility, …). It creates the agent, grants your firm access, wires it into the workspace roster, and seeds a starter brief you can refine. Specialists are pre-scoped to their discipline's rules, so the Coordinator can route discipline-specific checks to them automatically.

2. Custom agents (via the agent builder). In the app you can build an agent directly: give it a name, instructions (its brief), a model, conversation starters, and the tools / MCP servers it may use. Creating and sharing agents is an admin-gated capability. This is the path for bespoke helpers beyond the standard discipline specialists.

Agent tooling

Tools are what let an agent do things rather than just talk. Each agent is granted a specific set, so a specialist can read the model and run rules but can't, say, author new ones. The catalog agents draw from:

Tool group What it does Examples
Read the Revit model Inspect the active document without changing it active document & links, elements by category, parameter values, geometry & bounding boxes, rooms/spatial elements, stairs & railings, clearances/intersections, sheet names
Run rules Compile and execute checks compile_csharp (safety-check + compile a rule), execute_compiled (run a freshly compiled draft), execute_rule (run a stored rule by id)
Reports Persist results save a completed run to the reports database
Workspace Read/write the firm's files read rules & constitutions; (Setup) write and commit changes
Orbit Delegate to sub-agents spawn an agent, send it a message, list spawns (see below)
Setup-only Governance create a project, create a discipline specialist

Under the hood these come from VitruAI's connected services — a Revit service (model reading + rule compile/run, via your connected device), a Reports service, and a verification helper. Tool access is scoped per agent: the Coordinator gets delegation + read + reporting; specialists get read + run-rules + reporting; the Setup agent adds rule authoring and the create-project / create-specialist tools.

Tools are read-only against your model

No agent tool can modify your Revit model. Model access is strictly read; rule code is safety-checked to forbid mutations, file, network, and process access. See Authoring checks.

Delegation with Orbit

Orbit is VitruAI's delegation layer. Rather than one agent doing everything in a single long thread, the Coordinator spawns specialist sub-agents that run in parallel, each with its own fresh context — which is faster and keeps each agent focused on its discipline.

How it works:

  1. You send one request to the Coordinator (e.g. "Run a full QA sweep on this model.").
  2. The Coordinator spawns the relevant specialists — they start immediately and run concurrently, each in its own context window.
  3. Each specialist works independently (reading the model, running its rules) and, when done, sends its findings back.
  4. The Coordinator is re-engaged automatically as results arrive — no action from you — and synthesizes them into the final report.

You don't click "spawn." Delegation is the agent's decision: the Coordinator spawns when the work benefits from it. In the chat you'll see:

  • A spawn card for each sub-agent, with its status (queued → running → done) and a live preview.
  • Click a card to open its full transcript — the specialist's tool calls and reasoning.
  • A timeline of events (started, messages, finalized, errored) beneath each card.
  • The Coordinator's synthesized response once specialists finish.

Good to know

  • Parallelism is the point — several specialists run at once, so a multi-discipline sweep doesn't serialize.
  • Context efficiency — each spawn has its own context, so a big check doesn't bloat one thread. (See Tips for success.)
  • Resilience — a specialist that errors or is stopped doesn't take down the others; the Coordinator reports what it got.
  • Status updates currently refresh every couple of seconds while a spawn runs.

See also