Control Revit with Natural Language | Plain-English Revit Automation

Short answer: To control Revit with natural language, you describe the outcome you want in plain English and an AI agent translates it into a real Revit API operation that runs under your supervision. Archi Automate makes this practical for Autodesk® Revit® by connecting an AI client to the live model through the Model Context Protocol, composing the operation as C#, previewing it in a dry-run diff, and executing approved changes inside a managed transaction with a full audit log.

Most Revit work is repetitive enough to feel mechanical and varied enough to resist a fixed button. You know exactly what you want, the API can do it, but writing a one-off Dynamo graph or macro for a task you will run twice is rarely worth the time. Natural-language control closes that gap: you state the goal, the AI works out the mechanics, and you stay in charge of what actually gets written back to the model.

This article explains what that really means in practice, where it helps, what it looks like prompt by prompt, and, just as importantly, where it should stop short of acting on its own.

What it means to control Revit with natural language

There is no magic here, and pretending otherwise would do you a disservice. Controlling Revit with natural language is a chain of discrete, inspectable steps, not a single mysterious leap from sentence to result.

The flow looks like this: plain-English request -> AI interpretation -> controlled tool call -> Revit action. You type a request. The AI reads it, then inspects the live model to understand what it is dealing with. It composes a specific operation against the Revit API. That operation is checked against your active policy. Only then does anything touch the model, and only inside a transaction that can roll back cleanly.

The transport that makes the inspection possible matters. Archi Automate uses the Model Context Protocol, an open and swappable standard, so the AI client can ask the live model real questions before it proposes anything. If you want the detail behind that layer, see MCP for Revit. The point for now is that the AI is not guessing about your model from a screenshot. It is reading actual elements, parameters, and relationships.

So "talk to Revit" is accurate as a description of the experience and misleading as a description of the mechanism. You are talking to an AI agent that holds a live, structured conversation with your model on your behalf and then acts through a governed bridge.

Why plain-English commands are useful

The value is not novelty. It is friction removed from work you already do.

It removes the translation tax. Today, turning an intent like "find every door without a fire rating" into a result means either clicking through schedules and filters by hand or writing code. Natural language lets you skip straight from intent to a proposed operation.

It opens automation to non-programmers. A strong BIM coordinator who has never written C# still understands the model deeply. Plain-English Revit commands let that knowledge drive automation without a scripting layer in between. Dynamo, pyRevit, and macros remain excellent for known, repeatable workflows, and you should keep using them. Natural language covers the long tail those scripts never get written for.

It is fast for exploratory and one-off work. Audits, sanity checks, "how many of these do we actually have" questions, and multi-step tasks you will run once benefit most. The cost of writing a script you will discard immediately disappears.

It handles variable work gracefully. When every project numbers rooms differently or each consultant sends a slightly different spreadsheet, a rigid script breaks. A described outcome adapts, because the AI inspects the actual situation each time rather than assuming a fixed shape.

Example prompts: read, audit, and write

The clearest way to understand the range is to see real requests. These are grouped by how much they touch the model, from pure inspection through to changes that write back.

Read and inspect (no changes)

• "How many habitable rooms are on Level 03, and what is the smallest one by floor area?"
• "List every wall type used in the model and the total length of each."
• "Show me which views are placed on more than one sheet."
• "What shared parameters are attached to the mechanical equipment category?"

These run in read-only mode. The bridge refuses every write, opens no transactions, and is safe to point at a federated or review model.

Audit and report

• "Find all doors missing fire rating values and list them by level."
• "Cross-check every habitable room on Level 03 against TEK17 §12 daylight, ventilation and ceiling-height rules and produce a punch list."
• "Flag any rooms that are unbounded or have a zero area."
• "Compare the room names in the model against this consultant Excel and tell me what does not match."

Audits are where natural language earns its keep daily. The AI inspects the model, applies the rule, and hands you a list to act on. It reports; it does not silently fix.

Write and edit (executes under review)

• "Renumber every room across 14 floors using the new tower-naming convention."
• "Take this consultant Excel of equipment loads, match each row to the corresponding electrical fixture and write the wattage onto the matching shared parameter."
• "For every unique exterior wall plane on the tower, create an elevation view, apply the standard view-template, and place it on a new sheet at 1:50."
• "Set the fire rating to 60 minutes on every door in the corridor walls on this level."

Write operations are exactly where review matters most, which is the subject of the next two sections. For a broader catalogue of what these tasks look like at scale, see our overview of Revit automation.

What happens after you send a prompt

Understanding the sequence is what makes natural-language control trustworthy rather than unnerving. Here is the full path from your sentence to a logged result.

1. Parse intent. The AI reads your request and identifies the target elements, the operation, and any constraints you stated.
2. Inspect the model. Through the MCP connection, it queries the live model for the actual elements, parameters, and relationships involved, rather than assuming.
3. Ask a clarifying question if needed. If your request is ambiguous, for example which level "the corridor" refers to, it asks before acting. Guessing on a write is exactly what you do not want.
4. Compose and screen the operation. The bridge generates the required Revit API call as C# and screens that snippet against a configurable pattern-based deny-list before anything runs.
5. Preview in dry-run. Execution stops at a per-element diff. You see precisely what would change, element by element, and you can approve, edit, or discard it. The diff is exportable to JSONL.
6. Execute inside a transaction. Approved changes run inside a managed Revit transaction with automatic rollback on any exception, under enforced timeout and API constraints.
7. Log the result. Every session writes to a per-session JSONL audit log that is replayable for incident review.

