A custom Revit automation
suite, built tool by tool

"Touches the model" is the tool's own rule from its readme: a scan never writes; a commit is one named, undoable Revit transaction; the five read-only tools cannot change a model at all.

The full surface — 143 tools by channel, the three gates, the two transports, the Navisworks half and the harness numbers — is in the MCP layer reference, which also lists the other servers.

• Cover-Sheet Audit: One read-only RUN AUDIT runs every audited station once and fills the KPI band, the readiness donut and a twelve-row register — station, governing standard, issue count, status — whose rows deep-link to their station. Nothing is written to the model, and Export compliance report writes an eight-sheet workbook beside the model. Queue pills stage the fixes; one click commits every queued domain in order.
• Links: Worksets, Load State And Display new: Link Worksets routes every Revit, CAD and Navisworks link to its discipline’s workset, read from the folder tree, and creates only the worksets that are missing. Link Paths lists every link type with its loaded state, cloud links included, loads or unloads the checked rows for you alone or for everyone, and sets a link’s display to Custom in the ticked views by driving Revit’s own Visibility/Graphics dialog, which no API reaches. Every outcome is measured after the write, never assumed.
• Guarded Project Info: Reads/writes only standard built-in ProjectInfo fields with an IFD requirement reminder. Protects document health while you edit.
• Elevation-Safe Level Swap: Re-hosts elements to a new reference level while computing a delta offset so nothing physically moves. Re-level a model without breaking geometry.

• Six Governed Stages: Cleanup, CMMN, SPEC, Flags, Classification and Worksets run in sequence — sealing connectors, removing duplicate runs, writing standard parameters, classifying for IFC export, and routing worksets. Collapses a full day of manual coordination into one governed pass.
• Geometry-Driven Parameters: Populates project custom parameters straight from model geometry and editable mapping tables (spec_mappings.json), edited in-window on the Settings page — no raw JSON. No typing, no transcription errors.
• Scan → Apply, One Resolver: Each stage previews as a click-to-isolate grid before it writes; preview and run share one function so they can never disagree, and a live Model Health score summarizes the result. Nothing touches the model until you approve it.
• Tag Audit With Auto-Tag, And A Warning Drill-Down new: Tag Audit and Dim Coverage take a scope — the active view, the views on sheets, or every graphical view — and aggregate per view, deduplicating the elements that need a tag. Below the indicator rows, tick the untagged categories and Tag selected places one tag per element per view as ordinary undoable transactions, skipping elements another user has checked out. Model Health now lists every Revit warning type with its count and a Select button that puts the affected elements into the selection. The audit names the gap, then closes it — without leaving the window.

# Scan and Apply share one resolver — preview can never disagree with the run.
for stage in stages:                            # Cleanup · CMMN · SPEC · Flags · Classification · Worksets
    with revit.Transaction(stage.name, doc):    # each stage, one guarded tx
        stage.apply(doc, approved_elements)     # only what the review grid approved
health.score(results)                           # live Model Health — no TaskDialog

Illustrative — the workflow shape, not the internal phase logic.

# Each repair is isolated; a rule that doesn't clear the clash is undone.
with SubTransaction(doc) as st:
    st.Start()
    apply_fix(candidate)
    doc.Regenerate()
    st.Commit() if clash_cleared(candidate) else st.RollBack()

Illustrative — the guard pattern shared across the repair stations.

• Reads The Whole Model First: Scan lists every group type with its instances, the elements inside, nested and attached groups, pinned and borrowed instances and the text notes they hold. Badges say what the current options do to each type: how many open, stay whole, are skipped or belong to someone else.
• Nested, Pinned And Borrowed, Each By Rule: A nested group opens level by level until nothing is left grouped, or comes out of its parent whole. A pinned group is skipped, and a group another user owns is always skipped and named. An attached detail group goes with its model group, whatever the Detail groups switch says.
• Nothing Written Before You Confirm: The dialog says how many groups of how many types open, how many elements come out, what is skipped and why, and which types will be deleted. The commit is verified, and the empty shell Revit leaves behind after a group opens is removed, so the Project Browser stops counting it. Ctrl+Z undoes the whole thing in one step.
• Measured On A Plant Room: On a cloud-workshared Revit 2025 model, 393 model groups of 59 types holding 89,275 elements opened in just under three minutes, with the 59 emptied types deleted and 849 detail groups untouched. About half of that time is the ownership check with the central.