The execution mode is yours to set. The three modes map cleanly onto how much trust a task deserves.

Governance is set at the hub level with per-role modes, so architects might stay read-only, BIM leads work in dry-run, and a project director holds unrestricted rights, with scope limits and deletion rules attached. The condensed version of the architecture is: AI client -> Model Context Protocol -> Archi Automate bridge -> Revit transaction. Each hop is inspectable, and each can be constrained by policy.

What should not be fully autonomous

This is the section that separates a credible tool from a reckless one. Some things should never run without a human deciding, and the design reflects that.

• Destructive changes. Deleting elements, purging types, or anything not cleanly reversible deserves an explicit human approval through the dry-run diff, not a silent batch run.
• Large batch edits. A change spanning thousands of elements should be previewed and approved deliberately. The diff exists precisely so a sweeping edit does not surprise you.
• Code-compliance claims. The AI can cross-check a model against a rule set such as TEK17 or IBC and produce a punch list, and that is genuinely useful. It does not certify compliance. A qualified professional signs off on code, always.
• Anything needing professional judgment. Design intent, structural decisions, and life-safety calls belong to people. The tool surfaces information and executes mechanical operations you have approved; it does not replace the judgment of a BIM manager or engineer.

The honest framing is simple: treat natural-language control as a fast, well-supervised assistant, not as autopilot. The dry-run diff, the audit log, the deny-list, and the automatic rollback all exist so that a human stays in the loop on anything that matters. Used that way, it is dependable on live projects. Used as blind automation of irreversible changes, no tool is.

Seeing the workflow in practice

Reading about a per-element diff conveys less than watching one populate as the AI inspects a model and proposes a change. The rhythm is easiest to grasp end to end: a request, a dry-run preview you read line by line, your approval, and a logged result. Archi Automate hosts that workflow in a small desktop console that sits next to Revit, with three screens — a Dashboard for connection, license, AI clients, and Revit sessions; Guardrails for execution mode, safety limits, the activity log, and the raw policy file; and Connect your AI for the configuration snippets. You can see how the pieces fit together on the AI automation for Revit page.

Where Archi Automate fits

Archi Automate is the bridge that turns plain-English requests into governed Revit operations. It connects any MCP-compatible AI client, including Claude and ChatGPT, to Autodesk Revit 2025, 2026, and 2027 on Windows 10 and 11, with multiple Revit sessions supported.

What makes it a bridge rather than a fixed-command tool is that it composes operations across the whole Revit API surface on demand, subject to policy, instead of offering you a menu of pre-built buttons. Because the inputs are whatever your AI client can read, a site photo, an annotated PDF markup, a consultant Excel, or a building-code database can all become a Revit instruction. You can also package your studio's expertise as modular skills — office naming conventions, view-template libraries, building-typology rules, or regulation packs — and the AI combines them with the live model. As the underlying language models improve, the same bridge inherits the upgrade with no migration on your side.

FAQ

Can you really control Revit by typing plain English?

Yes. You type the outcome you want and an AI agent inspects the live model, composes the matching Revit API operation, and runs it under your chosen execution mode. The plain English is real; the work behind it is a concrete, inspectable Revit API call.

Does the AI change my model automatically?

Only if you let it. In read-only mode it cannot write at all. In dry-run mode it stops at a per-element diff for your approval. Only in unrestricted mode do approved changes run, and even then inside a managed transaction with automatic rollback on error.

What happens if the AI misunderstands a command?

If a request is ambiguous it asks a clarifying question before acting. If it composes the wrong operation, you see exactly what it intends in the dry-run diff and can edit or discard it before anything runs. Should an error occur during execution, the transaction rolls back automatically.

Do I need to know the Revit API?

No. The bridge composes the Revit API operation as C# for you. You describe the outcome in plain language. Knowing the API helps you read the proposed operation, but it is not required to use the tool.

Is natural-language Revit control safe on live projects?

It is, when used with review. Every composed snippet is screened against a deny-list, every session is logged to a replayable JSONL audit file, writes run in transactions that roll back on error, and hub-level policy sets per-role permissions. Destructive or large changes should always pass through the dry-run diff and a human decision.

Try it on your own model

The fastest way to understand natural-language Revit control is to point it at a model you know and watch the dry-run. Try Archi Automate for Revit and run a few read-only prompts before you ever enable a write.

Related guides

Continue building out your AI-for-Revit workflow with Archi Automate for Revit and these related guides:

• MCP for Revit
• Revit automation with AI
• AI agent for Revit
• Revit parameter automation

Archi Automate is an independent product by Archi Systems for use with Autodesk® Revit®. It is not affiliated with, endorsed by, sponsored by, or approved by Autodesk.