cfg  = load_json("fitting_config.json")  # offset + param names are DATA
x, y = world_xy(elem, cfg["offset_mm"])  # editable per project, not baked in
if is_empty(elem, cfg["param_x"]):       # overwrite guard: keep existing values
    write(elem, cfg["param_x"], meters(x))

Illustrative — every FIT page reads its defaults from JSON like this.

• Length-Preserving Disallow: Disallowing a join normally regrows the beam past its neighbour; SFX measures the regrowth and cancels it in the Start/End Extension parameters, so the physical faces never move and schedules keep the real lengths. Fabrication-true geometry, no manual retrimming.
• Deterministic Node Resolution: Ex-miter residual nodes get a deterministic primary/butt re-resolution, optional cope stripping, and a one-way location realign that snaps the line onto the physical length with extensions zeroed — faces unmoved. The same input always yields the same joint scheme.
• Scan → Review → Apply → Reverse: Dry-count scan first, a KPI band and a review grid with status pills and reason groups (drift, residual, skip) — pivotable by status, family or joint — XLSX export for the record, and a Re-Allow pass that reverses the whole operation under the extension-zeroing contract. Fully auditable; reversible except the one-way realign and the permanent cope strip.

• Sees What Revit Cannot: Against this model the check is Revit's own ElementIntersectsElementFilter; against a Revit link, each element's solids go through the inverse link transform into the link — still Revit's own intersection, narrowed by a box taken from the tested solids and confirmed by intersect volume, after the filter alone had reported exact rows with no common volume. Against a coordination model the geometry is read through the Navisworks API out of process (the Navisworks API is .NET Framework 4.8 and cannot load inside Revit), bounded to the envelope of everything in scope plus the clearance, and cached per envelope — the first run of a file is slow, the next is not. A result the coordinator can reproduce in Revit's own dialog is worth more than a cleverer one they cannot.
• Exact And Approximate, Said Out Loud: A hard clash against this model or a Revit link is proven with real solids. Against a coordination model it is your solid against the reader's box — and clearance is box-to-box on every source, because a true solid distance is a different computation and a box gap reported as a solid gap is a lie told in millimetres. Every row records which it was, and the export carries the column. A result set that mixes exact and approximate findings without saying so is worse than one that finds less.
• An Empty Coordination Model Is Named, Never Clean: Three different absences give the same empty result — the document links no coordination model, the file is a Desktop Connector placeholder that was never downloaded, or Navisworks Manage / Simulate is not installed on this machine — so the tool names each one as a warning that opens the log. An NWC sits in whichever frame it was exported in, so each file's offset is measured from this model's own elements inside it; when the references disagree beyond tolerance nothing is shifted and the log says so. A clean run and a run that checked nothing never look the same.
• New, Gone, Or Unchanged Since Last Time: From the second run with the same configuration — same scope, categories, mode, sources and coordination-file picks — every row carries a delta badge. Gone rows are kept at the bottom, dimmed because they have no live geometry, and click through to the A element if it still exists. Up to three previous run digests are kept per document and configuration, compact enough to be nothing more than ids, kind, source and centroid. The coordinator learns whether the backlog moved, not just how long it is.

• Measured, Not Calculated: The shared-coordinate mapping is derived from Revit itself — the internal origin and both horizontal axes are pushed through GetProjectPosition and the mapping is inverted from those three answers, so no assumption about the rotation's sign or order can be wrong. It is then proved: a probe point round-trips through the mapping and the tool refuses to place anything if it does not return where it started. A mapping that is slightly wrong puts markers inside the building in the wrong place, which reads exactly like success — refusing is the only honest answer.
• Five Report Formats, Detected By Content: Navisworks XML and HTML, CSV / delimited text, Excel (the sheet chosen by content, so a cover sheet does not break it) and BCF 2.x / 3.0 — the format is read from the file's content, never its extension. Units are never guessed: a report that declares none refuses rather than assuming metres. The difference between metres and millimetres is a factor of a thousand.
• Markers That Remember Their Clash: Each marker carries a short state token — in Comments by default, alongside whatever was already written there — naming the clash it came from and whether it is done. Stored on the element, it travels with the model and survives a workshared round trip. A re-import reconciles to New / Placed / Completed / Ignored / Not in report; for a BCF source the completed topics can be written back to a new archive. Import on Monday, fix sixty during the week, re-run on Friday and see only what is still outstanding.
• From The Interference Check, In One Click new: Place markers (CIT) in the Interference Check writes its result set to a one-shot file and hands it over. A Clash Importer already open on the same document takes the file itself and reloads — one window, not a second beside it; one open on a different document refuses, because the points belong to the other model, and a fresh window opens instead. Rows arrive with no status and sit on a (none) chip that is ticked like the others, so nothing loaded is dropped on the way to the Place page. Interference on Monday, markers on Monday.

• Cross-Link Clash Detection: Detects duct, flex duct, pipe, flex pipe, sprinkler, conduit and cable tray crossings — fittings and accessories optional — through walls (basic, stacked, curtain), floors, roofs and structural framing, including hosts in linked files. Catches openings the host model alone would miss.
• Review Grid + Filters: Results land in a review grid with isolate/zoom, sizes in mm plus fractional inches, host fire rating, and filters for host type, workset, phase and scope (model / view / selection), exportable to XLSX or XLS. Triage every crossing before you act.
• Auto-Placed Markers: Drops opening family instances at each crossing so openings can be coordinated and scheduled, writing each dimension only into a genuinely writable parameter and flagging names that don't resolve. A complete, schedulable opening set in one run — no silently-missed sizes.
• Live Schedule & 3D Preview: A real Revit category schedule of the openings the tool placed — it updates itself when an opening moves, resizes or is deleted, which is the one thing a schedule offers over the spreadsheet export — and a preview toggle that draws the staged opening boxes in the active view before anything is placed. See the opening set in the model, then commit it.

• Automated BOQ Engine: Classifies elements through a three-stage pipeline — material, fitting type, size — against the project's BOQ catalogue and writes SPEC_DESIGNATION (atomic BOQ number) and SPEC_DESCRIPTION across 17 MEP categories. Eliminates hours of manual referencing and instantly produces accurate Bills of Quantities.
• Smart Size Parsing: Reads messy inch strings and fractions (e.g. 1 1/2") and resolves them to metric Nominal Widths, with a fallback to Revit's native calculated size. Handles the real-world mess in supplier data.
• Catalogue Versions, Not Code: The catalogue is a validated JSON edited in the window, with a .bak of the last good file. A Units table (v2) makes the bill unit-aware; a Rates table (v3) adds Rate, Total and a currency grand total; and each project remembers its own catalogue and BOM library. The standard lives in data the project owns, not in the tool.
• Native Schedule, Rates & Write-Back new: Create / Update Schedule builds a multi-category BOQ – Bill ViewSchedule grouped by designation and filtered to classified elements — a second click updates it, appending fields the bill now carries and never removing yours. A catalogue that carries a Rates table adds Rate and Total columns and a cost grand total. On Reconcile, Apply Library Values writes the library's value back to ticked rows in one undoable transaction, and a write that Revit silently drops is reported as failed, never counted. The bill lands in Revit's own schedule, and the audit can fix what it finds.

• Needs No Equipment: The standard Revit report needs mechanical equipment with flow and pressure values filled in. Without them it says Not Computed. This tool asks for four things: the start element, the pressure there, the flow and the fluid. The pipework alone is enough.
• Reads The Network Itself: It reads the network through the connectors and splits the flow at every branch. Runs use Darcy-Weisbach. Fittings use a K coefficient from the family, from the Revit table, or from the tool’s own table.
• Elbows And Height Are Counted: Elbows are charged by the bend radius they are drawn with. Height counts unless the user switches it off. The friction method is a choice of four: Colebrook-White, Haaland, Swamee-Jain or Altshul-Tsal.
• Names The Critical Path: The result names the critical path, the turn along it and the pressure left at every outlet. Recommendations carry element ids.

• True Lengths, Cut Lengths, Figures Where A Reader Expects Them: Pipes keep their true length along the model axes, risers are vertical, and every pipe carries its cut length as a dimension. A figure stands above its line as it is read, never across it, and every level leg carries an elevation callout.
• Joints, Spools And Angles new: Every joint is tagged by its weld type — socket weld, field weld, flange, thread, groove — on the pipe side of the run, read from the pipe type. Spools are cut to a transport box, with field welds off the risers, and numbered. Elbow angles are written out, and an offset that is not square carries a hatched triangle.
• Symbols After The Fabricator’s Legend: Fittings and valves are drawn as symbols after the P&ID legend and were corrected against a Plant 3D library: a flanged union is a flange pair, a weld dot sits only at a weld, a coupling is a stroke across the pipe with a joint at each end, and its three tags fan on one side without crossing leaders. Runs, joint tags and spool tags print in the colours the reference sheets use.
• Laid Out In Your Title Block, With A Key Plan: The sheet is laid out inside the project’s own title block, keeping out of the areas its family already fills. A small 3D key plan shows where the sheet lies in the model, and five strips run under the drawing: general notes, line data, abbreviations, the bill of material of the sheet and the joint list. A set can start at any sheet number, and a large network is split into numbered sections.

• Reads Left To Right: Every pipe is a horizontal line one step long whatever its length in the model, with a flow arrow pointing away from the start. Sizes stand over the line once per row and wherever the size changes. Elbows, couplings and flanges are not drawn, because they change nothing in a flow diagram; the notes say how many were left out and the bill still lists them.
• Branches Never Cross: At a junction the run goes straight on along the connector opposite the one it came in by, a tee’s run rather than its branch, and every other way out drops to a row of its own below everything drawn before it. Branches off a branch nest the same way.
• The Machines At The Ends: The equipment, fixture or terminal a run starts from or ends at is a box with its tag, what it is, and the nozzle the run enters it by. The heading names the system and both ends; the strip under the drawing carries the lettered bill of material and your notes or the tool’s own.
• Fits One Sheet: The layout is in paper millimetres at a nominal step. A short run is spread out to use the content area, and a run too large is scaled down as a whole with the text and symbols keeping their size; the sheet says so when that goes below a third. Pick an end, or leave the branches off, when it does.

• Rooms From Wherever They Are: In an MEP model the architecture is usually a link, often several, each a copy or a part of the building, and the MEP may be split between this model and MEP links. Both are check lists: the rooms of this model, its spaces and the rooms of every loaded link on one side, this model and every link on the other. A room that appears in two sources is one room, and every source is asked at a point, because one model’s copy of a room stops at the ceiling while another’s reaches the slab.
• Placed By Points Along The Centreline: A run is sampled every half metre and placed by the room that holds most of it, or counted in every room it crosses with the length of each part. A fitting, terminal or support is placed by its insertion point; a support is found by its name in the categories supports are modelled in. What no room volume claims is placed by a kept room’s outline and height band, so a double-height plant room keeps the services over its mezzanine.
• A Plan Per Room, Painted By System: The PDF opens with the whole book as a table, then one page per room with its plan to scale, north up: walls and structure as their footprints, every run as a band as wide as it is, every fitting as its footprint, each in the ink of its system, the room’s length and width dimensioned on the plan. Or Revit’s own picture of the room, with the building greyed, every service painted in the report’s colours, and the legend read off the picture’s pixels.
• Three Outputs, One Scan: PDF REPORT writes the book; HTML writes one interactive page where a room opens on its plan and take-off and a line lights its elements up; XLSX writes three sheets of numbers that sum and sort. One file, or one file per storey. Click a room in the window and Revit selects what it holds, linked elements included. Export the book and read it; the model stays as it was.

• Reads Once, Then Follows The Keyboard: The first keystroke reads every text note in the model. After that the list follows the keyboard with no further Revit call. Results are grouped by the view that holds each note, with the matched part highlighted.
• Takes You To The Note: A click or the F3 key opens the note’s own view. The view zooms until the note sits in the middle, with drawing around it, and the note is selected. The space around the text is 30 mm by default, from 2 to 500. Next match is F3, previous is Shift+F3.
• Five Match Modes: Contains, whole word, exact text, wildcards (* and ?) and regular expressions. Match case is off by default. At most 500 result rows are drawn, while the counts, F3 and Replace still cover every match.
• Replace Asks First: Replace counts the changes first, asks, and then writes them in one transaction that Ctrl+Z undoes. Notes owned by another user, or changed since the read, are skipped and reported, never partly written.

• Six Formats, One Run: DWG, PDF, NWC, IFC, images and Excel from a single themeable shell with an in-window results log and a performance summary at the end. No more juggling separate export dialogs.
• Excel Without Excel: Schedules write to formatted .xlsx in a clean banded table style — via Excel when it's installed, or a built-in pure-Python OOXML writer (no COM, no install) that produces the same styling. Runs on any machine and protects values like Ø, 100×200 and DN.
• Clean CAD Deliverables: Embeds crisp logos and lays out schedule tables as clean OLE frames — an EMF picture or an editable embedded XLSX — in the exported CAD files, so titleblock artwork survives the DWG round-trip intact. CAD issues look like the Revit sheets.
• A Run That Checks Its Own Output new: At the end of every run the tool confirms each expected file exists, is non-zero and was written during this run; anything missing, empty or stale is named in the Export Log and the run's history record. A saved IFC setup from Revit's own exporter dialog can drive the IFC export, and when it cannot be applied the run finishes with warnings rather than a green headline. Output paths that would pass Windows' 259-character limit are computed before the DWG export and flagged with the two ways out. A transmittal that says it finished successfully actually did.

• Standards At Your Fingertips: Governed library folders plus pinned files, grouped by collection with live search and file-type facet chips — and a library-wide full-text search (Enter in the search box) that sweeps every document in the background: PDFs per page, plus Word, Excel, Markdown and text. A hit opens the document with every match highlighted; scanned PDFs with no text layer are flagged as not text-searched instead of silently skipped. Superseded local copies stop circulating.
• Native PDF Viewer/Editor: PDFs open in the suite's own IcZ.PdfView (PDFium rendering, zero external dependencies): continuous scroll, full-document search, text selection, highlight / text-box / freehand markup, page rotate-reorder-insert-delete-extract-merge, print, and save with annotations burned in. No Acrobat, no locked-down-machine failures.
• Preview & Edit In Place: Inline preview for Excel, Word (.docx rendered natively — tables, list numbering, images and hyperlinks intact; legacy .doc text-only), Markdown, code/text and images; Markdown and text files edit in place with crash-safe writes, and every file carries a plain-text Notes sidecar for redlines that never touches the original. Annotate the standard without altering it.

• Family Health Score: Runs the shared famqa scoring engine over the open family and draws a Health Radar & Report Card — a six-axis radar (Name, References, File, Plan View, Parameters, Structure) with clickable axis filters, an A–F grade badge, and a searchable findings list pivotable by group or severity. One glance tells you if the family is delivery-ready.
• Firm-Profile Driven: Checks come from a JSON profile (bundled default + a per-user %APPDATA% overlay) edited through a schema-generated settings form — no raw JSON editing. Retarget the standard by picking a profile, not touching code.
• Shareable Report: Exports a themed HTML scorecard via the shared reporthtml module for review outside Revit. Circulate the result without a Revit seat.
• Rename Overlay new: Collects every family whose name fails the profile's pattern, proposes new names from find / replace / prefix / suffix rules, and previews collisions — on disk, loaded in the model, or within the plan — before anything moves. Apply renames the .rfa and its type catalogue on disk (batch mode, with an undo map written first and a rollback on failure) and the loaded family in the model, one checked transaction each. Nothing is renamed until the preview has been shown for exactly this plan.

• Library, Not Loose Files: Scripts index from configurable shared folders with live search — the team's utility scripts one click from the ribbon, edited with Python syntax highlighting and saved in place. No more hunting network drives for the right macro.
• A Real Console In Revit: One persistent session scope with command history and code completion (Ctrl+Space or a typed dot); script runs share it by default so variables stay inspectable after a run, or opt into a fresh scope per run. doc/uidoc are re-injected at every execution — never stale. Debug against the live model interactively.
• ExternalEvent-Safe Execution: All script and REPL execution dispatches through icz.modeless.ExternalCall — never from a raw UI event — matching the suite's modeless contract. Console convenience without threading crashes.

Open the guide — bim-with-ai

Every page is generated from the same scripts that build the PowerPoint decks, so a slide cannot drift from its web page. The site is handed out by link rather than found by search — this page is one of the places the link lives.

Every pyRevit tool in the suite once re-solved the same problems: the Revit 2024 ElementId breaking change, modeless-window threading, theme duplication, worksharing guards, MEP connector hashing, and batch-export plumbing. The icz package pulls all of it into one dependency-free library, so each tool imports instead of reimplementing.

from icz import theme
from icz.shell import ShellWindow      # shared window chrome
from icz.modeless import ExternalCall  # ExternalEvent-safe model writes
from icz.revit_compat import eid       # Revit 2024+ ElementId shim

class ToolWindow(ShellWindow):         # inherit dots, nav-rail, theme
    ...

commit = ExternalCall(handler)         # call .raise_with(fn) from any click
key    = eid(element.Id)               # int, on any Revit version

 Only the public call surface is shown here — internal logic stays in the private repository.

A repository marked private has no link here on purpose. Each card says what the project does, so the page stays honest about code a visitor cannot open.

• Attaches By Default; Three Gates You Own: Out of the box the bridge attaches to a session you already opened. Three independent gates answer three different questions — may it drive the Revit process (off), may it model in the session (on), may it drive Dynamo live (off) — and a gated tool is absent from the tool list and refuses in-band if called from a stale cache, so it never spawns or reaches a wire. It can launch, and getting that wrong once cost real time: passing the model on the command line races add-in initialisation and takes the host down, so the launcher starts Revit bare, waits for the routes server to actually answer, and only then opens the document. Session lifetime is a switch you own, defaulted to off — not a capability the tool quietly assumes.
• Dry Run Is The Default — And It's Measured, Not Predicted: Without an explicit commit the work really executes inside a transaction that is then rolled back, so the outcome you read was measured against a model that never changed. On a delete, Revit reports every element it would remove including the dependents it takes with them. Navisworks cannot roll a transaction back, so there the dry run commits under its own label, undoes it only if the next undo record is its own, verifies the stacks, and reports undo.reverted as a measured true or false. The full cascade is visible before anything is destroyed.
• One Undoable Transaction, And Nothing Is Ever Saved: A committed write is a single named Transaction, so Ctrl+Z reverses it; destructive operations need an explicit confirmation on top of the commit flag. No route calls Save, Save As or Synchronize, and the code channel refuses a payload that does — the scan strips comments and requires an actual call, so a docstring mentioning it never false-refuses. The worst case a mistake reaches is an unsaved, undoable in-session change — what lands on disk stays your decision.
• Two Transports, One Prefix: The 90 modelling commands run over two transports behind one revit_cmd_* name — 64 execute in the first-party IcZ.Bridge add-in over a named pipe per process, which needs no pyRevit at all and serves several Revits at once; 26 run inside the pyRevit session over the discovered routes port. The two sets are disjoint and the harness asserts it in both directions, so the shared prefix can never let one channel silently shadow the other. Liveness is the pipe, never the pid — Windows recycles pids, and a bridge that had exited two days earlier once read alive because Office had been handed its number. A capability is advertised exactly where it works, and nowhere else.
• It Can See What It Did: A ribbon census, tool windows opened and closed with the proof being a measured window delta, a pyRevit reload proven by a changed session id, a live WPF visual-tree probe that reports rendered brushes and geometry, PNG captures of a view or a rendered window written to disk for the agent to read back — and revit_smoke, which turns the sequences a human used to click through into named, repeatable scenarios with their side effects declared up front. "Does it actually look right" stops being a screenshot request and becomes a check the agent runs itself.